initial import

Author: Jon Evans

MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jon Evans <jon@springyweb.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README

@@ -0,0 +1,61 @@
+InheritableAttributes
+=====================
+
+Useful if model attributes are to be inherited from a parent object if blank.
+
+Example
+=======
+
+class Company < ActiveRecord::Base
+  # company has an attribute "address"
+  has_many :divisions
+end
+
+class Division < ActiveRecord::Base
+  # division has an attribute "address"
+  belongs_to :company
+  
+  inherit_attribute :address, :from => :company
+end
+
+class Department < ActiveRecord::Base
+  # department has an attribute "address"
+  belongs_to :division
+  
+  inherit_attribute :address, :from => :division
+end
+
+
+d = Department.first
+
+d.address  #=> returns d.address, unless that value is blank, in which case
+               it returns d.division.address, unless that value is blank,
+               in which case it returns d.division.company.address
+
+
+You can also specify more than one attribute to inherit:
+
+class Department
+  # department has an attribute "address"
+  belongs_to :division
+  
+  inherit_attributes [:address, :telephone], :from => :division
+end
+
+If the attribute has a different name in the parent, you can use the :as
+option to specify it:
+
+class Depot < ActiveRecord::Base
+  belongs_to :company
+  
+  inherit_attribute :postal_address, :from => :company, :as => :address
+end
+
+d = Depot.first
+d.postal_address #=> returns d.postal_address, unless that value is blank,
+                     in which case it returns d.company.address
+
+
+Copyright (c) 2008 Jon Evans, Springy Web (UK) Ltd. Released under the MIT license
+
+jon@springyweb.com

Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the inheritable_attributes plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the inheritable_attributes plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'InheritableAttributes'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.class_eval { include InheritableAttributes }

lib/inheritable_attributes.rb

@@ -0,0 +1,27 @@
+# InheritableAttributes
+module InheritableAttributes
+  module ClassMethods
+    def inherit_attributes(attributes, options = {})
+      raise ArgumentError.new("must specify :from") unless options[:from]
+      parent = options[:from]
+      [attributes].flatten.each do |attribute|
+        parent_attribute = options[:as] || attribute
+        fn = <<-EOV
+          def #{attribute}_with_inheritance
+            val = #{attribute}_without_inheritance
+            
+            (val.blank? && ! parent.nil?) ? #{parent}.#{parent_attribute} : val
+          end
+          alias_method_chain :#{attribute}, :inheritance
+        EOV
+        class_eval fn
+      end
+    end
+    
+    alias inherit_attribute inherit_attributes
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+  end
+end

test/inheritable_attributes_test.rb

@@ -0,0 +1,123 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support/core_ext/blank'
+require 'active_support/core_ext/module/aliasing'
+require 'inheritable_attributes'
+
+class Thing
+  include InheritableAttributes
+
+  attr_reader :foo
+  
+  inherit_attribute :foo, :from=>:parent
+  
+  def initialize(parent, foo=nil)
+    @parent = parent
+    @foo = foo
+  end
+  
+  def read_attribute(attribute)
+    instance_variable_get("@#{attribute}")
+  end
+  
+  def parent
+    @parent
+  end
+end
+
+class Thing2 < Thing
+  attr_reader :bar, :baz
+  inherit_attributes [:bar, :baz], :from=>:parent
+  
+  def initialize(parent, foo=nil, bar=nil, baz=nil)
+    super(parent, foo)
+    @bar = bar
+    @baz = baz
+  end
+end
+
+class Thing3 < Thing
+  attr_reader :bar, :baz
+  inherit_attribute :bar, :from=>:parent, :as => :foo
+  inherit_attribute :baz, :from=>:parent
+  
+  def initialize(parent, foo=nil, bar=nil, baz=nil)
+    super(parent, foo)
+    @bar = bar
+    @baz = baz
+  end
+end
+
+class InheritableAttributesTest < Test::Unit::TestCase
+  def test_argument_error
+    assert_raise(ArgumentError) do
+      eval <<-EOF
+        class BadThing < Thing
+          inherit_attribute :bar
+        end
+      EOF
+    end
+  rescue
+    
+  end
+  def test_one_level
+    thing = Thing.new(nil, nil)
+    assert_equal(nil, thing.foo)
+    
+    thing = Thing.new(nil, "")
+    assert_equal("", thing.foo)
+    
+    thing = Thing.new(nil, :foo)
+    assert_equal(:foo, thing.foo)
+  end
+  
+  def test_two_levels
+    nil_parent = Thing.new(nil, nil)
+    parent = Thing.new(nil, :foo)
+    
+    # child's foo is nil
+    thing = Thing.new(nil_parent, nil)
+    assert_equal(nil, thing.foo)
+
+    thing = Thing.new(parent, nil)
+    assert_equal(:foo, thing.foo)
+
+    # child's foo is ""
+    thing = Thing.new(nil_parent, "")
+    assert_equal(nil, thing.foo)
+
+    thing = Thing.new(parent, "")
+    assert_equal(:foo, thing.foo)
+
+    # child's foo is :bar
+    thing = Thing.new(nil_parent, :bar)
+    assert_equal(:bar, thing.foo)
+
+    thing = Thing.new(parent, :bar)
+    assert_equal(:bar, thing.foo)
+  end
+  
+  def test_multi_vars
+    nil_parent = Thing2.new(nil)
+    parent = Thing2.new(nil, :foo_parent, :bar_parent, :baz_parent)
+
+    thing = Thing2.new(parent)
+    assert_equal(:foo_parent, thing.foo)
+    assert_equal(:bar_parent, thing.bar)
+    assert_equal(:baz_parent, thing.baz)
+
+    thing = Thing2.new(nil_parent, :foo, :bar, :baz)
+    assert_equal(:foo, thing.foo)
+    assert_equal(:bar, thing.bar)
+    assert_equal(:baz, thing.baz)
+  end
+  
+  def test_as
+    parent = Thing2.new(nil, :foo_parent, :bar_parent, :baz_parent)
+
+    thing = Thing3.new(parent)
+    assert_equal(:foo_parent, thing.foo)
+    assert_equal(:foo_parent, thing.bar)
+    assert_equal(:baz_parent, thing.baz)
+  end
+end