flex_columns 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  metadata.gz: a346cd4387b83db2754cd6d18db49a616015ca230a0b18134f0a7176b4f206778a7f778cec4b97e84c59dfb0358339a2106b1e8656be922a54b2d0143867b1da
-  data.tar.gz: bebc4830bc2ea67bfa2152cca4587d751dd13da67c4afe22ea288e4522079510aaf2aa42b32fbff72a6b2af4c930ada099fafadb063cb384bb84f30c1a3c05c4
 SHA1: 
-  metadata.gz: e57b169cbe90447775b3f4b0bf2c6e843825bb12
-  data.tar.gz: 314c670ba146241547f561a3354cf8473509f1be
+  metadata.gz: d883b205cd22c7aa6a6bda071d3ca52c7084e14e
+  data.tar.gz: 88057e546d40a01a83ba499f0c9c4d4c5b0863af
+SHA512: 
+  metadata.gz: 040c456a7527585100159b68e0b1685e590fb30a75f1388107773de1501a6699d8b7903f891ccbc0b0e0f5a7cb44b647d734cf5e65279185723129580cb6f4be
+  data.tar.gz: 951bfb6887b746545fcc7d5b8036d9a1efa5bdc31369e1b68fddfcf1bc482b10464d5f11a2d43cb4135ac9e140471cb5490ddee61e8ff41730e4fa03c0f82bb2

data/CHANGES.md

@@ -1,5 +1,9 @@
 # `flex_columns` Changelog
 
+## 1.0.7, 2014-04-07
+
+* Fixed an issue where, if you defined a model class when its table didn't exist, and then created its table while the Ruby process was still running, you still couldn't access any flex-column attributes — because we would simply skip defining them entirely if the table didn't exist. Now, we define them, assuming the columns exist and are of type `:string` (and `null`able) if the table doesn't exist, and replace them with the actual column definition once the table exists. (You need to call `.reset_column_information` on the model class to make this happen, just as you do with any changes to the underlying table of an ActiveRecord model.)
+
 ## 1.0.6, 2014-04-07
 
 * Fixed an issue where Float::INFINITY and Float::NaN could not be stored in a flex column.

data/README.md

@@ -110,13 +110,13 @@ As a snapshot of all possibilities:
 There's lots more, too:
 
 * Complete validations support: the flex-column object includes ActiveModel::Validations, so every single Rails validation (or custom validations) will work perfectly
-* Bulk operations, for avoiding ActiveRecord instantiation (efficiently operate using raw +select_all+ and +activerecord-import+ or similar systems)
+* Bulk operations, for avoiding ActiveRecord instantiation (efficiently operate using raw `select_all` and `activerecord-import` or similar systems)
 * Transparently compresses JSON data in the column using GZip, if it's typed as binary (`BINARY`, `VARBINARY`, `CLOB`, etc.); you can fully control this, or turn it off if you want
 * Happily allows definition and redefinition of flex columns at any time, for full dynamism and compatibility with development mode of Rails
 * Rich error hierarchy and detailed exception messages — you will know exactly what went wrong when something goes wrong
 * Include flex columns across associations, with control over exactly what's delegated and visibility of those methods (public or private)
 * Control whether attribute methods generated are public (default) or private (to encourage encapsulation)
-* "Types": automatically adds validations that require fields to comply with database types like +:integer+, +:string+, +:timestamp+, etc.
+* "Types": automatically adds validations that require fields to comply with database types like `:integer`, `:string`, `:timestamp`, etc.
 * Decide whether to preserve (the default) or delete keys from the underlying JSON that aren't defined in the flex column — lets you ensure database data is of the highest quality, or be compatible with any other storage mechanisms
 
 ### Documentation

data/lib/flex_columns/active_record/base.rb

@@ -60,8 +60,7 @@ module FlexColumns
 
           reason = nil
 
-          reason ||= :column if columns.detect { |c| c.name.to_s == base_name }
-          # return false if method_defined?(base_name) || method_defined?("#{base_name}=")
+          reason ||= :column if table_exists? && columns.detect { |c| c.name.to_s == base_name }
           reason ||= :instance_method if instance_methods(false).map(&:to_s).include?(base_name.to_s)
 
           (! reason)

data/lib/flex_columns/definition/fake_column.rb

@@ -0,0 +1,29 @@
+module FlexColumns
+  module Definition
+    # This is a class that complies with just enough of the ActiveRecord interface to columns to be able to be
+    # swapped in for it, in our code.
+    #
+    # We use this in just one case: when you declare a flex column on a model class whose underlying table doesn't
+    # exist. If you call +.reset_column_information+ on the model in question, we'll pick up the new, actual column
+    # (assuming the table exists now), but, until then, we'll use this.
+    class FakeColumn
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def null
+        true
+      end
+
+      def type
+        :string
+      end
+
+      def limit
+        nil
+      end
+    end
+  end
+end

data/lib/flex_columns/definition/flex_column_contents_class.rb

@@ -1,3 +1,5 @@
+require 'flex_columns/definition/fake_column'
+
 module FlexColumns
   module Definition
     # When you declare a flex column, we actually generate a brand-new Class for that column; instances of that flex
@@ -198,25 +200,11 @@ module FlexColumns
 
         raise ArgumentError, "Invalid column name: #{column_name.inspect}" unless column_name.kind_of?(Symbol)
 
-        column = model_class.columns.detect { |c| c.name.to_s == column_name.to_s }
-        unless column
-          raise FlexColumns::Errors::NoSuchColumnError, %{You're trying to define a flex column #{column_name.inspect}, but
-  the model you're defining it on, #{model_class.name}, seems to have no column
-  named that.
-
-  It has columns named: #{model_class.columns.map(&:name).sort_by(&:to_s).join(", ")}.}
-        end
-
-        unless column.type == :binary || column.text? || column.sql_type == "json" # for PostgreSQL >= 9.2, which has a native JSON data type
-          raise FlexColumns::Errors::InvalidColumnTypeError, %{You're trying to define a flex column #{column_name.inspect}, but
-  that column (on model #{model_class.name}) isn't of a type that accepts text.
-  That column is of type: #{column.type.inspect}.}
-        end
+        @model_class = model_class
+        @column = find_column(column_name)
 
         validate_options(options)
 
-        @model_class = model_class
-        @column = column
         @options = options
         @field_set = FlexColumns::Definition::FieldSet.new(self)
 
@@ -232,6 +220,14 @@ module FlexColumns
         block_result
       end
 
+      # This method gets called when ActiveRecord::Base.reset_column_information is called on the underlying model;
+      # this simply updates our notion of what column is present. Most importantly, this will correctly switch us from
+      # a table-does-not-exist state to a table-exists state (if you migrate the table in), but it also will correctly
+      # switch from one column type to another, etc.
+      def reset_column_information
+        @column = find_column(column_name)
+      end
+
       # Tells this class to re-publish all its methods to the DynamicMethodsModule it uses internally, and to the
       # model class it's a part of.
       #
@@ -275,6 +271,40 @@ module FlexColumns
         end
       end
 
+      # Given the name of a column, finds the column on the model and makes sure it complies with our
+      # requirements for columns we can store data in.
+      #
+      # However, if the underlying table doesn't currently exist, this creates a "fake" column object and returns it;
+      # this fake column object responds to just enough methods that we can use it successfully in this gem. This is
+      # used so that we can define flex columns on a model for a table that doesn't exist yet (typically, because it
+      # hasn't been migrated in yet), and effectively upgrade it using .reset_column_information, above, when it
+      # does exist.
+      def find_column(column_name)
+        return create_temporary_fake_column(column_name) if (! @model_class.table_exists?)
+
+        out = model_class.columns.detect { |c| c.name.to_s == column_name.to_s }
+        unless out
+          raise FlexColumns::Errors::NoSuchColumnError, %{You're trying to define a flex column #{column_name.inspect}, but
+the model you're defining it on, #{model_class.name}, seems to have no column
+named that.
+
+It has columns named: #{model_class.columns.map(&:name).sort_by(&:to_s).join(", ")}.}
+        end
+
+        unless out.type == :binary || out.text? || out.sql_type == "json" # for PostgreSQL >= 9.2, which has a native JSON data type
+          raise FlexColumns::Errors::InvalidColumnTypeError, %{You're trying to define a flex column #{column_name.inspect}, but
+that column (on model #{model_class.name}) isn't of a type that accepts text.
+That column is of type: #{out.type.inspect}.}
+        end
+
+        out
+      end
+
+      # This creates a "fake" column that we can use if the underlying table doesn't exist yet.
+      def create_temporary_fake_column(column_name)
+        ::FlexColumns::Definition::FakeColumn.new(column_name)
+      end
+
       # Check all of our options to make sure they're correct. This is pretty defensive programming, but it is SO
       # much nicer to get an error on startup if you've specified anything incorrectly than way on down the line,
       # possibly in production, when it really matters.

data/lib/flex_columns/has_flex_columns.rb

@@ -17,6 +17,10 @@ module FlexColumns
     included do
       before_validation :_flex_columns_before_validation!
       before_save :_flex_columns_before_save!
+
+      class << self
+        alias_method_chain :reset_column_information, :flex_columns
+      end
     end
 
     # Before we save this model, make sure each flex column has a chance to serialize itself up and assign itself
@@ -133,6 +137,12 @@ module FlexColumns
     end
 
     module ClassMethods
+      def reset_column_information_with_flex_columns
+        reset_column_information_without_flex_columns
+        _flex_column_classes.each { |c| c.reset_column_information }
+        _flex_columns_redefine_all_methods!
+      end
+
       # Does this class have any flex columns? If this module has been included into a class, then the answer is true.
       def has_any_flex_columns?
         true
@@ -177,8 +187,6 @@ it has flex columns named: #{_all_flex_column_names.sort_by(&:to_s).inspect}.}
       # FlexColumns::Definition::FlexColumnContentsClass#setup!, and so can contain any of the options that that method
       # accepts. The block, if passed, will be evaluated in the context of the generated class.
       def flex_column(flex_column_name, options = { }, &block)
-        return unless table_exists?
-
         flex_column_name = _flex_column_normalize_name(flex_column_name)
 
         new_class = Class.new(FlexColumns::Contents::FlexColumnContentsBase)
@@ -191,6 +199,12 @@ it has flex columns named: #{_all_flex_column_names.sort_by(&:to_s).inspect}.}
           _flex_column_object_for(flex_column_name)
         end
 
+        _flex_columns_redefine_all_methods!
+      end
+
+      # Defines, or redefines, all methods on the dynamic-methods module associated with this model. This gets called
+      # whenever we define a new flex column, or if you call .reset_column_information on the associated model.
+      def _flex_columns_redefine_all_methods!
         _flex_column_dynamic_methods_module.remove_all_methods!
         _flex_column_classes.each(&:sync_methods!)
       end

data/lib/flex_columns/version.rb

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

data/spec/flex_columns/helpers/system_helpers.rb

@@ -14,6 +14,14 @@ module FlexColumns
         end
       end
 
+      def reset_schema_cache!(model)
+        if model.connection.respond_to?(:schema_cache)
+          model.connection.schema_cache.clear!
+        elsif model.connection.respond_to?(:clear_cache!)
+          model.connection.clear_cache!
+        end
+      end
+
       def define_model_class(name, table_name, &block)
         model_class = Class.new(::ActiveRecord::Base)
         ::Object.send(:remove_const, name) if ::Object.const_defined?(name)

data/spec/flex_columns/system/basic_system_spec.rb

@@ -280,8 +280,6 @@ describe "FlexColumns basic operations" do
         user.name = 'User 1'
         user.wants_email = [ 1, 2, 3 ]
 
-        $stderr.puts "ATTRIBUTES: #{user.attributes.keys.sort.inspect}"
-
         user_json = JSON.dump(user)
         parsed = JSON.parse(user_json)
 
@@ -308,6 +306,7 @@ describe "FlexColumns basic operations" do
           field :bbb
         end
       end
+      define_model_class(:UserBackdoor, 'flexcols_spec_users') { }
 
       ::User.reset_column_information
 

data/spec/flex_columns/system/dynamism_system_spec.rb

@@ -26,6 +26,82 @@ describe "FlexColumns basic operations" do
     end
   end
 
+  it "should handle the case where a table comes into existence after being defined -- like it will when running a bunch of migrations at once" do
+    migrate do
+      drop_table :flexcols_coming_into_existence rescue nil
+    end
+
+    class ::Foo < ::ActiveRecord::Base
+      self.table_name = 'flexcols_coming_into_existence'
+
+      flex_column :foo do
+        field :att1
+        field :att2
+      end
+    end
+
+    migrate do
+      create_table :flexcols_coming_into_existence do |t|
+        t.string :name
+        t.string :foo
+      end
+    end
+
+    reset_schema_cache!(Foo)
+    Foo.reset_column_information
+
+    f2 = Foo.new
+    f2.att1 = "the_att1"
+    f2.att2 = "the_att2"
+    f2.save!
+
+    f2_again = Foo.find(f2.id)
+    f2_again.att1.should == "the_att1"
+    f2_again.att2.should == "the_att2"
+  end
+
+  it "should handle the case where a table comes into existence after being defined, and properly respect things like :binary and compression" do
+    migrate do
+      drop_table :flexcols_coming_into_existence rescue nil
+    end
+
+    class ::Foo < ::ActiveRecord::Base
+      self.table_name = 'flexcols_coming_into_existence'
+
+      flex_column :foo do
+        field :att1
+        field :att2
+      end
+    end
+
+    migrate do
+      create_table :flexcols_coming_into_existence do |t|
+        t.string :name
+        t.binary :foo
+      end
+    end
+
+    reset_schema_cache!(Foo)
+    Foo.reset_column_information
+
+    f2 = Foo.new
+    f2.att1 = "the_att1"
+    f2.att2 = "the_att2" * 1000
+    f2.save!
+
+    f2_again = Foo.find(f2.id)
+    f2_again.att1.should == "the_att1"
+    f2_again.att2.should == "the_att2" * 1000
+
+    class ::FooBackdoor < ActiveRecord::Base
+      self.table_name = 'flexcols_coming_into_existence'
+    end
+
+    f2_backdoor = ::FooBackdoor.find(f2.id)
+    data = f2_backdoor.foo
+    data.should match(/^FC:01,1,/i)
+  end
+
   it "should let you redefine flex columns, and obey the new settings" do
     class ::User < ::ActiveRecord::Base
       self.table_name = 'flexcols_spec_users'

data/spec/flex_columns/system/performance_system_spec.rb

@@ -130,8 +130,8 @@ describe "FlexColumns performance" do
 
     before :each do
       migrate do
-        drop_table :flexcols_spec_users rescue nil
-        create_table :flexcols_spec_users do |t|
+        drop_table :flexcols_spec_users_2 rescue nil
+        create_table :flexcols_spec_users_2 do |t|
           t.string :name, :null => false
           t.text :text_attrs_nonnull, :null => false
           t.text :text_attrs_null
@@ -140,9 +140,9 @@ describe "FlexColumns performance" do
         end
       end
 
-      ::User.reset_column_information
+      # reset_schema_cache!(::User) if defined?(::User)
 
-      define_model_class(:User, 'flexcols_spec_users') do
+      define_model_class(:User2, 'flexcols_spec_users_2') do
         flex_column :text_attrs_nonnull do
           field :aaa
         end
@@ -157,9 +157,9 @@ describe "FlexColumns performance" do
         end
       end
 
-      define_model_class(:UserBackdoor, 'flexcols_spec_users') { }
+      define_model_class(:User2Backdoor, 'flexcols_spec_users_2') { }
 
-      ::UserBackdoor.reset_column_information
+      ::User2Backdoor.reset_column_information
     end
 
     it "should be smart enough to store an empty JSON string to the database, if necessary, if the column is non-NULL" do
@@ -171,11 +171,11 @@ describe "FlexColumns performance" do
       # those circumstances, rather than trying to work around this (pretty broken) behavior that's also a pretty rare
       # edge case for us.
       unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && @dh.database_type == :mysql
-        my_user = ::User.new
+        my_user = ::User2.new
         my_user.name = 'User 1'
         my_user.save!
 
-        user_bd = ::UserBackdoor.find(my_user.id)
+        user_bd = ::User2Backdoor.find(my_user.id)
         user_bd.name.should == 'User 1'
         user_bd.text_attrs_nonnull.should == ""
         user_bd.text_attrs_null.should == nil
@@ -185,7 +185,7 @@ describe "FlexColumns performance" do
     end
 
     it "should store NULL or the empty string in the database, as appropriate, if there's no data left any more" do
-      my_user = ::User.new
+      my_user = ::User2.new
       my_user.name = 'User 1'
       my_user.aaa = 'aaa1'
       my_user.bbb = 'bbb1'
@@ -193,21 +193,21 @@ describe "FlexColumns performance" do
       my_user.ddd = 'ddd1'
       my_user.save!
 
-      user_bd = ::UserBackdoor.find(my_user.id)
+      user_bd = ::User2Backdoor.find(my_user.id)
       user_bd.name.should == 'User 1'
       check_text_column_data(user_bd.text_attrs_nonnull, 'aaa', 'aaa1')
       check_text_column_data(user_bd.text_attrs_null, 'bbb', 'bbb1')
       check_binary_column_data(user_bd.binary_attrs_nonnull, 'ccc', 'ccc1')
       check_binary_column_data(user_bd.binary_attrs_null, 'ddd', 'ddd1')
 
-      user_again = ::User.find(my_user.id)
+      user_again = ::User2.find(my_user.id)
       user_again.aaa = nil
       user_again.bbb = nil
       user_again.ccc = nil
       user_again.ddd = nil
       user_again.save!
 
-      user_bd_again = ::UserBackdoor.find(my_user.id)
+      user_bd_again = ::User2Backdoor.find(my_user.id)
       user_bd_again.name.should == 'User 1'
       user_bd_again.text_attrs_nonnull.should == ""
       user_bd_again.text_attrs_null.should == nil

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

@@ -0,0 +1,8 @@
+describe ::FlexColumns::Definition::FakeColumn do
+  it "should have the right properties" do
+    c = ::FlexColumns::Definition::FakeColumn.new(:foo)
+    c.name.should == :foo
+    c.null.should == true
+    c.type.should == :string
+  end
+end

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

@@ -10,6 +10,7 @@ describe FlexColumns::Definition::FlexColumnContentsClass do
     @klass.send(:extend, FlexColumns::Definition::FlexColumnContentsClass)
 
     @model_class = double("model_class")
+    allow(@model_class).to receive(:table_exists?).with().and_return(true)
     allow(@model_class).to receive(:kind_of?).with(Class).and_return(true)
     allow(@model_class).to receive(:has_any_flex_columns?).with().and_return(true)
     allow(@model_class).to receive(:name).with().and_return(:mcname)
@@ -121,6 +122,12 @@ describe FlexColumns::Definition::FlexColumnContentsClass do
       e.message.should match(/integer/i)
     end
 
+    it "should work if the table doesn't exist" do
+      allow(@model_class).to receive(:table_exists?).with().and_return(false)
+      allow(@model_class).to receive(:columns).and_raise(StandardError) # to make sure we don't touch this
+      @klass.setup!(@model_class, :foo) { }
+    end
+
     it "should work on a text column" do
       @klass.setup!(@model_class, :foo) { }
     end
@@ -204,6 +211,41 @@ describe FlexColumns::Definition::FlexColumnContentsClass do
     end
   end
 
+  describe "reset_column_information" do
+    it "should still generate a fake column if the table still doesn't exist" do
+      allow(@model_class).to receive(:table_exists?).with().and_return(false)
+      @klass.setup!(@model_class, :bar) { }
+      c = @klass.column
+      c.name.should == :bar
+      c.type.should == :string
+      c.null.should == true
+
+      @klass.reset_column_information
+      c = @klass.column
+      c.name.should == :bar
+      c.type.should == :string
+      c.null.should == true
+    end
+
+    it "should pull a real column if the table does exist" do
+      allow(@column_bar).to receive(:null).with().and_return(false)
+
+      allow(@model_class).to receive(:table_exists?).with().and_return(false)
+      @klass.setup!(@model_class, :bar) { }
+      c = @klass.column
+      c.name.should == :bar
+      c.type.should == :string
+      c.null.should == true
+
+      allow(@model_class).to receive(:table_exists?).with().and_return(true)
+      @klass.reset_column_information
+      c = @klass.column
+      c.name.should == :bar
+      c.type.should == :binary
+      c.null.should == false
+    end
+  end
+
   describe "_flex_columns_create_column_data" do
     def expect_options_transform(class_options, length_limit, resulting_options, column_name = :foo, storage_string = double("storage_string"))
       @klass.setup!(@model_class, column_name, class_options)

data/spec/flex_columns/unit/has_flex_columns_spec.rb

@@ -30,6 +30,10 @@ describe FlexColumns::HasFlexColumns do
         def table_exists?
           true
         end
+
+        def reset_column_information
+          # nothing here
+        end
       end
 
       def _flex_column_object_for(column_name, create_if_needed = true)
@@ -59,6 +63,39 @@ describe FlexColumns::HasFlexColumns do
     @klass.has_any_flex_columns?.should be
   end
 
+  describe "#_flex_columns_redefine_all_methods" do
+    it "should remove all methods on the module, and then add them back" do
+      dmm = double("dmm")
+      expect(FlexColumns::Util::DynamicMethodsModule).to receive(:new).once.with(@klass, :FlexColumnsDynamicMethods).and_return(dmm)
+
+      fcc1 = double("fcc1", :column_name => :foo)
+      expect(Class).to receive(:new).once.ordered.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(fcc1)
+      expect(fcc1).to receive(:setup!).once.ordered.with(@klass, :foo, { })
+
+      expect(dmm).to receive(:remove_all_methods!).once.ordered.with()
+      expect(fcc1).to receive(:sync_methods!).once.ordered.with()
+
+      @klass.flex_column(:foo)
+
+      fcc2 = double("fcc2", :column_name => :bar)
+      expect(Class).to receive(:new).once.ordered.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(fcc2)
+      expect(fcc2).to receive(:setup!).once.ordered.with(@klass, :bar, { })
+
+      expect(dmm).to receive(:remove_all_methods!).once.ordered.with()
+      expect(fcc1).to receive(:sync_methods!).once.ordered.with()
+      expect(fcc2).to receive(:sync_methods!).once.ordered.with()
+
+      @klass.flex_column(:bar)
+
+
+      expect(dmm).to receive(:remove_all_methods!).once.ordered.with()
+      expect(fcc1).to receive(:sync_methods!).once.ordered.with()
+      expect(fcc2).to receive(:sync_methods!).once.ordered.with()
+
+      @klass._flex_columns_redefine_all_methods!
+    end
+  end
+
   describe "#flex_column" do
     it "should do nothing if the table doesn't exist" do
       allow(@klass).to receive(:table_exists?).with().and_return(false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: flex_columns
 version: !ruby/object:Gem::Version 
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors: 
 - Andrew Geweke
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-04-07 00:00:00 Z
+date: 2014-04-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -106,6 +106,7 @@ files:
 - lib/flex_columns/active_record/base.rb
 - lib/flex_columns/contents/column_data.rb
 - lib/flex_columns/contents/flex_column_contents_base.rb
+- lib/flex_columns/definition/fake_column.rb
 - lib/flex_columns/definition/field_definition.rb
 - lib/flex_columns/definition/field_set.rb
 - lib/flex_columns/definition/flex_column_contents_class.rb
@@ -135,6 +136,7 @@ files:
 - spec/flex_columns/unit/active_record/base_spec.rb
 - spec/flex_columns/unit/contents/column_data_spec.rb
 - spec/flex_columns/unit/contents/flex_column_contents_base_spec.rb
+- spec/flex_columns/unit/definition/fake_column_spec.rb
 - spec/flex_columns/unit/definition/field_definition_spec.rb
 - spec/flex_columns/unit/definition/field_set_spec.rb
 - spec/flex_columns/unit/definition/flex_column_contents_class_spec.rb
@@ -187,6 +189,7 @@ test_files:
 - spec/flex_columns/unit/active_record/base_spec.rb
 - spec/flex_columns/unit/contents/column_data_spec.rb
 - spec/flex_columns/unit/contents/flex_column_contents_base_spec.rb
+- spec/flex_columns/unit/definition/fake_column_spec.rb
 - spec/flex_columns/unit/definition/field_definition_spec.rb
 - spec/flex_columns/unit/definition/field_set_spec.rb
 - spec/flex_columns/unit/definition/flex_column_contents_class_spec.rb