datts_right 0.0.8 → 0.0.9

data/README.textile

@@ -75,20 +75,16 @@ h3. Adding a dynamic attribute to a record
 
 pre. @user = User.create :name => "Roland Deschain"
 @user.add_dynamic_attribute(:age, "integer")
-@user.age = 820
+@user.write_dynamic_attribute :age, 820
 @user.save
 
-h3. @instance.dynamic_attributes
-
-Given the @user above, this prints out the dynamic_attributes just like AR::Base#attributes prints out the attributes
-
-pre. @user.dynamic_attributes # {:name => 820}
-
 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?
 
-pre. @user.dynamic_columns # {:age => {:object_type => "integer", :value => 820}}
+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"
+@user.dynamic_attribute_details(:age).value # 820
 
 h3. dynamic_attribute?(:some_attribute)
 
@@ -109,7 +105,7 @@ The dynamic attributes are only actually saved when save is called on the record
 
 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.write_dynamic_attribute :gunslinger, true # saves into memory
 @user.middle_name = "Unknown" # saves into memory
 @user.save # the respective dynamic attribute columns are written in the dynamic_attributes table
 
@@ -155,24 +151,24 @@ Here are the different types of dynamic attributes you can save:
 
 If you assign a value to a dynamic attribute that isn't the original type, it is ignored.
 
-pre. @user.gunslinger = true
+pre. @user.write_dynamic_attribute :gunslinger, true
 @user.save
-@user.gunslinger # true
-@user.gunslinger = "hey there"
+@user.read_dynamic_attribute(:gunslinger) # true
+@user.write_dynamic_attribute :gunslinger, "hey there"
 @user.save
-@user.gunslinger # true
+@user.read_dynamic_attribute(:gunslinger) # true
 
 h2. Removing a dynamic attribute
 
 pre. @user.remove_dynamic_attribute(:gunslinger)
-@user.gunslinger # NoMethodError
+@user.read_dynamic_attribute(:gunslinger) # NoMethodError
 @user.dynamic_columns # will not include :gunslinger => {...}
 
 h2. Ordering
 
 You can call
 
-pre. Product.order_dynamic_attribute("price", "float") # returns all users with their dynamic attribute "name" in ascending order
+pre. Product.order_by_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?
 
@@ -184,11 +180,24 @@ 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. Shortcuts
+
+Pretty much all methods that have dynamic_attribute can be shorter:
+
+|_. Long name |_. Short name |
+| write_dynamic_attribute | write_datt |
+| read_dynamic_attribute | read_datt |
+| update_dynamic_attribute | update_datt |
+| update_dynamic_attributes | update_datts |
+| find_by_dynamic_attribute_ | find_by_datt_ |
+| order_by_dynamic_attribute | order_by_datt |
+| where_dynamic_attribute | where_datt |
+
 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_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.
+# Do away with the special scopes, such as @where_dynamic_attribute@ and @order_by_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 "dynamic_attributes" table
 

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/datts_right.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{datts_right}
-  s.version = "0.0.8"
+  s.version = "0.0.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ramon Tayag"]
-  s.date = %q{2011-04-12}
+  s.date = %q{2011-04-17}
   s.description = %q{Creates a separate table that saves all your dynamic attributes.}
   s.email = %q{ramon@tayag.net}
   s.extra_rdoc_files = [
@@ -170,6 +170,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"])
@@ -288,6 +294,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"])
@@ -407,6 +419,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

@@ -13,6 +13,8 @@ module DattsRight
 
     has_many :dynamic_attributes, :as => :attributable, :dependent => :destroy
 
+    after_find :cache_dynamic_attributes
+
     # Carry out delayed actions before save
     before_save :build_dynamic_attributes
 

data/lib/datts_right/dynamic_attribute.rb

@@ -13,12 +13,14 @@ class DynamicAttribute < ActiveRecord::Base
     # only allow object_type changes if this is NOT a new record
     # and it's text to string or vice versa
     interchangeable_types = %w(text string)
-    #puts "It's currently a #{self.object_type}, and we wanna make it a #{object_type}"
+    #puts "#{attr_key} is currently a #{self.object_type}, and we wanna make it a #{object_type}"
     if !new_record? && interchangeable_types.include?(self.object_type) && interchangeable_types.include?(object_type) && self.object_type != object_type
-      #puts "It's not new, and we're setting it to #{object_type}"
+      #puts "#{attr_key} is not new, and we're setting object_type to #{object_type}"
       self.object_type = object_type
+      send "#{self.class.attr_column(v)}=", v
+    elsif self.object_type == object_type # has to be the same kind of object
+      send "#{self.object_type}_value=", v
     end
-    send("#{self.class.attr_column(v)}=", v)
   end
 
   def self.attr_type?(v)

data/lib/datts_right/instance_methods.rb

@@ -1,100 +1,34 @@
 module DattsRight
   module InstanceMethods
-    def add_dynamic_attribute(name, 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 #{key} to #{self.class.name}##{id}, and here are the dynamic_attributes: #{dynamic_columns.inspect}"
-        dynamic_attribute
-      else
-        false
+    def add_dynamic_attribute(name, object_type, value=nil)
+      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
+        @dynamic_attributes_cache[key.to_sym] = new_dynamic_attribute
+        return new_dynamic_attribute
       end
+      return false
     end
 
     def remove_dynamic_attribute(name)
-      name = name.to_s
-      dynamic_attribute = dynamic_attributes.find_by_attr_key(name)
+      dynamic_attribute = dynamic_attributes.find_by_attr_key(name.to_s)
       if dynamic_attribute
+        @dynamic_attributes_cache.delete(name.to_sym)
         dynamic_attribute.destroy
-        dynamic_columns(true)
       end
     end
 
-    # Works like ActiveRecord's attributes except it returns dynamic attributes only
-    #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
-    # the key not existing, we need to have a different method to return
-    # information about the record in this format:
-    #   {:price => {:object_type => "integer", :value => 200}}
-    def dynamic_columns(reload=false)
-      @dynamic_columns ||= {}
-      @dynamic_columns if !reload
-      #puts "Building the dynamic_columns cache, and we'll look through #{dynamic_attributes.count} dynamic_attributes"
-      @dynamic_columns={}
-      dynamic_attributes.reload
-      dynamic_attributes.each do |dynamic_attribute|
-        #puts "Going through dynamic_attribute##{dynamic_attribute.id}"
-        dynamic_column = {
-          dynamic_attribute.attr_key.to_sym => {
-            :object_type => dynamic_attribute.object_type,
-            :value => dynamic_attribute.value
-          }
-        }
-        #puts "Added #{dynamic_column.inspect} to the dynamic columns"
-        @dynamic_columns.merge!(dynamic_column)
-      end
-      #puts "in dynamic_columns, returning: #{@dynamic_columns.inspect}"
-      @dynamic_columns
+    # Give users access to the cache
+    def dynamic_attribute_details(key)
+      @dynamic_attributes_cache[key]
     end
 
     # Determines if the given attribute is a dynamic attribute.
     def dynamic_attribute?(attr)
-      #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?
-      #return false if self.class.column_names.include?(attr.to_s)
-      #false
+      !@dynamic_attributes_cache[attr.to_sym].nil?
     end
 
-    # This overrides the attributes= defined in ActiveRecord::Base
-    # The only difference is that this doesn't check to see if the
-    # model responds_to the method before sending it
-    #def attributes=(new_attributes, guard_protected_attributes = true)
-      #return unless new_attributes.is_a?(Hash)
-      #attributes = new_attributes.stringify_keys
-
-      #multi_parameter_attributes = []
-      #attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
-
-      #attributes.each do |k, v|
-        #if k.include?("(")
-          #multi_parameter_attributes << [ k, v ]
-        #else
-          #send("#{k}=", v)
-        #end
-      #end
-
-      #assign_multiparameter_attributes(multi_parameter_attributes)
-    #end
-
     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.
@@ -115,43 +49,26 @@ module DattsRight
       end
     end
 
-    # Overrides AR::Base#read_attribute
+    # Like AR::Base#read_attribute
     def read_dynamic_attribute(attr_name)
       attr_name = attr_name.to_s
       if dynamic_attribute?(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 "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 "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 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]
-        end
+        #puts "Reading #{attr_name}. The whole cache: #{@dynamic_attributes_cache.inspect}"
+        @dynamic_attributes_cache[attr_name.to_sym].value
       end
-      
-      super(attr_name)
     end
 
-    # Overrides AR::Base#write_attribute
+    # Like AR::Base#write_attribute
     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"
         attr_name = attr_name.to_s
-        
-        @save_dynamic_attr ||= {} # create the cache if needed
-        return @save_dynamic_attr[attr_name] = value
-        return nil
+        #puts "Writing @dynamic_attributes_cache[:#{attr_name}].value = #{value}"
+        dynamic_attribute = @dynamic_attributes_cache[attr_name.to_sym]
+        dynamic_attribute.value = value
+        #puts "In write_dynamic_attribute. Full cache: #{@dynamic_attributes_cache.inspect}"
+        return dynamic_attribute.value
       end
     end
 
@@ -161,52 +78,33 @@ module DattsRight
     # 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}"
+      @dynamic_attributes_cache ||= {}
+      @dynamic_attributes_cache.each do |k, v|
+        v.save
+        #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_attribute = dynamic_attributes.create! :name => k, :attr_key => k, :value => v
-          #puts "created: #{dynamic_attribute.inspect} among these dynamic_attributes: #{dynamic_attributes.inspect}"
-        end
+          ##@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
-      @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
+    def cache_dynamic_attributes
+      @dynamic_attributes_cache = {}
+      dynamic_attributes.each do |dynamic_attribute|
+        @dynamic_attributes_cache[dynamic_attribute.attr_key.to_sym] = dynamic_attribute
+      end
+      @dynamic_attributes_cache
+    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 :datt_details :dynamic_attribute_details
     alias :update_dynamic_attribute :write_dynamic_attribute
   end
 end

data/spec/datts_right_spec.rb

@@ -11,15 +11,17 @@ describe DattsRight do
       Page.instance_method(:add_dynamic_attribute).should == Page.instance_method(:add_datt)
     end
 
-    it "should add a dynamic attribute with nil value" do
+    it "should add a dynamic attribute" do
       @page.add_dynamic_attribute(:rocks, "string")
-      @page.dynamic_columns[:rocks][:value].should be_nil
+      @page.dynamic_attribute_details(:rocks).value.should be_nil
+      @page.add_dynamic_attribute(:rock, "string", "123")
+      @page.dynamic_attribute_details(:rock).value.should == "123"
     end
 
     it "should ignore when trying to add same attribute" do
       @page.add_dynamic_attribute(:rocks, "string")
       @page.add_dynamic_attribute(:rocks, "integer")
-      @page.dynamic_columns[:rocks][:object_type].should == "string"
+      @page.dynamic_attribute_details(:rocks).object_type.should == "string"
     end
 
     it "should return false if the method that is being added already exists" do
@@ -28,9 +30,14 @@ describe DattsRight do
 
     it "should not make any changes to the original attribute" do
       @page.update_attribute(:name, "juno")
-      @page.add_dynamic_attribute(:name, "text").should be_false
+      @page.add_dynamic_attribute(:name, "text")
       @page.name.should == "juno"
     end
+
+    it "should still work after reloading" do
+      @page.add_dynamic_attribute(:rocks, "string")
+      @page = Page.last
+    end
   end
 
   describe ".remove_dynamic_attribute(attr_key)" do
@@ -396,4 +403,15 @@ describe DattsRight do
       Page.where_dynamic_attribute(:bogus_field => "none").should be_empty
     end
   end
+
+  describe ".dynamic_attribute_details(key)" do
+    it "should be aliased by datt_details" do
+      Page.instance_method(:dynamic_attribute_details).should == Page.instance_method(:datt_details)
+    end
+
+    it "should allow access to the dynamic_attribute" do
+      @page.add_dynamic_attribute(:price, "integer")
+      @page.dynamic_attribute_details(:price).class.should == DynamicAttribute
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: datts_right
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: 
   segments: 
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - Ramon Tayag
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-12 00:00:00 +08:00
+date: 2011-04-17 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -1774,6 +1774,96 @@ dependencies:
   name: rcov
   version_requirements: *id117
   prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id118 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: autotest
+  version_requirements: *id118
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id119 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: sqlite3
+  version_requirements: *id119
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id120 !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: *id120
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id121 !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: *id121
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id122 !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: *id122
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id123 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id123
+  prerelease: false
 description: Creates a separate table that saves all your dynamic attributes.
 email: ramon@tayag.net
 executables: []