flex_columns 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d79e3b16e2f818cfee4e0cdf530a78ebc49bfbdd
-  data.tar.gz: 03593078cb27e5cac1d7b38090147ac5590f7b8f
+  metadata.gz: acb66f010a776e668841ca7f12dc0854cad5b4c9
+  data.tar.gz: 91492dda4eab46d062ae8958c62c5e31da33a339
 SHA512:
-  metadata.gz: 4072eb037511e12a1adfc2d34982568445bfcedb386013d2d50ded737e40f4fa259df9c5a87cf39dff86b4d2c82da01caec0c2055473cfd4d819be501e5b9e10
-  data.tar.gz: aea2b505ba4af83bbd3408d066402bdded39d4a06309d5ba4b2341a17ad00ccfbd0098bfe7149ba93ecee28c45f7d6c40dde03da22b27d3b56dc02b71d5a1f0e
+  metadata.gz: 4469119cb126a4e5767910b6ce4df02037afa3003d735be05baf0a0158ee45c3871b5c29292181c09823ac416184cb2e692f8ad31c9dfd66cea0187d65b5e3d6
+  data.tar.gz: 6614f83b721f635efa9e80f4f194237436890e66f35a662af0ed100d4d5bc4e90436abe859e89332ecc5f913134903e041bb66332a7d424560e64a5187bf0908

data/.gitignore

@@ -15,4 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-/spec_database_config.rb
+/spec_database_config.rb*

data/flex_columns.gemspec

@@ -45,20 +45,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency "activesupport", ">= 3.0", "<= 4.99.99"
 
-  ar_import_version = case ar_version
-  when nil then nil
-  when 'master', /^4\.0\./ then '~> 0.4.1'
-  when /^3\.0\./ then '~> 0.2.11'
-  when /^3\.1\./, /^3\.2\./ then '~> 0.3.1'
-  else raise "Don't know what activerecord-import version to require for activerecord version #{ar_version.inspect}!"
-  end
-
-  if ar_import_version
-    s.add_dependency("activerecord-import", ar_import_version)
-  else
-    s.add_dependency("activerecord-import")
-  end
-
   require File.expand_path(File.join(File.dirname(__FILE__), 'spec', 'flex_columns', 'helpers', 'database_helper'))
   database_gem_name = FlexColumns::Helpers::DatabaseHelper.maybe_database_gem_name
 

data/lib/flex_columns/contents/column_data.rb

@@ -80,7 +80,6 @@ module FlexColumns
 
         @field_contents_by_field_name = nil
         @unknown_field_contents_by_key = nil
-        @touched = false
       end
 
       # Returns the data for the given +field_name+. Raises FlexColumns::Errors::NoSuchFieldError if there is no field
@@ -109,8 +108,6 @@ module FlexColumns
 
         old_value = field_contents_by_field_name[field_name]
 
-        @touched = true if old_value != new_value
-
         # We deliberately delete from the hash anything that's being set to +nil+; this is so that we don't end up just
         # binding keys to +nil+, and returning them in #keys, etc. (Yes, this means that you can't distinguish a key
         # explicitly set to +nil+ from a key that's not present; this is different from Ruby's semantics for a Hash,
@@ -129,17 +126,56 @@ module FlexColumns
         field_contents_by_field_name.keys
       end
 
+      # Returns a representation of this data as a Hash. This should *not* be used in +flex_columns+ to manipulate
+      # data, as it does not contain a full representation of a column (in particular, unknown-field data is not
+      # represented in the returned Hash); however, it's useful to construct a string (e.g.,
+      # FlexColumnsContentsBase#inspect) to help with debugging.
+      def to_hash
+        deserialize_if_necessary!
+        field_contents_by_field_name.dup.with_indifferent_access
+      end
+
       # Does nothing, other than making sure the JSON has been deserialized. This therefore has the effect both of
       # ensuring that the stored data (if any) is valid, and also will remove any unknown keys (on save) if
       # +:unknown_fields+ was set to +:delete+.
       def touch!
         deserialize_if_necessary!
-        @touched = true
       end
 
-      # Has this object been modified in any way?
-      def touched?
-        !! @touched
+      # Has this object been deserialized? If it's been deserialized, then we need to do things like run validations
+      # on it, save it back to the database when someone calls #save! on the parent object, and so on.
+      #
+      # Not at all obvious: originally, we had a method called #touched? that let you know whether the given object
+      # had been changed at all. It simply got set on +#[]=+, above. The problem with this is that very frequently,
+      # +flex_columns+ is used to store complex data structures (because that's one of the things that's dramatically
+      # easier in a serialized JSON blob than in a traditional relational structure). But if you have an array stored,
+      # and you call #<< on it to append an element, then +#[]=+ never gets called at all -- because it's still the
+      # same object, just with different contents.
+      #
+      # We could have worked around this by saving off a copy of each field when we deserialized, then comparing them
+      # using a deep equality (#== should work just fine) to determine if they've changed. However, this adds very
+      # significant overhead to each and every single use of a +flex_column+ object, whether or not you rely on or
+      # care about this kind of tracking -- we would have to #dup every flex column field every single time we
+      # deserialized, and, if you have large objects in there, that can get extremely expensive.
+      #
+      # Since almost every object in Ruby is mutable -- even Strings -- there aren't really any easy wins here.
+      # Numbers are the only commonplace object that aren't, and it's not going to be a common use case that someone
+      # uses a +flex_column+ with fields that each simply store one single number. (Storing an array or a hash of
+      # numbers is much more common, but then you're talking about Arrays and Hashes, which are back to being mutable.)
+      #
+      # Another option would be to #freeze all of the fields on a flex column, thus requiring clients to reassign them
+      # with a new object if they wanted to change them at all. That, however, presents an API that most users would
+      # hate -- I don't want to say <tt>user.prefs_map = user.prefs_map.merge(:foo => bar)</tt>; I want to just say
+      # <tt>user.prefs_map[:foo] = bar</tt>.
+      #
+      # Instead, once we deserialize a field, we just assume that it has changed. While this may end up causing the
+      # client to do extra work at times, it's much higher-performance than doing the tracking every time.
+      #
+      # (There is definitely room to add code that would make this configurable, on a per-flex-column or even per-field
+      # basis. As always, patches are welcome; as of this writing, it seems likely that it might just not be an issue
+      # big enough to worry about.)
+      def deserialized?
+        !! field_contents_by_field_name
       end
 
       # Returns a String with the current contents of this object as JSON. (This will deserialize from JSON, if it
@@ -181,7 +217,8 @@ module FlexColumns
           end
         end
 
-        if length_limit && out.length > length_limit
+        actual_length = out ? out.length : 0
+        if length_limit && actual_length > length_limit
           raise FlexColumns::Errors::JsonTooLongError.new(data_source, length_limit, out)
         end
 
@@ -345,7 +382,7 @@ module FlexColumns
       # If we haven't yet deserialized the JSON string, do it now, and store the data appropriately. This also
       # checks for a validly-encoded string.
       def deserialize_if_necessary!
-        unless field_contents_by_field_name
+        unless deserialized?
           raw_data = storage_string || ''
 
           # PostgreSQL's JSON data type, combined with recent-enough adapters and ActiveRecord, will return JSON as a

data/lib/flex_columns/contents/flex_column_contents_base.rb

@@ -108,23 +108,18 @@ module FlexColumns
         column_data[field_name] = new_value
       end
 
-      # A flex column has been "touched" if it has had at least one field changed to a different value than it had
-      # before, or if someone has called #touch! on it. If a column has not been touched, validations are not run on it,
-      # nor is it re-serialized back out to the database on save!. Generally, this is a good thing: it increases
-      # performance substantially for times when you haven't actually changed the flex column's contents at all. It does
-      # mean that invalid data won't be detected and unknown fields won't be removed (if you've specified
-      # <tt>:unknown_fields => delete</tt>), however.
-      #
-      # There may be times, however, when you want to make sure the column is stored back out (including removing any
-      # unknown fields, if you selected that option), or to make sure that validations get run, no matter what.
-      # In this case, you can call #touch!.
+      # Sometimes you want to deserialize a flex column explicitly, without actually changing anything in it. (For
+      # example, if you set <tt>:unknown_fields => :delete</tt>, then unknown fields are removed from a column only if
+      # it has been deserialized before you save it.) While you could accomplish this by simply accessing any field
+      # of the column, it's cleaner and more clear what you're doing to just call this method.
       def touch!
         column_data.touch!
       end
 
-      # Has at least one field in the column been changed, or has someone called #touch! ?
-      def touched?
-        column_data.touched?
+      # Has the column been deserialized? A column is deserialized if someone has tried to read from or write to it,
+      # or if someone has called #touch!.
+      def deserialized?
+        column_data.deserialized?
       end
 
       # Called via the ActiveRecord::Base#before_validation hook that gets installed on the enclosing model instance.
@@ -139,6 +134,25 @@ module FlexColumns
         end
       end
 
+      INSPECT_MAXIMUM_LENGTH_FOR_ANY_ATTRIBUTE_VALUE = 100
+
+      # **NOTE**: This method *WILL* deserialize the contents of the column, if it hasn't already been deserialized.
+      # This is extremely useful for debugging, and almost certainly what you want, but if, for some reason, you
+      # call #inspect on every single instance of a flex-column you get back from the database, you'll incur a
+      # needless performance penalty. You have been warned.
+      def inspect
+        string_hash = { }
+        column_data.to_hash.each do |k,v|
+          v_string = v.to_s
+          if v_string.length > INSPECT_MAXIMUM_LENGTH_FOR_ANY_ATTRIBUTE_VALUE
+            v_string = "#{v_string[0..(INSPECT_MAXIMUM_LENGTH_FOR_ANY_ATTRIBUTE_VALUE - 1)]}..."
+          end
+          string_hash[k] = v_string
+        end
+
+        "<#{self.class.name}: #{string_hash.inspect}>"
+      end
+
       # Returns a JSON string representing the current contents of this flex column. Note that this is _not_ always
       # exactly what gets stored in the database, because of binary columns and compression; for that, use
       # #to_stored_data, below.

data/lib/flex_columns/definition/flex_column_contents_class.rb

@@ -146,11 +146,11 @@ module FlexColumns
 
       # Given a model instance, do we need to save this column? This is true under one of two cases:
       #
-      # * Someone has changed ("touched") at least one of the flex-column fields (or called #touch! on it);
+      # * Someone has deserialized the column by accessing it (or calling #touch! on it);
       # * The column is non-NULL, and there's no data in it right now. (Saving it will populate it with an empty string.)
       def requires_serialization_on_save?(model)
         maybe_flex_object = model._flex_column_object_for(column_name, false)
-        out = true if maybe_flex_object && maybe_flex_object.touched?
+        out = true if maybe_flex_object && maybe_flex_object.deserialized?
         out ||= true if ((! column.null) && (! model[column_name]))
         out
       end

data/lib/flex_columns/has_flex_columns.rb

@@ -38,7 +38,7 @@ module FlexColumns
     # whether you've changed that particular attribute or not.
     def _flex_columns_before_validation!
       _all_present_flex_column_objects.each do |flex_column_object|
-        flex_column_object.before_validation! if flex_column_object.touched?
+        flex_column_object.before_validation!
       end
     end
 
@@ -72,6 +72,25 @@ module FlexColumns
       @_flex_column_objects = { }
     end
 
+    # This little-know ActiveRecord method gets called to produce a string for #inspect for a particular attribute.
+    # Because the default implementation uses #read_attribute, if we don't override it, it will simply return our
+    # actual string in the database; if this is compressed data, this is meaningless to a programmer. So we override
+    # this to instead deserialize the column and call #inspect on the actual FlexColumnContentsBase object, which
+    # shows interesting information.
+    #
+    # **NOTE**: See the warning comment above FlexColumnContentsBase#inspect, which points out that this will
+    # deserialize the column if it hasn't already -- so calling this has a performance penalty. This should be fine,
+    # since calling #inspect in bulk isn't something a program should be doing in production mode anyway, but it's
+    # worth noting.
+    def attribute_for_inspect(attr_name)
+      cn =  self.class._all_flex_column_names
+      if cn.include?(attr_name.to_sym)
+        _flex_column_object_for(attr_name).inspect
+      else
+        super(attr_name)
+      end
+    end
+
     private
     # Returns the Hash that we keep flex-column objects in, indexed by column name.
     def _flex_column_objects

data/lib/flex_columns/version.rb

@@ -1,4 +1,4 @@
 module FlexColumns
   # The current version of FlexColumns.
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/spec/flex_columns/system/basic_system_spec.rb

@@ -40,6 +40,57 @@ describe "FlexColumns basic operations" do
       user2.user_attributes.keys.should == [ :wants_email ]
     end
 
+    it "shouldn't complain if there is no data, but you still touch a field" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.user_attributes.wants_email
+      user.save!
+    end
+
+    # This test case was created from a found bug: we were assuming that unless you called "#{method}=" on one of
+    # the attributes of a flex column, then we didn't need to serialize and save the flex column. However, that's not
+    # true, for exactly the reasons seen below (maybe you modified an object that was referred to from the field,
+    # but didn't change that field itself). See also the comment above ColumnData#deserialized?.
+    it "should still save its data even if you change something nested down deep" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.user_attributes.wants_email = { 'foo' => { 'bar' => [ 1, 2, 3 ] } }
+      user.save!
+
+      user_again = ::User.find(user.id)
+      user_again.user_attributes.wants_email['foo']['bar'] << 4
+      user_again.save!
+
+      user_yet_again = ::User.find(user.id)
+      user_yet_again.user_attributes.wants_email['foo']['bar'].should == [ 1, 2, 3, 4 ]
+    end
+
+    it "should return useful data for the column on #inspect, deserializing if necessary" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.wants_email = 'whatEVER, yo'
+      user.save!
+
+      user_again = ::User.find(user.id)
+      s = user_again.user_attributes.inspect
+      s.should match(/UserAttributesFlexContents/i)
+      s.should match(/wants_email/i)
+      s.should match(/whatEVER, yo/)
+    end
+
+    it "should return useful data for the column on #inspect from the parent AR model" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.wants_email = 'whatEVER, yo'
+      user.save!
+
+      user_again = ::User.find(user.id)
+      s = user_again.inspect
+      s.should match(/UserAttributesFlexContents/i)
+      s.should match(/wants_email/i)
+      s.should match(/whatEVER, yo/)
+    end
+
     it "should store its data as standard JSON" do
       user = ::User.new
       user.name = 'User 1'
@@ -60,7 +111,7 @@ describe "FlexColumns basic operations" do
       contents['wants_email'].should == 'sometimes'
     end
 
-    it "should not modify that JSON if you don't write to it with a different value, but should if you touch it" do
+    it "should not modify that JSON if you don't touch it, but should if you do" do
       define_model_class(:UserBackdoor, 'flexcols_spec_users') { }
 
       weirdly_spaced_json = '   {        "wants_email"  : "boop"    } '
@@ -72,15 +123,7 @@ describe "FlexColumns basic operations" do
 
       user = ::User.find(user_bd.id)
       user.name.should == 'User 1'
-      user.wants_email.should == 'boop'
-      user.wants_email = 'boop'
-      user.save!
-
-      user_bd_again = ::UserBackdoor.find(user_bd.id)
-      user_bd_again.name.should == 'User 1'
-      user_bd_again.user_attributes.should == weirdly_spaced_json
-
-      user.user_attributes.touch!
+      user.wants_email
       user.save!
 
       user_bd_again = ::UserBackdoor.find(user_bd.id)

data/spec/flex_columns/system/compression_system_spec.rb

@@ -99,6 +99,33 @@ describe "FlexColumns compression operations" do
     data.should_not match(/bar/)
   end
 
+  describe "#inspect" do
+    it "should decompress and deserialize data for #inspect on the column itself, but should abbreviate" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.foo = 'foo' * 1000
+      user.save!
+
+      user_again = ::User.find(user.id)
+      s = user_again.user_attributes.inspect
+      s.should match(/UserAttributesFlexContents/i)
+      s.should match(/foofoofoofoo/i)
+      s.length.should < 1000
+    end
+
+    it "should decompress and deserialize data for #inspect on the parent, too" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.foo = 'foo' * 1000
+      user.save!
+
+      user_again = ::User.find(user.id)
+      s = user_again.inspect
+      s.should match(/UserAttributesFlexContents/i)
+      s.should match(/foofoofoofoo/i)
+    end
+  end
+
   it "should read compressed data fine, even if told not to compress new data" do
     user = ::User.new
     user.name = 'User 1'

data/spec/flex_columns/system/performance_system_spec.rb

@@ -63,7 +63,7 @@ describe "FlexColumns performance" do
     @deserializations[0][:raw_data].should == user_again.user_attributes.to_json
   end
 
-  it "should not deserialize columns if they aren't touched" do
+  it "should not deserialize columns if they aren't accessed" do
     user = ::User.new
     user.name = 'User 1'
     user.wants_email = 'foo'

data/spec/flex_columns/system/unknown_fields_system_spec.rb

@@ -75,7 +75,7 @@ describe "FlexColumns unknown fields" do
     user_bd_again.some_unknown_attribute.should be_nil
   end
 
-  it "should not delete unknown fields if asked to, but we only read from the model" do
+  it "should delete unknown fields if asked to, even if we only read from the model" do
     @user_bd.wants_email = 'foo'
     @user_bd.save!
 
@@ -98,7 +98,7 @@ describe "FlexColumns unknown fields" do
 
     user_bd_again = ::UserBackdoor.find(@user_bd.id)
     user_bd_again.wants_email.should == 'foo'
-    user_bd_again.some_unknown_attribute.should == 'bongo'
+    user_bd_again.some_unknown_attribute.should_not be
   end
 
   it "should have a method that explicitly will purge unknown methods, even if deserialization hasn't happened for any other reason, but not before then" do

data/spec/flex_columns/unit/contents/column_data_spec.rb

@@ -131,22 +131,16 @@ describe FlexColumns::Contents::ColumnData do
         lambda { instance.touch! }.should raise_error(FlexColumns::Errors::UnparseableJsonInDatabaseError)
       end
 
-      it "should not be touched if you simply read from it" do
-        @instance.touched?.should_not be
+      it "should be deserialized if you simply read from it" do
+        @instance.deserialized?.should_not be
         @instance[:foo]
-        @instance.touched?.should_not be
+        @instance.deserialized?.should be
       end
 
-      it "should not be touched if you set a field to the same thing" do
-        @instance.touched?.should_not be
-        @instance[:foo] = 'bar'
-        @instance.touched?.should_not be
-      end
-
-      it "should be touched if you set a field to something different" do
-        @instance.touched?.should_not be
+      it "should be deserialized if you set a field to something different" do
+        @instance.deserialized?.should_not be
         @instance[:foo] = 'baz'
-        @instance.touched?.should be
+        @instance.deserialized?.should be
       end
     end
 
@@ -159,13 +153,34 @@ describe FlexColumns::Contents::ColumnData do
       parsed['baz'].should == 'quux'
     end
 
-    it "should return JSON data with #to_json" do
-      json = @instance.to_json
-      parsed = JSON.parse(json)
-      parsed.keys.sort.should == %w{foo bar baz}.sort
-      parsed['foo'].should == 'bar'
-      parsed['bar'].should == 123
-      parsed['baz'].should == 'quux'
+    describe "#to_hash" do
+      it "should return a hash with the data in it, with indifferent access" do
+        h = @instance.to_hash
+        h.keys.sort.should == %w{foo bar baz}.sort
+        h['foo'].should == 'bar'
+        h['bar'].should == 123
+        h['baz'].should == 'quux'
+        h[:foo].should == 'bar'
+        h[:bar].should == 123
+        h[:baz].should == 'quux'
+      end
+
+      it "should deserialize if needed" do
+        h = new_with_string(@json_string).to_hash
+        h.keys.sort.should == %w{foo bar baz}.sort
+        h['foo'].should == 'bar'
+        h['bar'].should == 123
+        h['baz'].should == 'quux'
+      end
+
+      it "should not return unknown fields" do
+        h = new_with_string({ 'foo' => 'bar', 'baz' => 123, 'quux' => 'whatever' }.to_json).to_hash
+        h.keys.sort.should == %w{foo baz}.sort
+        h['foo'].should == 'bar'
+        h['baz'].should == 123
+        h['bar'].should be_nil
+        h['quux'].should be_nil
+      end
     end
 
     it "should accept a Hash as JSON, already parsed by the database stack" do

data/spec/flex_columns/unit/contents/flex_column_contents_base_spec.rb

@@ -188,11 +188,11 @@ describe FlexColumns::Contents::FlexColumnContentsBase do
           allow(@model_instance).to receive(:_flex_column_object_for).with(:fcn, false).and_return(@instance)
         end
 
-        it "should tell you if it's been touched" do
-          expect(@column_data).to receive(:touched?).once.with().and_return(true)
-          @instance.touched?.should be
-          expect(@column_data).to receive(:touched?).once.with().and_return(false)
-          @instance.touched?.should_not be
+        it "should tell you if it's been deserialized" do
+          expect(@column_data).to receive(:deserialized?).once.with().and_return(true)
+          @instance.deserialized?.should be
+          expect(@column_data).to receive(:deserialized?).once.with().and_return(false)
+          @instance.deserialized?.should_not be
         end
 
         it "should save if the class tells it to" do
@@ -224,6 +224,25 @@ describe FlexColumns::Contents::FlexColumnContentsBase do
         @instance[:xxx].should == :yyy
       end
 
+      it "should return a useful string for #inspect" do
+        expect(@column_data).to receive(:to_hash).once.and_return({ :aaa => 'bbb', :ccc => 'ddd'})
+        i = @instance.inspect
+        i.should match(/aaa/)
+        i.should match(/bbb/)
+        i.should match(/ccc/)
+        i.should match(/ddd/)
+      end
+
+      it "should abbreviate that hash, if necessary" do
+        expect(@column_data).to receive(:to_hash).once.and_return({ :aaa => 'bbb', :ccc => ('ddd' * 1_000)})
+        i = @instance.inspect
+        i.should match(/aaa/)
+        i.should match(/bbb/)
+        i.should match(/ccc/)
+        i.should match(/ddddddddd/)
+        i.length.should < 1_000
+      end
+
       it "should delegate to the column data on []=" do
         expect(@column_data).to receive(:[]=).once.with(:xxx, :yyy).and_return(:zzz)
         (@instance[:xxx] = :yyy).should == :yyy

data/spec/flex_columns/unit/definition/flex_column_contents_class_spec.rb

@@ -490,19 +490,19 @@ describe FlexColumns::Definition::FlexColumnContentsClass do
     end
 
     describe "#requires_serialization_on_save?" do
-      it "should be true if there's an object and it has been touched" do
+      it "should be true if there's an object and it has been deserialized" do
         model = double("model")
         fco = double("fco")
         allow(model).to receive(:_flex_column_object_for).with(:foo, false).and_return(fco)
-        allow(fco).to receive(:touched?).with().and_return(true)
+        allow(fco).to receive(:deserialized?).with().and_return(true)
         @klass.requires_serialization_on_save?(model).should be
       end
 
-      it "should be false if there's an object but it hasn't been touched" do
+      it "should be false if there's an object but it hasn't been deserialized" do
         model = double("model")
         fco = double("fco")
         allow(model).to receive(:_flex_column_object_for).with(:foo, false).and_return(fco)
-        allow(fco).to receive(:touched?).with().and_return(false)
+        allow(fco).to receive(:deserialized?).with().and_return(false)
         @klass.requires_serialization_on_save?(model).should_not be
       end
 

data/spec/flex_columns/unit/has_flex_columns_spec.rb

@@ -168,28 +168,30 @@ describe FlexColumns::HasFlexColumns do
       @klass._flex_column_dynamic_methods_module.should be(@dmm)
     end
 
-    it "should call through on before_validation to only flex column objects that have been touched" do
+    it "should call through on before_validation to all flex column objects, whether or not they've been deserialized" do
       instance = @klass.new
       instance._flex_columns_before_validation!
 
       fcc_foo_instance = double("fcc_foo_instance")
       expect(@fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance)
       instance._flex_column_object_for(:foo).should be(fcc_foo_instance)
-      allow(fcc_foo_instance).to receive(:touched?).with().and_return(false)
+      allow(fcc_foo_instance).to receive(:deserialized?).with().and_return(false)
 
+      expect(fcc_foo_instance).to receive(:before_validation!).once.with()
       instance._flex_columns_before_validation!
 
 
       fcc_bar_instance = double("fcc_bar_instance")
       expect(@fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance)
       instance._flex_column_object_for(:bar).should be(fcc_bar_instance)
-      allow(fcc_bar_instance).to receive(:touched?).with().and_return(true)
+      allow(fcc_bar_instance).to receive(:deserialized?).with().and_return(true)
 
+      expect(fcc_foo_instance).to receive(:before_validation!).once.with()
       expect(fcc_bar_instance).to receive(:before_validation!).once.with()
       instance._flex_columns_before_validation!
 
-      allow(fcc_foo_instance).to receive(:touched?).with().and_return(true)
-      allow(fcc_bar_instance).to receive(:touched?).with().and_return(true)
+      allow(fcc_foo_instance).to receive(:deserialized?).with().and_return(true)
+      allow(fcc_bar_instance).to receive(:deserialized?).with().and_return(true)
 
       expect(fcc_foo_instance).to receive(:before_validation!).once.with()
       expect(fcc_bar_instance).to receive(:before_validation!).once.with()

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flex_columns
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Andrew Geweke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-22 00:00:00.000000000 Z
+date: 2014-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -148,20 +148,6 @@ dependencies:
     - - <=
       - !ruby/object:Gem::Version
         version: 4.99.99
-- !ruby/object:Gem::Dependency
-  name: activerecord-import
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
@@ -251,7 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Schema-free, structured JSON storage inside a RDBMS.
@@ -284,3 +270,4 @@ test_files:
 - spec/flex_columns/unit/including/include_flex_columns_spec.rb
 - spec/flex_columns/unit/util/dynamic_methods_module_spec.rb
 - spec/flex_columns/unit/util/string_utils_spec.rb
+has_rdoc: