datts_right 0.0.7 → 0.0.8

data/Gemfile.lock

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

data/README.textile

@@ -11,8 +11,8 @@ h2. Why make this?
 # I needed to allow users to create their own dynamic attributes on certain records. I was already running PostgreSQL. My database and code was designed largely on relational structures. I was thinking of moving to MongoDB but saw that I'd pretty much have to rewrite all the models. Creating this gem was the first step to using dynamic attributes on my app.
 # The "available":http://codaset.com/joelmoss/dynamic-attributes "plugins":https://github.com/moiristo/dynamic_attributes out there that did something like this stuffed the dynamic attributes in a column in the model that had dynamic attributes. Because of this, you:
 ** Could not order things by dynamic columns straight with SQL
-** Could not (as far as I know) chain scopes, like so: @MyModel.where(:name_which_is_a_real_attribute => "Joe").where_datt(:phone_which_is_dynamic => "23218793")@
-** Could not find by dynamic attribute straight with SQL, like so: @MyModel.find_by_datt_phone_which_is_dynamic("2398291308")@
+** Could not (as far as I know) chain scopes, like so: @MyModel.where(:name_which_is_a_real_attribute => "Joe").where_dynamic_attribute(:phone_which_is_dynamic => "23218793")@
+** Could not find by dynamic attribute straight with SQL, like so: @MyModel.find_by_dynamic_attribute_phone_which_is_dynamic("2398291308")@
 ** Had to add migrations to each model that you wanted to have dynamic attributes
 
 h2. Installation
@@ -22,7 +22,7 @@ Create a migration:
 <pre>
 class CreateDatts < ActiveRecord::Migration
   def self.up
-    create_table(:datts) do |t|
+    create_table(:dynamic_attributes) do |t|
       t.string :name, :null => false
       t.string :attr_key, :null => false
       t.string :object_type, :null => false
@@ -33,17 +33,17 @@ class CreateDatts < ActiveRecord::Migration
       end
     end
 
-    add_index "datts", ["attributable_id"], :name => "index_datts_on_attributable_id"
-    add_index "datts", ["attributable_type"], :name => "index_datts_on_attributable_type"
-    add_index "datts", ["attr_key"], :name => "index_datts_on_attr_key"
+    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"
   end
 
   def self.down
-    remove_index "datts", :name => "index_datts_on_attr_key"
-    remove_index "datts", :name => "index_datts_on_attributable_type"
-    remove_index "datts", :name => "index_datts_on_attributable_id"
+    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"
 
-    drop_table(:datts)
+    drop_table(:dynamic_attributes)
   end
 end
 </pre>
@@ -60,7 +60,7 @@ Add this to your Gemfile:
 
 Add this to the model that you want to have dynamic attributes:
 
-@has_datts@
+@has_dynamic_attributes@
 
 h2. Usage
 
@@ -96,28 +96,28 @@ Returns true or false
 
 h3. Dynamic find
 
-pre. User.find_by_datt_age(240) # returns the first user with that age
+pre. User.find_by_dynamic_attribute_age(240) # returns the first user with that age
 
 You can also use:
 
-pre. find_all_by_datt
-find_last_by_datt
+pre. find_all_by_dynamic_attribute
+find_last_by_dynamic_attribute
 
 h2. Stuff that make things faster
 
 The dynamic attributes are only actually saved when save is called on the record that has them.
 
-pre. @user.add_dynamic_attribute(:gunslinger, "boolean") # a column is already written on the "datts" table, with a null value.
-@user.add_dynamic_attribute(:middle_name, "string") # a column is already written on the "datts" table, with a null value.
+pre. @user.add_dynamic_attribute(:gunslinger, "boolean") # a column is already written on the "dynamic_attributes" table, with a null value.
+@user.add_dynamic_attribute(:middle_name, "string") # a column is already written on the "dynamic_attributes" table, with a null value.
 @user.gunslinger = true # saves into memory
 @user.middle_name = "Unknown" # saves into memory
-@user.save # the respective dynamic attribute columns are written in the datts table
+@user.save # the respective dynamic attribute columns are written in the dynamic_attributes table
 
-h2. Structure of the datts table
+h2. Structure of the dynamic_attributes table
 
-Although you probably shouldn't work with it directly, the datts table looks like this:
+Although you probably shouldn't work with it directly, the dynamic_attributes table looks like this:
 
-pre. ActiveRecord::Base.connection.create_table(:datts) do |t|
+pre. ActiveRecord::Base.connection.create_table(:dynamic_attributes) do |t|
   t.string :name, :null => false
   t.string :attr_key, :null => false
   t.string :object_type, :null => false
@@ -128,10 +128,10 @@ pre. ActiveRecord::Base.connection.create_table(:datts) do |t|
   end
 end
 
-This means that depending on the type of dynamic attribute you're creating, things will get saved in the respective column in the datts table.
+This means that depending on the type of dynamic attribute you're creating, things will get saved in the respective column in the dynamic_attributes table.
 
 pre. @user.add_dynamic_attribute(:gunslinger, "boolean")
-adds this to the datts table: 
+adds this to the dynamic_attributes table: 
 
 pre. { 
   :attr_key => "gunslinger", 
@@ -172,7 +172,7 @@ h2. Ordering
 
 You can call
 
-pre. Product.order_datt("price", "float") # returns all users with their dynamic attribute "name" in ascending order
+pre. Product.order_dynamic_attribute("price", "float") # returns all users with their dynamic attribute "name" in ascending order
 
 Why pass the "float" in the order method? Because what if 2 different user records both have the dynamic attribute "price", but for one it's a float, and for the other it's an integer? How would you know which to order things by?
 
@@ -180,17 +180,17 @@ h2. Where
 
 You can do:
 
-pre. Product.where_datt(:price => 200.0, :rating => 5)
+pre. Product.where_dynamic_attribute(:price => 200.0, :rating => 5)
 
 As of now it accepts a hash only. If you want to scope to normal attributes, use the normal @where@ method.
 
-h2. Contributing to datts_right
+h2. Contributing to dynamic_attributes_right
 
 There are definitely things that don't work, and could be done better. For example, it would be nice to:
 
-# Do away with the special scopes, such as @where_datt@ and @order_datt@. I've tried to override ActiveRecord to make the normal @where@ and @order@ methods to see if the attributes being passed were dynamic, and do the changes necessary to the resulting SQL, but my head "started to hurt":http://stackoverflow.com/q/5590191/61018.
+# Do away with the special scopes, such as @where_dynamic_attribute@ and @order_dynamic_attribute@. I've tried to override ActiveRecord to make the normal @where@ and @order@ methods to see if the attributes being passed were dynamic, and do the changes necessary to the resulting SQL, but my head "started to hurt":http://stackoverflow.com/q/5590191/61018.
 # Have smarter caching, so that finds with dynamic attributes aren't very expensive.
-# Have configurable "datts" table
+# Have configurable "dynamic_attributes" table
 
 Warning: the code is full of comments because I needed to visualize the code running.
 

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/datts_right.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{datts_right}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ramon Tayag"]
@@ -29,14 +29,13 @@ Gem::Specification.new do |s|
     "VERSION",
     "datts_right.gemspec",
     "lib/datts_right.rb",
-    "lib/datts_right/datt.rb",
+    "lib/datts_right/dynamic_attribute.rb",
     "lib/datts_right/exceptions.rb",
     "lib/datts_right/instance_methods.rb",
     "lib/datts_right/page.rb",
     "lib/datts_right/query_methods.rb",
     "spec/datt_spec.rb",
     "spec/datts_right_spec.rb",
-    "spec/has_datts_migration_generator_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/ramontayag/datts_right}
@@ -47,7 +46,6 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/datt_spec.rb",
     "spec/datts_right_spec.rb",
-    "spec/has_datts_migration_generator_spec.rb",
     "spec/spec_helper.rb"
   ]
 
@@ -166,6 +164,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"])
@@ -278,6 +282,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"])
@@ -391,6 +401,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,45 +1,47 @@
 require 'datts_right/instance_methods'
-require 'datts_right/datt'
-#require 'datts_right/query_methods'
-#require 'datts_right/exceptions'
+require 'datts_right/dynamic_attribute'
 
 module DattsRight
-  def has_datts(options={})
+  def has_dynamic_attributes(options={})
     include DattsRight::InstanceMethods
     #include DattsRight::QueryMethods
     #ActiveRecord::QueryMethods.extend DattsRight::QueryMethods
     #include DattsRight::Exceptions
 
-    cattr_accessor :datts_options
-    self.datts_options = options
+    cattr_accessor :dynamic_attributes_options
+    self.dynamic_attributes_options = options
 
-    has_many :datts, :as => :attributable, :dependent => :destroy
+    has_many :dynamic_attributes, :as => :attributable, :dependent => :destroy
 
     # Carry out delayed actions before save
     before_save :build_dynamic_attributes
 
-    # scope :scope_self when looking through attributes so we don't look through all datts
+    # 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 datt :price
-    #   * Some Page records have a datt :price
+    #   * 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 datts that belong to Page
-    #     and we want to disregard the rest of the datts.
-    scope :scope_self, lambda { joins(:datts).where("datts.attributable_type = :klass", :klass => self.name) }
-    scope :dattr_key, lambda { |attr_key| scope_self.joins(:datts).where("datts.attr_key = :attr_key", :attr_key => attr_key)}
-    scope :dattr_type, lambda { |object_type| scope_self.joins(:datts).where("object_type = :object_type", :object_type => object_type) }
+    #   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_datt, lambda { |attr_key_with_order, 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 = "datts.#{object_type}_value"
+      order_value = "dynamic_attributes.#{object_type}_value"
       order_value << " #{order_by}" if order_by
-      scope_self.dattr_key(attr_key).joins(:datts).dattr_type(object_type).order(order_value)
+      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|
+    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
@@ -48,18 +50,13 @@ module DattsRight
       when Hash
         opts
       end
-      results = self#joins(:datts)
-      # Look for all DattsRight records whose:
-      #   1. Has all dynamic_attributes
-      #   2. Those dynamic attributes match there conditions
+      results = self
       attributes.each do |k, v|
         conditions = "exists (" +
-          "select 1 from datts datt where " +
-          # restricting the attributable_id to pages.id forces all the exists clauses to reference a single attributable record. Layman's terms, assuming Page uses datts_right:
-          # find only pages that has the matching dynamic attributes
-          "#{self.table_name}.id = datt.attributable_id " +
-          "and datt.attributable_type = :attributable_type " +
-          "and datt.name = :name and datt.#{Datt.attr_column(v)} = :value" +
+          "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
@@ -71,16 +68,14 @@ module DattsRight
       begin # Prioritize ActiveRecord's method_missing
         super(method_id, *arguments)
       rescue NoMethodError => e
-        #puts "Method missing: #{method_id}"
-        if method_id.to_s =~ /^find_(all_|last_)?by_datt_([_a-z]\w*)$/
+        if method_id.to_s =~ /^find_(all_|last_)?by_(dynamic_attribute|datt)_([_a-z]\w*)$/
           all_or_last = $1
-          attributes = $2.split("_and_")
+          attributes = $3.split("_and_")
           results = self
           attributes.each_with_index do |attribute, i|
-            results = results.where_datt(attribute.to_sym => arguments[i])
+            results = results.where_dynamic_attribute(attribute.to_sym => arguments[i])
           end
 
-          #puts "this is $1 of the method '#{method_id}': #{all_or_last}."
           case all_or_last
           when "all_"
             results
@@ -94,39 +89,6 @@ module DattsRight
         else
           raise e
         end
-
-        #if method_id.to_s =~ /^find_(all_|last_)by_datt_([_a-z]\w*)$/
-          #all_or_last = $1
-          #attributes = $2.split("_and_")
-          #results = self
-          #attributes.each_with_index do |attribute, i|
-            #results = results.where_datt(attribute.to_sym => arguments[i])
-          #end
-
-          #puts "this is $1 of the method '#{method_id}': #{all_or_last}."
-          #case all_or_last
-          #when "all_"
-            #results
-          #when "last_"
-            #results.last
-          #else
-            #nil
-          #end
-        #elsif method_id.to_s =~ /^find_by_datt_([_a-z]\w*)$/
-          ##puts "returning a find_by_datt_#{$1}"
-          #attributes = $1.split("_and_")
-          ##puts "here are the attributes: #{attributes.inspect}"
-          #results = self
-          #attributes.each_with_index do |attribute, i|
-            ##puts "Adding where_datt(:#{attribute} => #{arguments[i]})"
-            #results = results.where_datt(attribute.to_sym => arguments[i])
-          #end
-
-          ##puts "Will return the FIRST of #{results.to_sql}"
-          #results.first
-        #else
-          #nil
-        #end
       end
     end
 
@@ -147,6 +109,8 @@ module DattsRight
       super
     end
   end
+
+  alias :has_datts :has_dynamic_attributes 
 end
 
 ActiveRecord::Base.extend DattsRight

data/lib/datts_right/{datt.rb → dynamic_attribute.rb}

@@ -1,4 +1,4 @@
-class Datt < ActiveRecord::Base
+class DynamicAttribute < ActiveRecord::Base
   # TODO
   # Set table name from configuration
   belongs_to :attributable, :polymorphic => true

data/lib/datts_right/instance_methods.rb

@@ -1,15 +1,15 @@
 module DattsRight
   module InstanceMethods
     def add_dynamic_attribute(name, klass)
-      unless attributes.keys.include?(name.to_s)
-        name = name.to_s
-        datt = datts.find_by_attr_key(name.underscore)
-        unless datt
-          datt = datts.create :name => name, :attr_key => name.underscore, :object_type => klass
+      key = name.to_s
+      unless attributes.keys.include?(key)
+        dynamic_attribute = dynamic_attributes.find_by_attr_key(key.underscore)
+        unless dynamic_attribute
+          dynamic_attribute = dynamic_attributes.create :name => key, :attr_key => key.underscore, :object_type => klass
           dynamic_columns(true)
         end
-        #puts "Just added #{name} to #{self.class.name}##{id}, and here are the dynamic_attributes: #{dynamic_columns}"
-        datt
+        #puts "Just added #{key} to #{self.class.name}##{id}, and here are the dynamic_attributes: #{dynamic_columns.inspect}"
+        dynamic_attribute
       else
         false
       end
@@ -17,25 +17,26 @@ module DattsRight
 
     def remove_dynamic_attribute(name)
       name = name.to_s
-      datt = datts.find_by_attr_key(name)
-      if datt
-        datt.destroy
+      dynamic_attribute = dynamic_attributes.find_by_attr_key(name)
+      if dynamic_attribute
+        dynamic_attribute.destroy
         dynamic_columns(true)
       end
     end
 
     # Works like ActiveRecord's attributes except it returns dynamic attributes only
-    def dynamic_attributes(reload=false)
-      @dynamic_attributes ||= {}
-      return @dynamic_attributes if !reload
-      #puts "Reloading dynamic_attributes"
-      datts.each do |datt|
-        #puts "Adding this to @dynamic_attributes: #{datt.attr_key} => #{datt.value}"
-        @dynamic_attributes.merge({datt.attr_key => datt.value}) 
-      end
-      #puts "Here are teh datts: #{datts.inspect}, and this is what we're returning: #{@dynamic_attributes}"
-      @dynamic_attributes.symbolize_keys!
-    end
+    #def dynamic_attributes(reload=false)
+      #puts "dynamic_attributes called with reload? #{reload}"
+      #@dynamic_attributes ||= {}
+      #return @dynamic_attributes if !reload
+      ##puts "Reloading dynamic_attributes"
+      #dynamic_attributes.each do |dynamic_attribute|
+        ##puts "Adding this to @dynamic_attributes: #{dynamic_attribute.attr_key} => #{dynamic_attribute.value}"
+        #@dynamic_attributes.merge({dynamic_attribute.attr_key => dynamic_attribute.value}) 
+      #end
+      ##puts "Here are teh dynamic_attributes: #{dynamic_attributes.inspect}, and this is what we're returning: #{@dynamic_attributes}"
+      #@dynamic_attributes.symbolize_keys!
+    #end
 
     # Because we cannot determine the difference between the inexistence
     # between key value pair point to nil (eg :hi => nil) and
@@ -45,18 +46,18 @@ module DattsRight
     def dynamic_columns(reload=false)
       @dynamic_columns ||= {}
       @dynamic_columns if !reload
-      #puts "Building the dynamic_columns cache, and we'll look through #{datts.count} datts"
+      #puts "Building the dynamic_columns cache, and we'll look through #{dynamic_attributes.count} dynamic_attributes"
       @dynamic_columns={}
-      datts.reload
-      datts.each do |datt|
-        #puts "Going through datt##{datt.id}"
+      dynamic_attributes.reload
+      dynamic_attributes.each do |dynamic_attribute|
+        #puts "Going through dynamic_attribute##{dynamic_attribute.id}"
         dynamic_column = {
-          datt.attr_key.to_sym => {
-            :object_type => datt.object_type,
-            :value => datt.value
+          dynamic_attribute.attr_key.to_sym => {
+            :object_type => dynamic_attribute.object_type,
+            :value => dynamic_attribute.value
           }
         }
-        #puts "Added #{dynamic_column} to the dynamic columns"
+        #puts "Added #{dynamic_column.inspect} to the dynamic columns"
         @dynamic_columns.merge!(dynamic_column)
       end
       #puts "in dynamic_columns, returning: #{@dynamic_columns.inspect}"
@@ -65,7 +66,7 @@ module DattsRight
 
     # Determines if the given attribute is a dynamic attribute.
     def dynamic_attribute?(attr)
-      #puts "in dynamic_attribute?(:#{attr}). datts: #{datts.inspect}. Datt: #{Datt.all.inspect}"
+      #puts "in dynamic_attribute?(:#{attr}). dynamic_attributes: #{dynamic_attributes.inspect}. Datt: #{Datt.all.inspect}"
       #dynamic_columns.include?(attr.to_s)
       !dynamic_columns[attr.to_sym].nil?
       #return dynamic_attributes.include?(attr.to_sym) unless dynamic_attributes.empty?
@@ -94,101 +95,44 @@ module DattsRight
       #assign_multiparameter_attributes(multi_parameter_attributes)
     #end
 
-    # Overrides AR::Persistence#update_attributes
-    # Needed to change it because the AR::Persistence method updated the attributes
-    # method directly.
-    #   Ex.
-    #     self.attributes = attributes
-    #
-    # That won't work because our dynamic attributes aren't in the attributes field
-    def update_attributes(attributes)
+    def update_dynamic_attributes(attributes)
       # The following transaction covers any possible database side-effects of the
       # attributes assignment. For example, setting the IDs of a child collection.
       with_transaction_returning_status do
-        attributes.each do |k, v|
-          self.send("#{k}=", v)
+        attributes.symbolize_keys.each do |k, v|
+          self.write_dynamic_attribute(k, v)
         end
         save
       end
     end
 
-    # Overrides AR::Persistence#update_attributes!
-    # See DattsRight#update_attributes for the reason why
-    def update_attributes!(attributes)
+    def update_dynamic_attributes!(attributes)
       with_transaction_returning_status do
-        attributes.each do |k, v|
-          self.send("#{k}=", v)
+        attributes.symbolize_keys.each do |k, v|
+          self.write_dynamic_attribute(k, v)
         end
         save!
       end
     end
 
-    private
-
-    # Called after validation on update so that dynamic attributes behave
-    # like normal attributes in the fact that the database is not touched
-    # until save is called.
-    def build_dynamic_attributes
-      return if @save_dynamic_attr.nil?
-      # This originally saves things into the "datts" column.
-      #write_attribute_without_dynamic_attributes "datts", @save_dynamic_attr
-      # We save things into the datts table
-      @save_dynamic_attr.each do |k, v|
-        k = k.to_s
-        datt = datts.find_by_attr_key(k)
-        #puts "to create or to update #{k}?"
-        if datt
-          datt.update_attribute(:value, v)
-          #puts "updated: #{datt.inspect}"
-        #else
-          #datt = datts.create! :name => k, :attr_key => k, :value => v
-          #puts "created: #{datt.inspect} among these datts: #{datts.inspect}"
-        end
-      end
-      @save_dynamic_attr = {}
-      true
-    end
-
-    # Implements dynamic-attributes as if real getter/setter methods
-    # were defined.
-    def method_missing(method_id, *args, &block)
-      puts "in DattsRight::InstanceMethods#method_missing with method_id #{method_id}"
-      begin
-        super method_id, *args, &block
-      rescue NoMethodError => e
-        puts "AR doesn't have #{method_id} so DattsRight will take care of it instead"
-        attr_name = method_id.to_s.sub(/\=$/, '')
-        #puts "Now we check to see if price is a dynamic attribute. dynamic_columns: #{dynamic_columns}. is #{attr_name} in those dynamic_columns? #{dynamic_attribute?(attr_name)}"
-        if dynamic_attribute?(attr_name)
-          #puts "== And #{method_id} is a dynamic method"
-          if method_id.to_s =~ /\=$/
-            return write_attribute(attr_name, args[0])
-          else
-            return read_attribute(attr_name)
-          end
-        end
-        raise e
-      end
-    end
-
     # Overrides AR::Base#read_attribute
-    def read_attribute(attr_name)
+    def read_dynamic_attribute(attr_name)
       attr_name = attr_name.to_s
       if dynamic_attribute?(attr_name)
-        #puts "trying to read datt #{attr_name}"
+        #puts "trying to read dynamic_attribute #{attr_name}"
         # If value is in the @save_dynamic_attr cache, and it's not blank
         if !@save_dynamic_attr.blank? and @save_dynamic_attr[attr_name]
-          #puts "datt #{attr_name} IS in cache, so let's return its value"
+          #puts "dynamic_attribute #{attr_name} IS in cache, so let's return its value"
           # Then we return the value
           return @save_dynamic_attr[attr_name]
         else # The value is not there, or it's blank
-          #puts "datt #{attr_name} is NOT in cache, so let's load it from the datt table"
+          #puts "dynamic_attribute #{attr_name} is NOT in cache, so let's load it from the dynamic_attribute table"
           #attrs = read_attribute_without_dynamic_attributes(dynamic_attributes_options[:column_name].to_s)
-          #puts "Here are ALL the datts: #{Datt.all.inspect} and my id is: #{id}"
-          #puts "Here are my the datts: #{datts.inspect} and my id is: #{id}. and the first datt's value is #{datts.first.value}"
-          datt = datts.find_by_attr_key(attr_name)
-          #puts "This is the dat I find: #{datt.inspect}"
-          return datt.try(:value)
+          #puts "Here are ALL the dynamic_attributes: #{Datt.all.inspect} and my id is: #{id}"
+          #puts "Here are my the dynamic_attributes: #{dynamic_attributes.inspect} and my id is: #{id}. and the first dynamic_attribute's value is #{dynamic_attributes.first.value}"
+          dynamic_attribute = dynamic_attributes.find_by_attr_key(attr_name)
+          #puts "This is the dat I find: #{dynamic_attribute.inspect}"
+          return dynamic_attribute.try(:value)
           #attrs = attrs.nil? ? nil : YAML.load(attrs).symbolize_keys! unless attrs.is_a? Hash
           #return nil if attrs.blank?
           #return attrs[attr_name.to_sym]
@@ -199,7 +143,7 @@ module DattsRight
     end
 
     # Overrides AR::Base#write_attribute
-    def write_attribute(attr_name, value)
+    def write_dynamic_attribute(attr_name, value)
       #puts "attempting to write: #{attr_name} = #{value}"
       if dynamic_attribute?(attr_name)
         #puts "#{attr_name} is a dynamic_attribute"
@@ -207,9 +151,62 @@ module DattsRight
         
         @save_dynamic_attr ||= {} # create the cache if needed
         return @save_dynamic_attr[attr_name] = value
+        return nil
       end
-      
-      super(attr_name, value)
     end
+
+    private
+
+    # Called after validation on update so that dynamic attributes behave
+    # like normal attributes in the fact that the database is not touched
+    # until save is called.
+    def build_dynamic_attributes
+      return if @save_dynamic_attr.nil?
+      # This originally saves things into the "dynamic_attributes" column.
+      #write_attribute_without_dynamic_attributes "dynamic_attributes", @save_dynamic_attr
+      # We save things into the dynamic_attributes table
+      @save_dynamic_attr.each do |k, v|
+        k = k.to_s
+        dynamic_attribute = dynamic_attributes.find_by_attr_key(k)
+        #puts "to create or to update #{k}?"
+        if dynamic_attribute
+          dynamic_attribute.update_attribute(:value, v)
+          #puts "updated: #{dynamic_attribute.inspect}"
+        #else
+          #dynamic_attribute = dynamic_attributes.create! :name => k, :attr_key => k, :value => v
+          #puts "created: #{dynamic_attribute.inspect} among these dynamic_attributes: #{dynamic_attributes.inspect}"
+        end
+      end
+      @save_dynamic_attr = {}
+      true
+    end
+
+    # Implements dynamic-attributes as if real getter/setter methods
+    # were defined.
+    #def method_missing(method_id, *args, &block)
+      #puts "in DattsRight::InstanceMethods#method_missing with method_id #{method_id}"
+      #begin
+        #super method_id, *args, &block
+      #rescue NoMethodError => e
+        #puts "AR doesn't have #{method_id} so DattsRight will take care of it instead"
+        #attr_name = method_id.to_s.sub(/\=$/, '')
+        ##puts "Now we check to see if price is a dynamic attribute. dynamic_columns: #{dynamic_columns}. is #{attr_name} in those dynamic_columns? #{dynamic_attribute?(attr_name)}"
+        #if dynamic_attribute?(attr_name)
+          ##puts "== And #{method_id} is a dynamic method"
+          #if method_id.to_s =~ /\=$/
+            #return write_attribute(attr_name, args[0])
+          #else
+            #return read_attribute(attr_name)
+          #end
+        #end
+        #raise e
+      #end
+    #end
+
+    alias :add_datt :add_dynamic_attribute
+    alias :remove_datt :remove_dynamic_attribute
+    alias :read_datt :read_dynamic_attribute
+    alias :write_datt :write_dynamic_attribute
+    alias :update_dynamic_attribute :write_dynamic_attribute
   end
 end

data/lib/datts_right/page.rb

@@ -1,3 +1,3 @@
 class Page < ActiveRecord::Base
-  has_datts
+  has_dynamic_attributes
 end

data/spec/datt_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe Datt do
+describe DynamicAttribute do
   before do
     reset_database
     @page = Page.create
@@ -8,13 +8,13 @@ describe Datt do
 
   it "should allow transferring between String and Text" do
     @page.add_dynamic_attribute(:foo, "string")
-    @page.foo = "this is a string"
+    @page.write_dynamic_attribute :foo, "this is a string"
     @page.save
-    @page.foo = "t"*300
+    @page.write_dynamic_attribute :foo, "t"*300
     @page.save
-    @page.datts.find_by_attr_key("foo").object_type.should == "text"
-    @page.foo = "this is a string again"
+    @page.dynamic_attributes.find_by_attr_key("foo").object_type.should == "text"
+    @page.write_dynamic_attribute :foo, "this is a string again"
     @page.save
-    @page.datts.find_by_attr_key("foo").object_type.should == "string"
+    @page.dynamic_attributes.find_by_attr_key("foo").object_type.should == "string"
   end
 end

data/spec/datts_right_spec.rb

@@ -7,9 +7,13 @@ describe DattsRight do
   end
 
   describe ".add_dynamic_attribute(attr_key, object_type)" do
+    it "should be aliased by add_datt" do
+      Page.instance_method(:add_dynamic_attribute).should == Page.instance_method(:add_datt)
+    end
+
     it "should add a dynamic attribute with nil value" do
       @page.add_dynamic_attribute(:rocks, "string")
-      @page.dynamic_attributes[:rocks].should be_nil
+      @page.dynamic_columns[:rocks][:value].should be_nil
     end
 
     it "should ignore when trying to add same attribute" do
@@ -30,6 +34,10 @@ describe DattsRight do
   end
 
   describe ".remove_dynamic_attribute(attr_key)" do
+    it "should be aliased by remove_datt" do
+      Page.instance_method(:remove_dynamic_attribute).should == Page.instance_method(:remove_datt)
+    end
+
     it "should remove the attribute completely" do
       @page.add_dynamic_attribute(:rocks, "string")
       @page.remove_dynamic_attribute(:rocks)
@@ -60,115 +68,129 @@ describe DattsRight do
 
   it "should allow saving of integers" do
     @page.add_dynamic_attribute(:price, "integer")
-    @page.price = 300
+    @page.write_dynamic_attribute :price, 300
     @page.save
     @page = Page.last
-    @page.price.should == 300
+    @page.read_dynamic_attribute(:price).should == 300
   end
 
   it "should allow saving of floats" do
     @page.add_dynamic_attribute(:price, "float")
-    @page.price = 300.0
+    @page.write_dynamic_attribute :price, 300.0
     @page.save
     @page = Page.last
-    @page.price.should == 300.0
+    @page.read_dynamic_attribute(:price).should == 300.0
   end
 
   it "should allow saving of true" do
     @page.add_dynamic_attribute(:real, "boolean")
-    @page.real = true
+    @page.write_dynamic_attribute :real, true
     @page.save
     @page = Page.last
-    @page.real.should be_true
+    @page.read_dynamic_attribute(:real).should be_true
   end
 
   it "should allow saving of false" do
     @page.add_dynamic_attribute(:real, "boolean")
-    @page.real = false
+    @page.write_dynamic_attribute :real, false
     @page.save
     @page = Page.last
-    @page.real.should be_false
+    @page.read_dynamic_attribute(:real).should be_false
   end
 
   it "should allow saving of strings" do
     @page.add_dynamic_attribute(:real, "string")
-    @page.real = "its real alright"
+    @page.write_dynamic_attribute :real, "its real alright"
     @page.save
     @page = Page.last
-    @page.real.should == "its real alright"
+    @page.read_dynamic_attribute(:real).should == "its real alright"
   end
 
   it "should allow saving of text" do
     @page.add_dynamic_attribute(:real, "text")
-    @page.real = "t"*256
+    @page.write_dynamic_attribute :real, "t"*256
     @page.save
     @page = Page.last
-    @page.real.should == "t"*256
+    @page.read_dynamic_attribute(:real).should == "t"*256
   end
 
   it "should cache the attribute" do
     @page.add_dynamic_attribute(:price, "integer")
-    @page.price = 200
-    @page.price.should == 200
+    @page.write_dynamic_attribute :price, 200
+    @page.read_dynamic_attribute(:price).should == 200
   end
 
   it "should not save the attribute if save on the attributable object isn't called" do
     @page.add_dynamic_attribute(:price, "integer")
-    @page.price = 200
+    @page.write_dynamic_attribute :price, 200
     @page = Page.last
-    @page.price.should be_nil
+    @page.read_dynamic_attribute(:price).should be_nil
   end
 
   it "should allow overwriting of values" do
     @page.add_dynamic_attribute(:price, "integer")
-    @page.price = 200
+    @page.write_dynamic_attribute :price, 200
     @page.save
     @page = Page.last
-    @page.price = 300
+    @page.write_dynamic_attribute :price, 300
     @page.save
     @page = Page.last
-    @page.price.should == 300
+    @page.read_dynamic_attribute(:price).should == 300
   end
 
   it "should allow nullifying of attributes, but keeping the fields there" do
     @page.add_dynamic_attribute(:farce, "string")
-    @page.farce = "Nothing here my friend"
+    @page.write_dynamic_attribute :farce, "Nothing here my friend"
     @page.save
-    @page.farce = nil
+    @page.write_dynamic_attribute :farce, nil
     @page.dynamic_attribute?(:farce).should be_true
   end
 
-  describe "on dynamic find_by_datt methods" do
+  describe ".read_dynamic_attribute" do
+    it "should be aliased by read_datt" do
+      Page.instance_method(:read_dynamic_attribute).should == Page.instance_method(:read_datt)
+    end
+  end
+
+  describe "on dynamic find_by_dynamic_attribute methods" do
+    it "should be aliased by find_by_datt" do
+      @page.add_dynamic_attribute(:price, "integer")
+      @page.write_dynamic_attribute :price, 400
+      @page.save
+      Page.find_by_datt_price(400).should == Page.find_by_dynamic_attribute_price(400)
+    end
+
     it "should be able to return single records" do
       @page.add_dynamic_attribute(:price, "integer")
-      @page.price = 400
+      @page.write_dynamic_attribute :price, 400
       @page.save
 
       @page_2 = Page.create
       @page_2.add_dynamic_attribute(:price, "integer")
-      @page_2.price = 500
+      @page_2.write_dynamic_attribute :price, 500
       @page_2.save
 
-      Page.find_by_datt_price(400).should == @page
-      Page.find_by_datt_price(400).should_not == @page_2
+      @results = Page.find_by_dynamic_attribute_price(400)
+      @results.should == @page
+      @results.should_not == @page_2
     end
 
     it "should be able to return all matching records" do
       @page.add_dynamic_attribute(:price, "integer")
-      @page.price = 400
+      @page.write_dynamic_attribute :price, 400
       @page.save
 
       @page_2 = Page.create
       @page_2.add_dynamic_attribute(:price, "integer")
-      @page_2.price = 500
+      @page_2.write_dynamic_attribute :price, 500
       @page_2.save
 
       @page_3 = Page.create
       @page_3.add_dynamic_attribute(:price, "integer")
-      @page_3.price = 400
+      @page_3.write_dynamic_attribute :price, 400
       @page_3.save
 
-      @results = Page.find_all_by_datt_price(400)
+      @results = Page.find_all_by_dynamic_attribute_price(400)
       @results.should include(@page)
       @results.should_not include(@page_2)
       @results.should include(@page_3)
@@ -180,15 +202,15 @@ describe DattsRight do
 
     it "should be able to return the last record" do
       @page.add_dynamic_attribute(:price, "integer")
-      @page.price = 400
+      @page.write_dynamic_attribute :price, 400
       @page.save
 
       @page_2 = Page.create
       @page_2.add_dynamic_attribute(:price, "integer")
-      @page_2.price = 400
+      @page_2.write_dynamic_attribute :price, 400
       @page_2.save
 
-      Page.find_last_by_datt_price(400) == @page_2
+      Page.find_last_by_dynamic_attribute_price(400) == @page_2
     end
 
     it "should allow normal attributes to work" do
@@ -201,15 +223,15 @@ describe DattsRight do
     it "should allow chaining" do
       @page.add_dynamic_attribute(:price, "integer")
       @page.name = "fixed"
-      @page.price = 400
+      @page.write_dynamic_attribute :price, 400
       @page.save
 
       @page_2 = Page.create
       @page_2.add_dynamic_attribute(:price, "integer")
-      @page_2.price = 500
+      @page_2.write_dynamic_attribute :price, 500
       @page_2.save
 
-      @pages = Page.where(:name => "fixed").find_by_datt_price(400)
+      @pages = Page.where(:name => "fixed").find_by_dynamic_attribute_price(400)
       @pages.should == @page
       @pages.should_not == @page_2
     end
@@ -217,19 +239,19 @@ describe DattsRight do
 
   it "should allow multiple attributes" do
     @page.add_dynamic_attribute(:price, "integer")
-    @page.price = 400
+    @page.write_dynamic_attribute :price, 400
     @page.add_dynamic_attribute(:farce, "string")
-    @page.farce = "hitt"
+    @page.write_dynamic_attribute :farce, "hitt"
     @page.save
 
     @page_2 = Page.create
     @page_2.add_dynamic_attribute(:price, "integer")
-    @page_2.price = 400
+    @page_2.write_dynamic_attribute :price, 400
     @page_2.add_dynamic_attribute(:farce, "string")
-    @page_2.farce = "hi"
+    @page_2.write_dynamic_attribute :farce, "hi"
     @page_2.save
 
-    @pages = Page.find_by_datt_price_and_farce(400, "hi")
+    @pages = Page.find_by_dynamic_attribute_price_and_farce(400, "hi")
     @pages.should == @page_2
     @pages.should_not == @page
   end
@@ -240,83 +262,116 @@ describe DattsRight do
     end
 
     it "should not save the value" do
-      @page.price = 200
+      @page.write_dynamic_attribute :price, 200
       @page.save
-      @page.price = "hi there"
+      @page.write_dynamic_attribute :price, "hi there"
       @page.save
-      Page.last.price.should == 200
+      Page.last.read_dynamic_attribute(:price).should == 200
     end
   end
 
   it "should allow mass assignment" do
     @page.add_dynamic_attribute(:price, "integer")
     @page.add_dynamic_attribute(:farce, "string")
-    @page.update_attributes(:price => 200, :farce => "hi")
-    @page.price.should == 200
-    @page.farce.should == "hi"
+    @page.update_dynamic_attributes(:price => 200, :farce => "hi")
+    @page.read_dynamic_attribute(:price).should == 200
+    @page.read_dynamic_attribute(:farce).should == "hi"
 
-    @page.update_attributes!(:price => 300, :farce => "not farce!")
-    @page.price.should == 300
-    @page.farce.should == "not farce!"
+    @page.update_dynamic_attributes!(:price => 300, :farce => "not farce!")
+    @page.read_dynamic_attribute(:price).should == 300
+    @page.read_dynamic_attribute(:farce).should == "not farce!"
   end
 
-  it "should allow use of update_attribute" do
+  it "should allow use of update_dynamic_attribute" do
     @page.add_dynamic_attribute(:price, "integer")
-    @page.update_attribute(:price, 200)
-    @page.price.should == 200
+    @page.update_dynamic_attribute(:price, 200)
+    @page.read_dynamic_attribute(:price).should == 200
   end
 
-  describe "ordering" do
+  describe "order_by_dynamic_attribute" do
+    it "should be aliased by order_by_datt" do
+      @page.add_dynamic_attribute(:price, "integer")
+      @page.write_dynamic_attribute :price, 2
+      @page.save
+      Page.order_by_dynamic_attribute("price", "integer").should == Page.order_by_datt("price", "integer")
+    end
+
     it "should default to asc" do
       @page.add_dynamic_attribute(:price, "integer")
-      @page.price = 2
+      @page.write_dynamic_attribute :price, 2
       @page.save
       @page_2 = Page.create
       @page_2.add_dynamic_attribute(:price, "integer")
-      @page_2.price = 1
+      @page_2.write_dynamic_attribute :price, 1
       @page_2.save
       @page_3 = Page.create
       @page_3.add_dynamic_attribute(:price, "float")
-      @page_3.price = 3.0
+      @page_3.write_dynamic_attribute :price, 3.0
       @page_3.save
       @page_4 = Page.create
       @page_4.add_dynamic_attribute(:price, "float")
-      @page_4.price = 3.5
+      @page_4.write_dynamic_attribute :price, 3.5
       @page_4.save
 
       # What if different records have price but they are of different object_type?
-      #   page_1.price is an "integer" and it's saved in "integer_value" column
-      #   page_2.price is a "float" and it's saved in "float_value"
+      #   page_1.read_dynamic_attribute(:price) is an "integer" and it's saved in "integer_value" column
+      #   page_2.read_dynamic_attribute(:price) is a "float" and it's saved in "float_value"
       #
-      #   How would you work on Page.order_datt("price")?
+      #   How would you work on Page.order_by_dynamic_attribute("price")?
       #
       #   Answer 1: we could require passing of the object_type in the order method
-      #     This way, we know which column to look at => order_datt("price", "integer")
-      Page.order_datt("price", "integer").should == [@page_2, @page]
-      Page.order_datt("price DESC", "float").should == [@page_4, @page_3]
+      #     This way, we know which column to look at => order_by_dynamic_attribute("price", "integer")
+      Page.order_by_dynamic_attribute("price", "integer").should == [@page_2, @page]
+      Page.order_by_dynamic_attribute("price DESC", "float").should == [@page_4, @page_3]
     end
   end
 
-  describe "where_datt" do
-    it "should automatically join in the datts table" do
+  describe ".write_dynamic_attribute" do
+    it "should be aliased by write_datt" do
+      Page.instance_method(:write_dynamic_attribute).should == Page.instance_method(:write_datt)
+    end
+  end
+
+  describe ".with_dynamic_attribute_key" do
+    it "should be aliased by .with_datt_key" do
+      @page.add_dynamic_attribute(:price, "float")
+      Page.with_dynamic_attribute_key(:price).should == Page.with_datt_key(:price)
+    end
+  end
+
+  describe ".with_dynamic_attribute_type" do
+    it "should be aliased by .with_datt_type" do
+      @page.add_dynamic_attribute(:price, "float")
+      Page.with_dynamic_attribute_type("float").should == Page.with_datt_type("float")
+    end
+  end
+
+  describe "where_dynamic_attribute" do
+    it "should be aliased by where_datt" do
+      @page.add_dynamic_attribute(:price, "float")
+      @page.write_dynamic_attribute :price, 200.0
+      Page.where_dynamic_attribute(:price => 200.0).should == Page.where_datt(:price => 200.0)
+    end
+
+    it "should automatically join in the dynamic_attributes table" do
       @page.add_dynamic_attribute(:price, "float")
-      @page.price = 200.0
+      @page.write_dynamic_attribute :price, 200.0
       @page.add_dynamic_attribute(:farce, "boolean")
-      @page.farce = true
+      @page.write_dynamic_attribute :farce, true
       @page.save
       
       @page_2 = Page.create
       @page_2.add_dynamic_attribute(:price, "integer")
       @page_2.add_dynamic_attribute(:farce, "boolean")
-      @page_2.farce = true
-      @page_2.price = 1
+      @page_2.write_dynamic_attribute :farce, true
+      @page_2.write_dynamic_attribute :price, 1
       @page_2.save
 
-      @result = Page.where_datt(:price => 200.0, :farce => true)
+      @result = Page.where_dynamic_attribute(:price => 200.0, :farce => true)
       @result.should include(@page)
       @result.should_not include(@page_2)
 
-      #@result = Page.where_datt("price < :price", :price => 199.0)
+      #@result = Page.where_dynamic_attribute("price < :price", :price => 199.0)
       #@result.should_not include(@page)
       #@result.should include(@page_2)
     end
@@ -324,21 +379,21 @@ describe DattsRight do
     it "should allow chaining with where scopes" do
       @page.add_dynamic_attribute(:price, "integer")
       @page.name = "aardvark"
-      @page.price = 200
+      @page.write_dynamic_attribute :price, 200
       @page.save
       
       @page_2 = Page.create
       @page_2.add_dynamic_attribute(:price, "integer")
-      @page_2.price = 200
+      @page_2.write_dynamic_attribute :price, 200
       @page_2.save
 
-      @results = Page.where_datt(:price => 200).where(:name => "aardvark")
+      @results = Page.where_dynamic_attribute(:price => 200).where(:name => "aardvark")
       @results.should include(@page)
       @results.should_not include(@page_2)
     end
 
     it "should return an empty array if we're looking for a field that doesn't exist" do
-      Page.where_datt(:bogus_field => "none").should be_empty
+      Page.where_dynamic_attribute(:bogus_field => "none").should be_empty
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,7 +4,7 @@ require 'rubygems'
 require 'active_record'
 require 'rspec'
 require 'datts_right'
-require 'datts_right/page' # for testing
+require 'datts_right/page'
 
 # Allow to connect to SQLite
 root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
@@ -23,13 +23,13 @@ RSpec.configure do |config|
 end
 
 def reset_database
-  %W(pages datts).each do |table_name|
+  %W(pages dynamic_attributes).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"
   end
-  ActiveRecord::Base.connection.create_table(:datts) do |t|
+  ActiveRecord::Base.connection.create_table(:dynamic_attributes) do |t|
     t.string :name, :null => false
     t.string :attr_key, :null => false
     t.string :object_type, :null => false

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: datts_right
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Ramon Tayag
@@ -1684,6 +1684,96 @@ dependencies:
   name: rcov
   version_requirements: *id111
   prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id112 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: autotest
+  version_requirements: *id112
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id113 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: sqlite3
+  version_requirements: *id113
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id114 !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: *id114
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id115 !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: *id115
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id116 !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: *id116
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id117 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id117
+  prerelease: false
 description: Creates a separate table that saves all your dynamic attributes.
 email: ramon@tayag.net
 executables: []
@@ -1706,14 +1796,13 @@ files:
 - VERSION
 - datts_right.gemspec
 - lib/datts_right.rb
-- lib/datts_right/datt.rb
+- lib/datts_right/dynamic_attribute.rb
 - lib/datts_right/exceptions.rb
 - lib/datts_right/instance_methods.rb
 - lib/datts_right/page.rb
 - lib/datts_right/query_methods.rb
 - spec/datt_spec.rb
 - spec/datts_right_spec.rb
-- spec/has_datts_migration_generator_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/ramontayag/datts_right
@@ -1752,5 +1841,4 @@ summary: Allows saving of dynamic attributes in your ActiveRecord model
 test_files: 
 - spec/datt_spec.rb
 - spec/datts_right_spec.rb
-- spec/has_datts_migration_generator_spec.rb
 - spec/spec_helper.rb

data/spec/has_datts_migration_generator_spec.rb

@@ -1,13 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-#describe "Migration Generator" do
-  #before do
-    #Rails.stub!(:version).and_return("3.0.0")
-    #Dir.mkdir("#{RAILS_ROOT}/db") unless File.exists?("#{RAILS_ROOT}/db")
-    #Dir.mkdir("#{RAILS_ROOT}/db/migrate") unless File.exists?("#{RAILS_ROOT}/db/migrate")
-  #end
-
-  #it "should generate migration file" do
-    #Dir.glob("#{RAILS_ROOT}/db/migrate/*.rb").should_not be_empty
-  #end
-#end