datts_right 0.0.15 → 0.0.16

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    datts_right (0.0.14)
+    datts_right (0.0.15)
       datts_right
       rails (>= 3.0.0)
 

data/README.textile

@@ -20,7 +20,7 @@ h2. Installation
 Create a migration:
 
 <pre>
-class CreateDatts < ActiveRecord::Migration
+class CreateDynamicAttributes < ActiveRecord::Migration
   def self.up
     create_table(:dynamic_attributes) do |t|
       t.string :name, :null => false
@@ -36,9 +36,23 @@ class CreateDatts < ActiveRecord::Migration
     add_index "dynamic_attributes", ["attributable_id"], :name => "index_dynamic_attributes_on_attributable_id"
     add_index "dynamic_attributes", ["attributable_type"], :name => "index_dynamic_attributes_on_attributable_type"
     add_index "dynamic_attributes", ["attr_key"], :name => "index_dynamic_attributes_on_attr_key"
+
+    create_table(:dynamic_attribute_definitions) do |t|
+      t.text :definition
+      t.string :attribute_defineable_type, :null => false
+      t.integer :attribute_defineable_id, :null => false
+    end
+
+    add_index "dynamic_attribute_definitions", ["attribute_defineable_id"], :name => "index_dynamic_attribute_definitions_on_attribute_defineable_id"
+    add_index "dynamic_attribute_definitions", ["attribute_defineable_type"], :name => "index_dynamic_attribute_definitions_on_attribute_defineable_type"
   end
 
   def self.down
+    remove_index "dynamic_attribute_definitions", :name => "index_dynamic_attribute_definitions_on_attribute_defineable_id"
+    remove_index "dynamic_attribute_definitions", :name => "index_dynamic_attribute_definitions_on_attribute_defineable_type"
+
+    drop_table(:dynamic_attribute_definitions)
+
     remove_index "dynamic_attributes", :name => "index_dynamic_attributes_on_attr_key"
     remove_index "dynamic_attributes", :name => "index_dynamic_attributes_on_attributable_type"
     remove_index "dynamic_attributes", :name => "index_dynamic_attributes_on_attributable_id"
@@ -48,7 +62,6 @@ class CreateDatts < ActiveRecord::Migration
 end
 </pre>
 
-* *name* is not important at the moment, but I intend to make better use of it in the future.
 * *attr_key* the name of the dynamic attribute
 * *object_type* what type of value is saved. See "object_type":#object_type.
 * *attributable_id* and *attributable_type* are for the polymorphic association
@@ -78,9 +91,7 @@ pre. @user = User.create :name => "Roland Deschain"
 @user.write_dynamic_attribute :age, 820
 @user.save
 
-h3. @instance.dynamic_columns
-
-However, dynamic_attributes doesn't give us much information. What if we want to find out the list of dynamic attributes already available?
+h3. @instance.dynamic_attribute_details
 
 pre. @user.dynamic_attribute_details(:age) # Returns a dynamic attribute record, where you can access the following:
 @user.dynamic_attribute_details(:age).object_type # "integer"
@@ -99,6 +110,45 @@ You can also use:
 pre. find_all_by_dynamic_attribute
 find_last_by_dynamic_attribute
 
+h3. Mimicking ActiveRecord
+
+You can read and write the attributes directly:
+
+@page.age = 200 # here, age is a dynamic attribute
+@page.age # returns 200
+
+h3. Defining attributes
+
+If you want to define what attributes will exist, you can set an associated record to define what will attributes will automatically exist. Best explained by example:
+
+<pre>
+class Category < AR::Base
+  has_dynamic_attributes :definition => true
+  has_many :pages
+end
+
+class Page < AR::Base
+  has_dynamic_attributes :of => :category
+  belongs_to :category
+end
+</pre>
+
+pre. @category = Category.create
+@category.definition = {:price => {:object_type => "integer"}, :description => {:object_type => "text"}}
+@category.save
+@page = Page.create :category => category
+@page.price = 200
+@page.description = "hi there"
+
+What happened here was that for every definition in category, a dynamic attribute was created on every page that belongs to that category. These dynamic attributes are added to page after_create. That means if you change the definition of the category afterwards, then it won't affect the pages that already exist.
+
+The only thing that is *required* is @:price => {:object_type => "integer"}@ - you may add more information like: @:price => {:object_type => "integer", :name => "Price", :description => "How much this will cost."}@
+
+You can access all that other information this way:
+
+pre. @page.dynamic_attribute_details(:price).definer[:name] # "Price"
+@page.dynamic_attribute_details(:price).definer[:description] # "How much this will cost."
+
 h2. Stuff that make things faster
 
 The dynamic attributes are only actually saved when save is called on the record that has them.

data/VERSION

@@ -1 +1 @@
-0.0.15
+0.0.16

data/datts_right.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{datts_right}
-  s.version = "0.0.15"
+  s.version = "0.0.16"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ramon Tayag"]
-  s.date = %q{2011-04-18}
+  s.date = %q{2011-04-19}
   s.description = %q{Creates a separate table that saves all your dynamic attributes.}
   s.email = %q{ramon@tayag.net}
   s.extra_rdoc_files = [
@@ -29,7 +29,10 @@ Gem::Specification.new do |s|
     "VERSION",
     "datts_right.gemspec",
     "lib/datts_right.rb",
+    "lib/datts_right/base.rb",
+    "lib/datts_right/category.rb",
     "lib/datts_right/dynamic_attribute.rb",
+    "lib/datts_right/dynamic_attribute_definition.rb",
     "lib/datts_right/exceptions.rb",
     "lib/datts_right/instance_methods.rb",
     "lib/datts_right/page.rb",
@@ -37,6 +40,8 @@ Gem::Specification.new do |s|
     "spec/datt_spec.rb",
     "spec/datts_right/add_dynamic_attributes_spec.rb",
     "spec/datts_right/attributes_spec.rb",
+    "spec/datts_right/dynamic_attribute_definition_spec.rb",
+    "spec/datts_right/inheritance_spec.rb",
     "spec/datts_right/remove_dynamic_attribute_spec.rb",
     "spec/datts_right_spec.rb",
     "spec/spec_helper.rb"
@@ -50,6 +55,8 @@ Gem::Specification.new do |s|
     "spec/datt_spec.rb",
     "spec/datts_right/add_dynamic_attributes_spec.rb",
     "spec/datts_right/attributes_spec.rb",
+    "spec/datts_right/dynamic_attribute_definition_spec.rb",
+    "spec/datts_right/inheritance_spec.rb",
     "spec/datts_right/remove_dynamic_attribute_spec.rb",
     "spec/datts_right_spec.rb",
     "spec/spec_helper.rb"
@@ -230,6 +237,12 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
       s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<autotest>, [">= 0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
     else
       s.add_dependency(%q<datts_right>, [">= 0"])
       s.add_dependency(%q<rails>, [">= 3.0.0"])
@@ -402,6 +415,12 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
       s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<autotest>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
     end
   else
     s.add_dependency(%q<datts_right>, [">= 0"])
@@ -575,6 +594,12 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
     s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<autotest>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
   end
 end
 

data/lib/datts_right.rb

@@ -1,116 +1,6 @@
+require 'datts_right/base'
 require 'datts_right/instance_methods'
 require 'datts_right/dynamic_attribute'
+require 'datts_right/dynamic_attribute_definition'
 
-module DattsRight
-  def has_dynamic_attributes(options={})
-    include DattsRight::InstanceMethods
-    cattr_accessor :dynamic_attributes_options
-    self.dynamic_attributes_options = options
-
-    has_many :dynamic_attributes, :as => :attributable, :dependent => :destroy
-
-    # Carry out delayed actions before save
-    before_save :build_dynamic_attributes
-
-    after_find :cache_dynamic_attributes
-    default_scope includes(:dynamic_attributes)
-
-
-    # scope :scope_self when looking through attributes so we don't look through all dynamic_attributes
-    # Why? What if you have Friend and Page models. 
-    #   * Some Phone records have a dynamic_attribute :price
-    #   * Some Page records have a dynamic_attribute :price
-    #
-    #   When we do Page.find_by_price(400) we want to search only the dynamic_attributes that belong to Page
-    #     and we want to disregard the rest of the dynamic_attributes.
-    scope :scope_self, lambda { joins(:dynamic_attributes).where("dynamic_attributes.attributable_type = :klass", :klass => self.name) }
-    scope :with_datt_key, lambda { |args| with_dynamic_attribute_key(args) }
-    scope :with_dynamic_attribute_key, lambda { |datt_key| scope_self.joins(:dynamic_attributes).where("dynamic_attributes.attr_key = :datt_key", :datt_key => datt_key)}
-    scope :with_datt_type, lambda { |args| with_dynamic_attribute_type(args) }
-    scope :with_dynamic_attribute_type, lambda { |object_type| scope_self.joins(:dynamic_attributes).where("object_type = :object_type", :object_type => object_type) }
-
-    scope :order_by_datt, lambda { |attr_key_with_order, object_type| order_by_dynamic_attribute(attr_key_with_order, object_type) }
-    scope :order_by_dynamic_attribute, lambda { |attr_key_with_order, object_type|
-      # possible attr_key_with_order forms: "field_name", "field_name ASC", "field_name DESC"
-      split_attr_key_with_order = attr_key_with_order.split(" ")
-      attr_key = split_attr_key_with_order.first
-      order_by = split_attr_key_with_order.last if split_attr_key_with_order.size > 1
-      order_value = "dynamic_attributes.#{object_type}_value"
-      order_value << " #{order_by}" if order_by
-      scope_self.with_dynamic_attribute_key(attr_key).joins(:dynamic_attributes).with_dynamic_attribute_type(object_type).order(order_value)
-    }
-    
-    scope :where_datt, lambda { |opts| where_dynamic_attribute(opts) }
-    scope :where_dynamic_attribute, lambda { |opts|
-      # TODO accept stuff other than the normal hash
-      # Lifted from AR::Relation#build_where
-      attributes = case opts
-      when String, Array
-        self.expand_hash_conditions_for_aggregates(opts)
-      when Hash
-        opts
-      end
-      results = self
-      attributes.each do |k, v|
-        conditions = "exists (" +
-          "select 1 from dynamic_attributes dynamic_attribute where " +
-          "#{self.table_name}.id = dynamic_attribute.attributable_id " +
-          "and dynamic_attribute.attributable_type = :attributable_type " +
-          "and dynamic_attribute.name = :name and dynamic_attribute.#{DynamicAttribute.attr_column(v)} = :value" +
-        ")"
-        results = results.where(conditions, :attributable_type => self.name, :name => k.to_s, :value => v)
-      end
-      results
-    }
-
-    def self.method_missing(method_id, *arguments)
-      # TODO better way to hook this into the rails code, and not define my own
-      begin # Prioritize ActiveRecord's method_missing
-        super(method_id, *arguments)
-      rescue NoMethodError => e
-        if method_id.to_s =~ /^find_(all_|last_)?by_(dynamic_attribute|datt)_([_a-z]\w*)$/
-          all_or_last = $1
-          attributes = $3.split("_and_")
-          results = self
-          attributes.each_with_index do |attribute, i|
-            results = results.where_dynamic_attribute(attribute.to_sym => arguments[i])
-          end
-
-          case all_or_last
-          when "all_"
-            results
-          when "last_"
-            results.last
-          when nil
-            results.first
-          else
-            nil
-          end
-        else
-          raise e
-        end
-      end
-    end
-
-    # Override AR::Base#respond_to? so we can return the matchers even if the
-    # attribute doesn't exist in the actual columns. Is this expensive?
-    def respond_to?(method_id, include_private=false)
-      # TODO perhaps we could save a cache somewhere of all methods used by
-      # any of the records of this class. that way, we can make this method
-      # act a bit more like AR::Base#respond_to?
-      #   Ex:
-      #     return true if all_attributes_exists?(match.attribute_names) || all_dynamic_attributes_exists?(match.attribute_names)
-      if match = ActiveRecord::DynamicFinderMatch.match(method_id)
-        return true
-      elsif match = ActiveRecord::DynamicScopeMatch.match(method_id)
-        return true
-      end
-
-      super
-    end
-  end
-
-  alias :has_datts :has_dynamic_attributes 
-end
-
-ActiveRecord::Base.extend DattsRight
+ActiveRecord::Base.extend DattsRight::Base

data/lib/datts_right/base.rb

@@ -0,0 +1,117 @@
+module DattsRight
+  module Base
+    def has_dynamic_attributes(options={})
+      include DattsRight::InstanceMethods
+      cattr_accessor :dynamic_attributes_options
+      self.dynamic_attributes_options = options
+
+      has_many :dynamic_attributes, :as => :attributable, :dependent => :destroy
+      has_one :dynamic_attribute_definition, :as => :attribute_defineable, :dependent => :destroy
+      after_save :save_dynamic_attribute_definition
+      after_create :create_dynamic_attribute_definition, :inherit_definition
+      delegate :definition, :definition=, :to => :dynamic_attribute_definition
+
+      # Carry out delayed actions before save
+      before_save :build_dynamic_attributes
+
+      after_find :cache_dynamic_attributes
+      default_scope includes(:dynamic_attributes).includes(:dynamic_attribute_definition)
+
+
+      # scope :scope_self when looking through attributes so we don't look through all dynamic_attributes
+      # Why? What if you have Friend and Page models. 
+      #   * Some Phone records have a dynamic_attribute :price
+      #   * Some Page records have a dynamic_attribute :price
+      #
+      #   When we do Page.find_by_price(400) we want to search only the dynamic_attributes that belong to Page
+      #     and we want to disregard the rest of the dynamic_attributes.
+      scope :scope_self, lambda { joins(:dynamic_attributes).where("dynamic_attributes.attributable_type = :klass", :klass => self.name) }
+      scope :with_datt_key, lambda { |args| with_dynamic_attribute_key(args) }
+      scope :with_dynamic_attribute_key, lambda { |datt_key| scope_self.joins(:dynamic_attributes).where("dynamic_attributes.attr_key = :datt_key", :datt_key => datt_key)}
+      scope :with_datt_type, lambda { |args| with_dynamic_attribute_type(args) }
+      scope :with_dynamic_attribute_type, lambda { |object_type| scope_self.joins(:dynamic_attributes).where("object_type = :object_type", :object_type => object_type) }
+
+      scope :order_by_datt, lambda { |attr_key_with_order, object_type| order_by_dynamic_attribute(attr_key_with_order, object_type) }
+      scope :order_by_dynamic_attribute, lambda { |attr_key_with_order, object_type|
+        # possible attr_key_with_order forms: "field_name", "field_name ASC", "field_name DESC"
+        split_attr_key_with_order = attr_key_with_order.split(" ")
+        attr_key = split_attr_key_with_order.first
+        order_by = split_attr_key_with_order.last if split_attr_key_with_order.size > 1
+        order_value = "dynamic_attributes.#{object_type}_value"
+        order_value << " #{order_by}" if order_by
+        scope_self.with_dynamic_attribute_key(attr_key).joins(:dynamic_attributes).with_dynamic_attribute_type(object_type).order(order_value)
+      }
+      
+      scope :where_datt, lambda { |opts| where_dynamic_attribute(opts) }
+      scope :where_dynamic_attribute, lambda { |opts|
+        # TODO accept stuff other than the normal hash
+        # Lifted from AR::Relation#build_where
+        attributes = case opts
+        when String, Array
+          self.expand_hash_conditions_for_aggregates(opts)
+        when Hash
+          opts
+        end
+        results = self
+        attributes.each do |k, v|
+          conditions = "exists (" +
+            "select 1 from dynamic_attributes dynamic_attribute where " +
+            "#{self.table_name}.id = dynamic_attribute.attributable_id " +
+            "and dynamic_attribute.attributable_type = :attributable_type " +
+            "and dynamic_attribute.attr_key = :attr_key and dynamic_attribute.#{DynamicAttribute.attr_column(v)} = :value" +
+          ")"
+          results = results.where(conditions, :attributable_type => self.name, :attr_key => k.to_s, :value => v)
+        end
+        results
+      }
+
+      def self.method_missing(method_id, *arguments)
+        # TODO better way to hook this into the rails code, and not define my own
+        begin # Prioritize ActiveRecord's method_missing
+          super(method_id, *arguments)
+        rescue NoMethodError => e
+          if method_id.to_s =~ /^find_(all_|last_)?by_(dynamic_attribute|datt)_([_a-z]\w*)$/
+            all_or_last = $1
+            attributes = $3.split("_and_")
+            results = self
+            attributes.each_with_index do |attribute, i|
+              results = results.where_dynamic_attribute(attribute.to_sym => arguments[i])
+            end
+
+            case all_or_last
+            when "all_"
+              results
+            when "last_"
+              results.last
+            when nil
+              results.first
+            else
+              nil
+            end
+          else
+            raise e
+          end
+        end
+      end
+
+      # Override AR::Base#respond_to? so we can return the matchers even if the
+      # attribute doesn't exist in the actual columns. Is this expensive?
+      def respond_to?(method_id, include_private=false)
+        # TODO perhaps we could save a cache somewhere of all methods used by
+        # any of the records of this class. that way, we can make this method
+        # act a bit more like AR::Base#respond_to?
+        #   Ex:
+        #     return true if all_attributes_exists?(match.attribute_names) || all_dynamic_attributes_exists?(match.attribute_names)
+        if match = ActiveRecord::DynamicFinderMatch.match(method_id)
+          return true
+        elsif match = ActiveRecord::DynamicScopeMatch.match(method_id)
+          return true
+        end
+
+        super
+      end
+    end
+
+    alias :has_datts :has_dynamic_attributes 
+  end
+end

data/lib/datts_right/category.rb

@@ -0,0 +1,4 @@
+class Category < ActiveRecord::Base
+  has_dynamic_attributes :definition => true
+  has_many :pages
+end

data/lib/datts_right/dynamic_attribute.rb

@@ -2,6 +2,14 @@ class DynamicAttribute < ActiveRecord::Base
   # TODO
   # Set table name from configuration
   belongs_to :attributable, :polymorphic => true
+  belongs_to :dynamic_attribute_definition
+
+  # Returns the hash that defined this
+  def definer
+    defining_record = attributable.defining_record
+    return {} if defining_record.nil?
+    defining_record.definition[attr_key.to_sym]
+  end
 
   def value
     send("#{object_type}_value")

data/lib/datts_right/dynamic_attribute_definition.rb

@@ -0,0 +1,10 @@
+class DynamicAttributeDefinition < ActiveRecord::Base
+  belongs_to :attribute_defineable, :polymorphic => true
+
+  # definition should contain a json hash like this:
+  # {"body" => {"object_type" => "text"}}
+  #
+  # If you want more info, you can add other descriptions
+  # {"body" => {"object_type" => "text", "name" => "Body", "description" => "What the body will include"}}
+  serialize :definition
+end

data/lib/datts_right/instance_methods.rb

@@ -4,7 +4,7 @@ module DattsRight
       key = name.to_s.underscore
       return false if self.class.columns_hash[key] # if key already exists as a normal attribute
       unless dynamic_attribute?(key)
-        new_dynamic_attribute = dynamic_attributes.new :name => name, :attr_key => key, :object_type => object_type, "#{object_type}_value".to_sym => value
+        new_dynamic_attribute = dynamic_attributes.new :attr_key => key, :object_type => object_type, "#{object_type}_value".to_sym => value
         @dynamic_attributes_cache[key.to_sym] = new_dynamic_attribute
         return new_dynamic_attribute
       end
@@ -12,14 +12,9 @@ module DattsRight
     end
 
     def add_dynamic_attribute!(name, object_type, value=nil)
+      dynamic_attribute = add_dynamic_attribute(name, object_type, value)
+      dynamic_attribute.save if dynamic_attribute
       key = name.to_s.underscore
-      return false if self.class.columns_hash[key] # if key already exists as a normal attribute
-      unless dynamic_attribute?(key)
-        new_dynamic_attribute = dynamic_attributes.create! :name => name, :attr_key => key, :object_type => object_type, "#{object_type}_value".to_sym => value
-        @dynamic_attributes_cache[key.to_sym] = new_dynamic_attribute
-        return new_dynamic_attribute
-      end
-      return false
     end
 
     def remove_dynamic_attribute(name)
@@ -113,6 +108,11 @@ module DattsRight
       assign_multiparameter_attributes(multi_parameter_attributes)
     end
 
+    def defining_record
+      return nil if dynamic_attributes_options[:of].nil?
+      send dynamic_attributes_options[:of].to_s
+    end
+
     private
 
     # Called after validation on update so that dynamic attributes behave
@@ -120,19 +120,7 @@ module DattsRight
     # until save is called.
     def build_dynamic_attributes
       @dynamic_attributes_cache ||= {}
-      @dynamic_attributes_cache.each do |k, v|
-        #puts "about to save: #{v.inspect}"
-        v.save
-        #puts "Just to saved: #{v.inspect}"
-        #dynamic_attribute = dynamic_attributes.find_by_attr_key(k.to_s)
-        #value_column = "#{v[:object_type]}_value".to_sym
-        #if dynamic_attribute
-          #dynamic_attribute.update_attributes value_column => v[:value], :object_type => v[:object_type]
-        #else
-          ##@dynamic_attributes_cache[k] = dynamic_attributes.create! :name => k, :attr_key => k, value_column => v[:value], :object_type => v[:object_type]
-          #@dynamic_attributes_cache[k].save
-        #end
-      end
+      @dynamic_attributes_cache.each { |k, v| v.save }
     end
 
     def cache_dynamic_attributes
@@ -145,34 +133,38 @@ module DattsRight
     end
 
     def method_missing(method_id, *args, &body)
-      #begin
-        #method_missing_without_dynamic_attributes method_id, *args, &block
-      #rescue NoMethodError => e
-        #attr_name = method_id.to_s.sub(/\=$/, '')
-        #if is_dynamic_attribute?(attr_name)
-          #if method_id.to_s =~ /\=$/
-            #return write_attribute_with_dynamic_attributes(attr_name, args[0])
-          #else
-            #return read_attribute_with_dynamic_attributes(attr_name)
-          #end
-        #end
-        #raise e
-      #end
       begin
         super(method_id, *args, &body)
       rescue NoMethodError => e
         attr_name = method_id.to_s.sub(/\=$/, '')
         if dynamic_attribute?(attr_name)
-          #puts "#{attr_name} is a dynamic_attribute"
           method_id.to_s =~ /\=$/ ? write_dynamic_attribute(attr_name, args[0]) : read_dynamic_attribute(attr_name)
-        #else
-          #super(method_id, *args, &body) # send it to super again, so that any magic activerecord needs to do will still work
         else
           raise NoMethodError
         end
       end
     end
 
+    def save_dynamic_attribute_definition
+      dynamic_attribute_definition.save
+    end
+
+    def inherit_definition
+      #puts "In inherit_definition"
+      #puts "------- #{dynamic_attributes_options[:of]}"
+      #dynamic_attribute_definition.create if dynamic_attributes_options[:definition]
+      if dynamic_attributes_options[:of]
+        #puts "There is a defining record of #{self.class.name}##{self.name} in #{defining_record.inspect}. #{defining_record.dynamic_attribute_definition.inspect}"
+        if defining_record
+          defining_record.definition.each do |k, v|
+            datt = add_dynamic_attribute(k, v[:object_type])
+            datt.dynamic_attribute_definition
+            #puts "Added #{datt.inspect}"
+          end
+        end
+      end
+    end
+
     alias :add_datt :add_dynamic_attribute
     alias :add_datt! :add_dynamic_attribute!
     alias :remove_datt :remove_dynamic_attribute

data/lib/datts_right/page.rb

@@ -1,3 +1,4 @@
 class Page < ActiveRecord::Base
-  has_dynamic_attributes
+  belongs_to :category
+  has_dynamic_attributes :of => :category
 end

data/spec/datts_right/dynamic_attribute_definition_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe DynamicAttributeDefinition do
+  it "should serialize the definition" do
+    category = Category.create
+    category.definition = {:that => "is", :cool => "right?"}
+    category.definition[:that].should == "is"
+    category.definition[:cool].should == "right?"
+  end
+end

data/spec/datts_right/inheritance_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe DattsRight, "when inheriting the definition of an association" do
+  before do
+    @category = Category.create
+    @category.definition = {:teaser => {:object_type => "text"}, :price => {:object_type => "integer"}}
+    @category.save
+    @page = Page.create :category => @category
+  end
+  it "should create the dynamic attributes" do
+    @page.teaser = "hi"
+    @page.teaser.should == "hi"
+    @page.price = 200
+    @page.price.should == 200
+  end
+
+  it "should point to the dynamic attribute definition" do
+    @page.datt_details(:teaser).definer.should == {:object_type => "text"}
+    @page.datt_details(:price).definer.should == {:object_type => "integer"}
+  end
+end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require 'active_record/errors'
 require 'rspec'
 require 'datts_right'
 require 'datts_right/page'
+require 'datts_right/category'
 
 # Allow to connect to SQLite
 root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
@@ -24,14 +25,15 @@ RSpec.configure do |config|
 end
 
 def reset_database
-  %W(pages dynamic_attributes).each do |table_name|
+  %W(pages categories dynamic_attributes dynamic_attribute_definitions).each do |table_name|
     ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS '#{table_name}'")
   end
   ActiveRecord::Base.connection.create_table(:pages) do |t|
     t.string :name, :default => "My name"
+    t.integer :category_id
   end
   ActiveRecord::Base.connection.create_table(:dynamic_attributes) do |t|
-    t.string :name, :null => false
+    t.integer :dynamic_attribute_definition_id
     t.string :attr_key, :null => false
     t.string :object_type, :null => false
     t.string :attributable_type, :null => false
@@ -40,5 +42,13 @@ def reset_database
       t.send(type, "#{type}_value".to_sym)
     end
   end
+  ActiveRecord::Base.connection.create_table(:dynamic_attribute_definitions) do |t|
+    t.text :definition
+    t.string :attribute_defineable_type, :null => false
+    t.integer :attribute_defineable_id, :null => false
+  end
+  ActiveRecord::Base.connection.create_table(:categories) do |t|
+    t.string :name
+  end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: datts_right
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 63
   prerelease: 
   segments: 
   - 0
   - 0
-  - 15
-  version: 0.0.15
+  - 16
+  version: 0.0.16
 platform: ruby
 authors: 
 - Ramon Tayag
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-18 00:00:00 +08:00
+date: 2011-04-19 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -2584,6 +2584,96 @@ dependencies:
   name: rcov
   version_requirements: *id171
   prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id172 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: autotest
+  version_requirements: *id172
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id173 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: sqlite3
+  version_requirements: *id173
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id174 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  name: rspec
+  version_requirements: *id174
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id175 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  version_requirements: *id175
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id176 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  name: jeweler
+  version_requirements: *id176
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id177 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id177
+  prerelease: false
 description: Creates a separate table that saves all your dynamic attributes.
 email: ramon@tayag.net
 executables: []
@@ -2606,7 +2696,10 @@ files:
 - VERSION
 - datts_right.gemspec
 - lib/datts_right.rb
+- lib/datts_right/base.rb
+- lib/datts_right/category.rb
 - lib/datts_right/dynamic_attribute.rb
+- lib/datts_right/dynamic_attribute_definition.rb
 - lib/datts_right/exceptions.rb
 - lib/datts_right/instance_methods.rb
 - lib/datts_right/page.rb
@@ -2614,6 +2707,8 @@ files:
 - spec/datt_spec.rb
 - spec/datts_right/add_dynamic_attributes_spec.rb
 - spec/datts_right/attributes_spec.rb
+- spec/datts_right/dynamic_attribute_definition_spec.rb
+- spec/datts_right/inheritance_spec.rb
 - spec/datts_right/remove_dynamic_attribute_spec.rb
 - spec/datts_right_spec.rb
 - spec/spec_helper.rb
@@ -2655,6 +2750,8 @@ test_files:
 - spec/datt_spec.rb
 - spec/datts_right/add_dynamic_attributes_spec.rb
 - spec/datts_right/attributes_spec.rb
+- spec/datts_right/dynamic_attribute_definition_spec.rb
+- spec/datts_right/inheritance_spec.rb
 - spec/datts_right/remove_dynamic_attribute_spec.rb
 - spec/datts_right_spec.rb
 - spec/spec_helper.rb