has_dynamic_columns 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f728b40892f557858d9809deb92fe4f6c80e54a
-  data.tar.gz: f8c151d8a22042bfb7803be46dce5aefd06600a4
+  metadata.gz: 654ea8aee466792c91ae8278022ad10ff034c072
+  data.tar.gz: 7f5f8b41a767bd2fc12ab09b4d5c3e8df57e5e96
 SHA512:
-  metadata.gz: 7a73f110f7ea4dd8e4509e9cb62b53016976e4cdf98286511e5ccd8fa09fe939b1535e829ef561179fc46c87d36fc084c53abf2bdc1fa6cbba19c5aa4977e382
-  data.tar.gz: a186cb3ab5e69896847bb6e91a8f291435680547d1013fae4c76b189642f12714f0cd7c95cfacb893bf81d460d4fd871623733b98b1d1db8039cf695756b2ddf
+  metadata.gz: 76a5cf1aa4b44b2ba1e6a02b40150ef23222015d3c812e3cb3061b44ceda271f5ebe9296cb2d5f19d44c1ee7ed064c0c90beacefa56903d256b2217969f19c69
+  data.tar.gz: f2adf795d3b55a202237b5edbfb8f780ceb79d2011d19bb9916c16dc8a0edb389c2fc01d31d35e7c924523267900038e4a3c3aee2160b8626c69c6cdfb1fc9f3

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 2.0.0
+  - 1.9.3
+script: rspec spec

data/README.md

@@ -1,3 +1,6 @@
+[![Gem Version](https://badge.fury.io/rb/has_dynamic_columns.svg)](http://badge.fury.io/rb/has_dynamic_columns)
+[![Build Status](https://travis-ci.org/butchmarshall/has_dynamic_columns.svg?branch=master)](https://travis-ci.org/butchmarshall/has_dynamic_columns)
+
 has_dynamic_columns
 ============
 
@@ -6,6 +9,13 @@ This plugin gives ActiveRecord models the ability to dynamically define collecta
 Release Notes
 ============
 
+**0.3.5**
+ - Added model storage type (for storing association with other activerecord objects)
+
+**0.3.4**
+ - Can now store array of data
+ - JRuby support
+
 **0.3.0**
  - Moved to storing data types in separate tables (where/order now correct!)
  - Added order.by_dynamic_columns
@@ -24,6 +34,7 @@ running the following command:
 
     rails generate has_dynamic_columns:active_record
 	rails generate has_dynamic_columns:upgrade_0_3_0_active_record
+	rails generate has_dynamic_columns:upgrade_0_3_4_active_record
     rake db:migrate
 
 Usage

data/has_dynamic_columns.gemspec

@@ -19,9 +19,13 @@ Gem::Specification.new do |spec|
 	spec.require_paths = ["lib"]
 
 	spec.add_dependency "activerecord", [">= 3.0", "< 5.0"]
-
-	spec.add_development_dependency "sqlite3", "> 0"
-	spec.add_development_dependency "factory_girl", "> 0"
+	if RUBY_PLATFORM == 'java'
+		spec.add_development_dependency "jdbc-sqlite3", "> 0"
+		spec.add_development_dependency "activerecord-jdbcsqlite3-adapter", "> 0"
+	else
+		spec.add_development_dependency "sqlite3", "> 0"
+	end
+	spec.add_development_dependency "factory_girl", "> 4.0"
 	spec.add_development_dependency "bundler", "~> 1.7"
 	spec.add_development_dependency "rake", "~> 10.0"
 end

data/lib/generators/has_dynamic_columns/templates/migration_0.3.4.rb

@@ -0,0 +1,8 @@
+class Upgrade034HasDynamicColumns < ActiveRecord::Migration
+	def self.up
+		add_column :dynamic_columns, :multiple, :boolean, :default => false
+	end
+
+	def self.down
+	end
+end

data/lib/generators/has_dynamic_columns/templates/migration_0.3.5.rb

@@ -0,0 +1,15 @@
+class Upgrade035HasDynamicColumns < ActiveRecord::Migration
+	def self.up
+		create_table :dynamic_column_model_data do |t|
+			t.integer :value_id
+			t.string :value_type
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_model_data, [:value_id,:value_type], name: "index_by_value")
+		add_column :dynamic_columns, :class_name, :string
+		add_column :dynamic_columns, :column_name, :string
+	end
+
+	def self.down
+	end
+end

data/lib/generators/has_dynamic_columns/upgrade_0_3_4_active_record_generator.rb

@@ -0,0 +1,22 @@
+require "generators/has_dynamic_columns/has_dynamic_columns_generator"
+require "generators/has_dynamic_columns/next_migration_version"
+require "rails/generators/migration"
+require "rails/generators/active_record"
+
+# Extend the HasDynamicColumnsGenerator so that it creates an AR migration
+module HasDynamicColumns
+	class Upgrade_0_3_4_ActiveRecordGenerator < ::HasDynamicColumnsGenerator
+		include Rails::Generators::Migration
+		extend NextMigrationVersion
+
+		source_paths << File.join(File.dirname(__FILE__), "templates")
+
+		def create_migration_file
+			migration_template "migration_0.3.4.rb", "db/migrate/upgrade_0_3_4_has_dynamic_columns.rb"
+		end
+
+		def self.next_migration_number(dirname)
+			::ActiveRecord::Generators::Base.next_migration_number dirname
+		end
+	end
+end

data/lib/generators/has_dynamic_columns/upgrade_0_3_5_active_record_generator.rb

@@ -0,0 +1,22 @@
+require "generators/has_dynamic_columns/has_dynamic_columns_generator"
+require "generators/has_dynamic_columns/next_migration_version"
+require "rails/generators/migration"
+require "rails/generators/active_record"
+
+# Extend the HasDynamicColumnsGenerator so that it creates an AR migration
+module HasDynamicColumns
+	class Upgrade_0_3_5_ActiveRecordGenerator < ::HasDynamicColumnsGenerator
+		include Rails::Generators::Migration
+		extend NextMigrationVersion
+
+		source_paths << File.join(File.dirname(__FILE__), "templates")
+
+		def create_migration_file
+			migration_template "migration_0.3.5.rb", "db/migrate/upgrade_0_3_5_has_dynamic_columns.rb"
+		end
+
+		def self.next_migration_number(dirname)
+			::ActiveRecord::Generators::Base.next_migration_number dirname
+		end
+	end
+end

data/lib/has_dynamic_columns/active_record/query_methods.rb

@@ -1 +1,232 @@
-require_relative "v#{ActiveRecord::VERSION::MAJOR}/query_methods"
+# Common modifications to ActiveRecord::QueryMethods
+require_relative "v#{ActiveRecord::VERSION::MAJOR}/query_methods"
+
+module HasDynamicColumns
+	module ActiveRecord
+		module QueryMethods
+			def self.included(base)
+				base.class_eval do
+					include ClassMethods
+
+					alias_method_chain :order, :dynamic_columns
+					alias_method_chain :where, :dynamic_columns
+					alias_method_chain :build_arel, :dynamic_columns
+
+					def dynamic_column_process_arel_nodes(rel, scope, index, joins)
+						case rel
+						when Arel::Nodes::Grouping
+							dynamic_column_process_arel_nodes(rel.expr, scope, index+1, joins)
+						when Arel::Nodes::Or
+							dynamic_column_process_arel_nodes(rel.left, scope, index+1, joins)
+							dynamic_column_process_arel_nodes(rel.right, scope, index+10000, joins) # Hack - queries with over 10,000 dynamic where conditions may break
+						when Arel::Nodes::And
+							dynamic_column_process_arel_nodes(rel.left, scope, index+1, joins)
+							dynamic_column_process_arel_nodes(rel.right, scope, index+10000, joins) # Hack - queries with over 10,000 dynamic where conditions may break
+						# We can work with this
+						when Arel::Nodes::Descending
+							col_name = rel.expr.name
+							dynamic_type = rel.expr.relation.engine
+
+							rel.expr.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table]
+							rel.expr.name = :value
+						# We can work with this
+						when Arel::Nodes::Ascending
+							col_name = rel.expr.name
+							dynamic_type = rel.expr.relation.engine
+
+							rel.expr.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table]
+							rel.expr.name = :value
+						# We can work with this
+						else
+							col_name = rel.left.name
+							dynamic_type = rel.left.relation.engine.to_s
+
+							res = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins) # modify the where to use the aliased table
+
+							rel.left.relation = res[:table]
+							rel.left.name = res[:column] || :value # value is the data storage column searchable on dynamic_column_data table
+						end
+					end
+
+					# Builds the joins required for this dynamic column
+					# Modifies the where to use the dynamic_column_data table alias
+					#
+					# rel - an arel node
+					# scope - scope to run the conditions in
+					# index - unique table identifier
+					# joins - list of joins processed (to prevent duplicates)
+					def dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index, joins)
+						field_scope = scope
+						field_scope_id = (!field_scope.nil?) ? field_scope.id : nil
+						field_scope_type = (!field_scope.nil?) ? field_scope.class.name.constantize.to_s : nil
+
+						joins_scope_key = "#{field_scope_type}_#{field_scope_id}"
+						joins[joins_scope_key] ||= {}
+
+						column_datum_store_table_type = "HasDynamicColumns::DynamicColumnStringDatum"
+						if !field_scope.nil? && a = field_scope.activerecord_dynamic_columns.where(key: col_name).first
+							column_datum_store_table_type = "HasDynamicColumns::DynamicColumn#{a.data_type.to_s.capitalize}Datum"
+						end
+
+						column_table = HasDynamicColumns::DynamicColumn.arel_table.alias("dynamic_where_#{index}_#{col_name}")
+						column_datum_table = HasDynamicColumns::DynamicColumnDatum.arel_table.alias("dynamic_where_data_#{index}_#{col_name}")
+						column_datum_store_table = column_datum_store_table_type.constantize.arel_table.alias("dynamic_where_data_store_#{index}_#{col_name}")
+
+						# Join for this scope/col already added - continue
+						if !joins[joins_scope_key][col_name].nil?
+							return joins[joins_scope_key][col_name]
+						end
+
+						# Join on the column with the key
+						on_query = column_table[:key].eq(col_name)
+						on_query = on_query.and(
+							column_table[:field_scope_type].eq(field_scope_type)
+						) unless field_scope_type.nil?
+
+						on_query = on_query.and(
+							column_table[:field_scope_id].eq(field_scope_id)
+						) unless field_scope_id.nil?
+
+						column_table_join_on = column_table
+												.create_on(
+													on_query
+												)
+
+						join_scope_type = (field_scope_id.nil?)? Arel::Nodes::OuterJoin : Arel::Nodes::InnerJoin
+
+						column_table_join = table.create_join(column_table, column_table_join_on)
+						self.joins_values += [column_table_join]
+
+						# Join on all the data with the provided key
+						column_table_datum_join_on = column_datum_table
+												.create_on(
+													column_datum_table[:owner_id].eq(table[:id]).and(
+														column_datum_table[:owner_type].eq(dynamic_type.to_s)
+													).and(
+														column_datum_table[:dynamic_column_id].eq(column_table[:id])
+													)
+												)
+
+						column_table_datum_join = table.create_join(column_datum_table, column_table_datum_join_on, join_scope_type)
+						self.joins_values += [column_table_datum_join]
+
+						# Join on the actual data
+						column_table_datum_store_join_on = column_datum_store_table
+												.create_on(
+													column_datum_table[:datum_id].eq(column_datum_store_table[:id]).and(
+														column_datum_table[:datum_type].eq(column_datum_store_table_type)
+													)
+												)
+
+						column_table_datum_store_join = table.create_join(column_datum_store_table, column_table_datum_store_join_on, join_scope_type)
+						self.joins_values += [column_table_datum_store_join]
+
+						column_name = :value
+
+						# If this dynamic column points to another model we need to join on that table
+						if !field_scope.nil? && assoc = field_scope.activerecord_dynamic_columns.where(data_type: "model", key: col_name).first
+							assoc_table = assoc.class_name.constantize.arel_table.alias("dynamic_where_associated_data_#{index}_#{col_name}")
+							
+							join_on = assoc_table.create_on(
+													column_datum_store_table[:value_id].eq(assoc_table[:id]).and(
+														column_datum_store_table[:value_type].eq(assoc.class_name)
+													)
+												)
+							join = table.create_join(assoc_table, join_on)
+							self.joins_values += [join]
+
+							column_table_datum_store_join = join
+							column_datum_store_table = assoc_table
+							column_name = assoc.column_name.to_sym
+						end
+
+						# Track the joins
+						# - So they can be referenced later
+						# - So we don't make more joins than we have to
+						joins[joins_scope_key][col_name] = {
+							:join => column_table_datum_store_join,
+							:table => column_datum_store_table,
+							:column => column_name
+						}
+
+						joins[joins_scope_key][col_name]
+					end
+
+					# Builds all the joins required for the dynamic columns in the where/order clauses
+					def build_dynamic_column_joins
+						joins = {}
+
+						self.where_dynamic_columns_values.each_with_index { |dynamic_scope, index_outer|
+							dynamic_scope[:where].each_with_index { |rel, index_inner|
+								# Process each where
+								dynamic_column_process_arel_nodes(rel, dynamic_scope[:scope], (index_outer*1000)+(index_inner*10000), joins)
+
+								# Warning
+								# Must cast rel to a string - I've encountered ***strange*** situations where this will change the 'col_name' to value in the where clause
+								# specifically, the test 'case should restrict if scope specified' will fail
+								self.where_values += [rel.to_sql]
+							}
+						}
+						self.order_dynamic_columns_values.each_with_index { |dynamic_scope, index_outer|
+							dynamic_scope[:order].each_with_index { |rel, index_inner|
+								# Process each order
+								dynamic_column_process_arel_nodes(rel, dynamic_scope[:scope], (index_outer*1000)+(index_inner*10000), joins)
+							}
+						}
+
+						true
+					end
+				end
+			end
+
+			# When arel starts building - filter
+			def build_arel_with_dynamic_columns
+				self.build_dynamic_column_joins
+
+				if self.where_dynamic_columns_values.length > 0 || self.order_dynamic_columns_values.length > 0
+					self.group_values += [Arel::Nodes::Group.new(table[:id])]
+				end
+
+				build_arel_without_dynamic_columns
+			end
+
+			# OrderChain objects act as placeholder for queries in which #order does not have any parameter.
+			# In this case, #order must be chained with #by_dynamic_columns to return a new relation.
+			class OrderChain
+				def initialize(scope)
+					@scope = scope
+				end
+
+				def by_dynamic_columns(*args)
+					@scope.send(:preprocess_order_args, args)
+
+					# Add now - want to keep the order with the regular column orders
+					@scope.order_values += args
+
+					# Map
+					dynamic_columns_value = {
+						:scope => nil,
+						:order => args,
+					}
+					@scope.order_dynamic_columns_values = dynamic_columns_value
+
+					chain = ::ActiveRecord::QueryMethods::OrderChain.new(@scope)
+					chain.instance_eval do
+						# Make outer scope variable accessible
+						@dynamic_columns_value = dynamic_columns_value
+
+						# Extends where to chain with a has_scope method
+						# This scopes the where from above
+						def with_scope(opt)
+							@dynamic_columns_value[:scope] = opt
+
+							@scope
+						end
+					end
+
+					chain
+				end
+			end
+		end
+	end
+end

data/lib/has_dynamic_columns/active_record/v3/query_methods.rb

@@ -1,189 +1,39 @@
+# ActiveRecord v3 specific changes
+
 module HasDynamicColumns
 	module ActiveRecord
 		module QueryMethods
-			def self.included(base)
-				base.class_eval do
-					alias_method_chain :order, :dynamic_columns
-					alias_method_chain :where, :dynamic_columns
-					alias_method_chain :build_arel, :dynamic_columns
-
-					def preprocess_order_args(order_args)
-						order_args.flatten!
-						#validate_order_args(order_args)
-
-						references = order_args.grep(String)
-						references.map! { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }.compact!
-						references!(references) if references.any?
-
-						# if a symbol is given we prepend the quoted table name
-						order_args.map! do |arg|
-							case arg
-							when Symbol
-								#arg = klass.attribute_alias(arg) if klass.attribute_alias?(arg)
-								table[arg].asc
-							when Hash
-								arg.map { |field, dir|
-									#field = klass.attribute_alias(field) if klass.attribute_alias?(field)
-									table[field].send(dir.downcase)
-								}
-							else
-								arg
-							end
-						end.flatten!
-					end
-
-
-					def dynamic_column_process_arel_nodes(rel, scope, index, joins)
-						case rel
-						when Arel::Nodes::Grouping
-							dynamic_column_process_arel_nodes(rel.expr, scope, index+1, joins)
-						when Arel::Nodes::Or
-							dynamic_column_process_arel_nodes(rel.left, scope, index+1, joins)
-							dynamic_column_process_arel_nodes(rel.right, scope, index+10000, joins) # Hack - queries with over 10,000 dynamic where conditions may break
-						when Arel::Nodes::And
-							dynamic_column_process_arel_nodes(rel.left, scope, index+1, joins)
-							dynamic_column_process_arel_nodes(rel.right, scope, index+10000, joins) # Hack - queries with over 10,000 dynamic where conditions may break
-						# We can work with this
-						when Arel::Nodes::Descending
-							col_name = rel.expr.name
-							dynamic_type = rel.expr.relation.engine
-
-							rel.expr.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table]
-							rel.expr.name = :value
-						# We can work with this
-						when Arel::Nodes::Ascending
-							col_name = rel.expr.name
-							dynamic_type = rel.expr.relation.engine
-
-							rel.expr.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table]
-							rel.expr.name = :value
-						# We can work with this
-						else
-							col_name = rel.left.name
-							dynamic_type = rel.left.relation.engine.to_s
-
-							rel.left.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table] # modify the where to use the aliased table
-							rel.left.name = :value # value is the data storage column searchable on dynamic_column_data table
-						end
-					end
-
-					# Builds the joins required for this dynamic column
-					# Modifies the where to use the dynamic_column_data table alias
-					#
-					# rel - an arel node
-					# scope - scope to run the conditions in
-					# index - unique table identifier
-					# joins - list of joins processed (to prevent duplicates)
-					def dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index, joins)
-						field_scope = scope
-						field_scope_id = (!field_scope.nil?) ? field_scope.id : nil
-						field_scope_type = (!field_scope.nil?) ? field_scope.class.name.constantize.to_s : nil
-
-						joins_scope_key = "#{field_scope_type}_#{field_scope_id}"
-						joins[joins_scope_key] ||= {}
-
-						column_datum_store_table_type = "HasDynamicColumns::DynamicColumnStringDatum"
-						if !field_scope.nil? && a = field_scope.activerecord_dynamic_columns.where(key: col_name).first
-							column_datum_store_table_type = "HasDynamicColumns::DynamicColumn#{a.data_type.to_s.capitalize}Datum"
+			module ClassMethods
+				def self.included base
+					base.class_eval do
+						def preprocess_order_args(order_args)
+							order_args.flatten!
+							#validate_order_args(order_args)
+
+							references = order_args.grep(String)
+							references.map! { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }.compact!
+							references!(references) if references.any?
+
+							# if a symbol is given we prepend the quoted table name
+							order_args.map! do |arg|
+								case arg
+								when Symbol
+									#arg = klass.attribute_alias(arg) if klass.attribute_alias?(arg)
+									table[arg].asc
+								when Hash
+									arg.map { |field, dir|
+										#field = klass.attribute_alias(field) if klass.attribute_alias?(field)
+										table[field].send(dir.downcase)
+									}
+								else
+									arg
+								end
+							end.flatten!
 						end
-
-						column_table = HasDynamicColumns::DynamicColumn.arel_table.alias("dynamic_where_#{index}_#{col_name}")
-						column_datum_table = HasDynamicColumns::DynamicColumnDatum.arel_table.alias("dynamic_where_data_#{index}_#{col_name}")
-						column_datum_store_table = column_datum_store_table_type.constantize.arel_table.alias("dynamic_where_data_store_#{index}_#{col_name}")
-
-						# Join for this scope/col already added - continue
-						if !joins[joins_scope_key][col_name].nil?
-							return joins[joins_scope_key][col_name]
-						end
-
-						# Join on the column with the key
-						on_query = column_table[:key].eq(col_name)
-						on_query = on_query.and(
-							column_table[:field_scope_type].eq(field_scope_type)
-						) unless field_scope_type.nil?
-
-						on_query = on_query.and(
-							column_table[:field_scope_id].eq(field_scope_id)
-						) unless field_scope_id.nil?
-
-						column_table_join_on = column_table
-												.create_on(
-													on_query
-												)
-
-						column_table_join = table.create_join(column_table, column_table_join_on)
-						self.joins_values += [column_table_join]
-
-						# Join on all the data with the provided key
-						column_table_datum_join_on = column_datum_table
-												.create_on(
-													column_datum_table[:owner_id].eq(table[:id]).and(
-														column_datum_table[:owner_type].eq(dynamic_type.to_s)
-													).and(
-														column_datum_table[:dynamic_column_id].eq(column_table[:id])
-													)
-												)
-
-						column_table_datum_join = table.create_join(column_datum_table, column_table_datum_join_on, Arel::Nodes::OuterJoin)
-						self.joins_values += [column_table_datum_join]
-
-						# Join on the actual data
-						column_table_datum_store_join_on = column_datum_store_table
-												.create_on(
-													column_datum_table[:datum_id].eq(column_datum_store_table[:id]).and(
-														column_datum_table[:datum_type].eq(column_datum_store_table_type)
-													)
-												)
-
-						column_table_datum_store_join = table.create_join(column_datum_store_table, column_table_datum_store_join_on, Arel::Nodes::OuterJoin)
-						self.joins_values += [column_table_datum_store_join]
-
-						joins[joins_scope_key][col_name] = {
-							:join => column_table_datum_store_join,
-							:table => column_datum_store_table
-						}
-
-						joins[joins_scope_key][col_name]
-					end
-
-					# Builds all the joins required for the dynamic columns in the where/order clauses
-					def build_dynamic_column_joins
-						joins = {}
-
-						self.where_dynamic_columns_values.each_with_index { |dynamic_scope, index_outer|
-							dynamic_scope[:where].each_with_index { |rel, index_inner|
-								# Process each where
-								dynamic_column_process_arel_nodes(rel, dynamic_scope[:scope], (index_outer*1000)+(index_inner*10000), joins)
-
-								# Warning
-								# Must cast rel to a string - I've encountered ***strange*** situations where this will change the 'col_name' to value in the where clause
-								# specifically, the test 'case should restrict if scope specified' will fail
-								self.where_values += [rel.to_sql]
-							}
-						}
-						self.order_dynamic_columns_values.each_with_index { |dynamic_scope, index_outer|
-							dynamic_scope[:order].each_with_index { |rel, index_inner|
-								# Process each order
-								dynamic_column_process_arel_nodes(rel, dynamic_scope[:scope], (index_outer*1000)+(index_inner*10000), joins)	
-							}
-						}
-
-						true
 					end
 				end
 			end
 
-			# When arel starts building - filter
-			def build_arel_with_dynamic_columns
-				self.build_dynamic_column_joins
-
-				if self.where_dynamic_columns_values.length > 0 || self.order_dynamic_columns_values.length > 0
-					self.group_values += [Arel::Nodes::Group.new(table[:id])]
-				end
-
-				build_arel_without_dynamic_columns
-			end
-
 			# lifted from
 			# http://erniemiller.org/2013/10/07/activerecord-where-not-sane-true/
 			class WhereChain
@@ -230,44 +80,6 @@ module HasDynamicColumns
 				end
 			end
 
-			# OrderChain objects act as placeholder for queries in which #order does not have any parameter.
-			# In this case, #order must be chained with #by_dynamic_columns to return a new relation.
-			class OrderChain
-				def initialize(scope)
-					@scope = scope
-				end
-
-				def by_dynamic_columns(*args)
-					@scope.send(:preprocess_order_args, args)
-
-					# Add now - want to keep the order with the regular column orders
-					@scope.order_values += args
-
-					# Map
-					dynamic_columns_value = {
-						:scope => nil,
-						:order => args,
-					}
-					@scope.order_dynamic_columns_values = dynamic_columns_value
-
-					chain = ::ActiveRecord::QueryMethods::OrderChain.new(@scope)
-					chain.instance_eval do
-						# Make outer scope variable accessible
-						@dynamic_columns_value = dynamic_columns_value
-
-						# Extends where to chain with a has_scope method
-						# This scopes the where from above
-						def with_scope(opt)
-							@dynamic_columns_value[:scope] = opt
-
-							@scope
-						end
-					end
-
-					chain
-				end
-			end
-
 			def order_with_dynamic_columns(opts = :chain)
 				# Chain - by_dynamic_columns
 				if opts == :chain

data/lib/has_dynamic_columns/active_record/v4/query_methods.rb

@@ -1,161 +1,9 @@
+# ActiveRecord v4 specific changes
+
 module HasDynamicColumns
 	module ActiveRecord
 		module QueryMethods
-			def self.included(base)
-				base.class_eval do
-					alias_method_chain :order, :dynamic_columns
-					alias_method_chain :where, :dynamic_columns
-					alias_method_chain :build_arel, :dynamic_columns
-
-					def dynamic_column_process_arel_nodes(rel, scope, index, joins)
-						case rel
-						when Arel::Nodes::Grouping
-							dynamic_column_process_arel_nodes(rel.expr, scope, index+1, joins)
-						when Arel::Nodes::Or
-							dynamic_column_process_arel_nodes(rel.left, scope, index+1, joins)
-							dynamic_column_process_arel_nodes(rel.right, scope, index+10000, joins) # Hack - queries with over 10,000 dynamic where conditions may break
-						when Arel::Nodes::And
-							dynamic_column_process_arel_nodes(rel.left, scope, index+1, joins)
-							dynamic_column_process_arel_nodes(rel.right, scope, index+10000, joins) # Hack - queries with over 10,000 dynamic where conditions may break
-						# We can work with this
-						when Arel::Nodes::Descending
-							col_name = rel.expr.name
-							dynamic_type = rel.expr.relation.engine
-
-							rel.expr.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table]
-							rel.expr.name = :value
-						# We can work with this
-						when Arel::Nodes::Ascending
-							col_name = rel.expr.name
-							dynamic_type = rel.expr.relation.engine
-
-							rel.expr.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table]
-							rel.expr.name = :value
-						# We can work with this
-						else
-							col_name = rel.left.name
-							dynamic_type = rel.left.relation.engine.to_s
-
-							rel.left.relation = dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index+1, joins)[:table] # modify the where to use the aliased table
-							rel.left.name = :value # value is the data storage column searchable on dynamic_column_data table
-						end
-					end
-
-					# Builds the joins required for this dynamic column
-					# Modifies the where to use the dynamic_column_data table alias
-					#
-					# rel - an arel node
-					# scope - scope to run the conditions in
-					# index - unique table identifier
-					# joins - list of joins processed (to prevent duplicates)
-					def dynamic_column_build_arel_joins(col_name, dynamic_type, scope, index, joins)
-						field_scope = scope
-						field_scope_id = (!field_scope.nil?) ? field_scope.id : nil
-						field_scope_type = (!field_scope.nil?) ? field_scope.class.name.constantize.to_s : nil
-
-						joins_scope_key = "#{field_scope_type}_#{field_scope_id}"
-						joins[joins_scope_key] ||= {}
-
-						column_datum_store_table_type = "HasDynamicColumns::DynamicColumnStringDatum"
-						if !field_scope.nil? && a = field_scope.activerecord_dynamic_columns.where(key: col_name).first
-							column_datum_store_table_type = "HasDynamicColumns::DynamicColumn#{a.data_type.to_s.capitalize}Datum"
-						end
-
-						column_table = HasDynamicColumns::DynamicColumn.arel_table.alias("dynamic_where_#{index}_#{col_name}")
-						column_datum_table = HasDynamicColumns::DynamicColumnDatum.arel_table.alias("dynamic_where_data_#{index}_#{col_name}")
-						column_datum_store_table = column_datum_store_table_type.constantize.arel_table.alias("dynamic_where_data_store_#{index}_#{col_name}")
-
-						# Join for this scope/col already added - continue
-						if !joins[joins_scope_key][col_name].nil?
-							return joins[joins_scope_key][col_name]
-						end
-
-						# Join on the column with the key
-						on_query = column_table[:key].eq(col_name)
-						on_query = on_query.and(
-							column_table[:field_scope_type].eq(field_scope_type)
-						) unless field_scope_type.nil?
-
-						on_query = on_query.and(
-							column_table[:field_scope_id].eq(field_scope_id)
-						) unless field_scope_id.nil?
-
-						column_table_join_on = column_table
-												.create_on(
-													on_query
-												)
-
-						column_table_join = table.create_join(column_table, column_table_join_on)
-						self.joins_values += [column_table_join]
-
-						# Join on all the data with the provided key
-						column_table_datum_join_on = column_datum_table
-												.create_on(
-													column_datum_table[:owner_id].eq(table[:id]).and(
-														column_datum_table[:owner_type].eq(dynamic_type)
-													).and(
-														column_datum_table[:dynamic_column_id].eq(column_table[:id])
-													)
-												)
-
-						column_table_datum_join = table.create_join(column_datum_table, column_table_datum_join_on, Arel::Nodes::OuterJoin)
-						self.joins_values += [column_table_datum_join]
-
-						# Join on the actual data
-						column_table_datum_store_join_on = column_datum_store_table
-												.create_on(
-													column_datum_table[:datum_id].eq(column_datum_store_table[:id]).and(
-														column_datum_table[:datum_type].eq(column_datum_store_table_type)
-													)
-												)
-
-						column_table_datum_store_join = table.create_join(column_datum_store_table, column_table_datum_store_join_on, Arel::Nodes::OuterJoin)
-						self.joins_values += [column_table_datum_store_join]
-
-						joins[joins_scope_key][col_name] = {
-							:join => column_table_datum_store_join,
-							:table => column_datum_store_table
-						}
-
-						joins[joins_scope_key][col_name]
-					end
-
-					# Builds all the joins required for the dynamic columns in the where/order clauses
-					def build_dynamic_column_joins
-						joins = {}
-
-						self.where_dynamic_columns_values.each_with_index { |dynamic_scope, index_outer|
-							dynamic_scope[:where].each_with_index { |rel, index_inner|
-								# Process each where
-								dynamic_column_process_arel_nodes(rel, dynamic_scope[:scope], (index_outer*1000)+(index_inner*10000), joins)
-
-								# Warning
-								# Must cast rel to a string - I've encountered ***strange*** situations where this will change the 'col_name' to value in the where clause
-								# specifically, the test 'case should restrict if scope specified' will fail
-								self.where_values += [rel.to_sql]
-							}
-						}
-						self.order_dynamic_columns_values.each_with_index { |dynamic_scope, index_outer|
-							dynamic_scope[:order].each_with_index { |rel, index_inner|
-								# Process each order
-								dynamic_column_process_arel_nodes(rel, dynamic_scope[:scope], (index_outer*1000)+(index_inner*10000), joins)	
-							}
-						}
-
-						true
-					end
-				end
-			end
-
-			# When arel starts building - filter
-			def build_arel_with_dynamic_columns
-				self.build_dynamic_column_joins
-
-				if self.where_dynamic_columns_values.length > 0 || self.order_dynamic_columns_values.length > 0
-					self.group_values += [Arel::Nodes::Group.new(table[:id])]
-				end
-
-				build_arel_without_dynamic_columns
+			module ClassMethods
 			end
 
 			# lifted from
@@ -206,44 +54,6 @@ module HasDynamicColumns
 				end
 			end
 
-			# OrderChain objects act as placeholder for queries in which #order does not have any parameter.
-			# In this case, #order must be chained with #by_dynamic_columns to return a new relation.
-			class OrderChain
-				def initialize(scope)
-					@scope = scope
-				end
-
-				def by_dynamic_columns(*args)
-					@scope.send(:preprocess_order_args, args)
-
-					# Add now - want to keep the order with the regular column orders
-					@scope.order_values += args
-
-					# Map
-					dynamic_columns_value = {
-						:scope => nil,
-						:order => args,
-					}
-					@scope.order_dynamic_columns_values = dynamic_columns_value
-
-					chain = ::ActiveRecord::QueryMethods::OrderChain.new(@scope)
-					chain.instance_eval do
-						# Make outer scope variable accessible
-						@dynamic_columns_value = dynamic_columns_value
-
-						# Extends where to chain with a has_scope method
-						# This scopes the where from above
-						def with_scope(opt)
-							@dynamic_columns_value[:scope] = opt
-
-							@scope
-						end
-					end
-
-					chain
-				end
-			end
-
 			def order_with_dynamic_columns(opts = :chain)
 				# Chain - by_dynamic_columns
 				if opts == :chain

data/lib/has_dynamic_columns/dynamic_column_model_datum.rb

@@ -0,0 +1,6 @@
+module HasDynamicColumns
+	class DynamicColumnModelDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+		belongs_to :value, :polymorphic => true
+	end
+end

data/lib/has_dynamic_columns/model/class_methods.rb

@@ -229,9 +229,9 @@ module HasDynamicColumns
 
 							@@has_dynamic_columns_configurations.each { |config|
 								if !options[:root].nil?
-									json[options[:root]][config[:as].to_s] = self.send(config[:as].to_s)
+									json[options[:root]][config[:as].to_s] = self.send(config[:as].to_s, true)
 								else
-									json[config[:as].to_s] = self.send(config[:as].to_s)
+									json[config[:as].to_s] = self.send(config[:as].to_s, true)
 								end
 							}
 
@@ -242,28 +242,55 @@ module HasDynamicColumns
 						def #{configuration[:as]}=data
 							data.each_pair { |key, value|
 								# We dont play well with this key
-								if !self.storable_#{configuration[:as].to_s.singularize}_key?(key)
-									raise NoMethodError
-								end
+								raise NoMethodError.new "This key isn't storable" if !self.storable_#{configuration[:as].to_s.singularize}_key?(key)
+
 								dynamic_column = self.#{configuration[:as].to_s.singularize}_key_to_dynamic_column(key)
 
-								# We already have this key in database
-								if existing = self.activerecord_dynamic_column_data.select { |i| i.dynamic_column == dynamic_column }.first
-									existing.value = value
-								else
-									self.activerecord_dynamic_column_data.build(:dynamic_column => dynamic_column, :value => value)
-								end
+								# Expecting array data type
+								raise ArgumentError.new "Multiple columns must be passed arrays" if dynamic_column.multiple && !value.is_a?(Array)
+
+								# Treat everything as an array - makes building easier
+								value = [value] if !value.is_a?(Array)
+
+								# Loop each value - sets existing data or builds a new data node
+								existing = self.activerecord_dynamic_column_data.select { |i| i.dynamic_column == dynamic_column }
+								value.each_with_index { |datum, datum_index|
+									if existing[datum_index]
+										# Undelete this node if its now needed
+										existing[datum_index].reload if existing[datum_index].marked_for_destruction?
+										existing[datum_index].value = datum
+									# No existing placeholder - build a new one
+									else
+										self.activerecord_dynamic_column_data.build(:dynamic_column => dynamic_column, :value => datum)
+									end
+								}
+
+								# Any record no longer needed should be marked for destruction
+								existing.each_with_index { |i,index|
+									if index > value.length
+										i.mark_for_destruction
+									end
+								}
 							}
 						end
 
-						def #{configuration[:as]}
+						def #{configuration[:as]}(as_json = false)
 							h = {}
 							self.field_scope_#{configuration[:as]}.each { |i|
-								h[i.key] = nil
+								h[i.key] = (i.multiple)? [] : nil
 							}
 
 							self.activerecord_dynamic_column_data.each { |i|
-								h[i.dynamic_column.key] = i.value unless !i.dynamic_column || !h.has_key?(i.dynamic_column.key)
+								if i.dynamic_column && h.has_key?(i.dynamic_column.key)
+									v = i.value
+									v = v.as_json(:root => nil) if as_json && v.respond_to?(:as_json)
+
+									if i.dynamic_column.multiple
+										h[i.dynamic_column.key] << v
+									else
+										h[i.dynamic_column.key] = v
+									end
+								end
 							}
 
 							h
@@ -274,25 +301,33 @@ module HasDynamicColumns
 						end
 
 						def field_scope_#{configuration[:as]}
+							obj = self.get_#{configuration[:as]}_field_scope
+
 							# has_many relationship
-							if self.get_#{configuration[:as]}_field_scope.respond_to?(:select) && self.get_#{configuration[:as]}_field_scope.respond_to?(:collect)
-								self.get_#{configuration[:as]}_field_scope.collect { |i|
-									i.send("activerecord_dynamic_columns")
+							if obj.respond_to?(:select) && obj.respond_to?(:collect)
+								obj.collect { |i|
+									i.send("activerecord_dynamic_columns") if i.respond_to?(:activerecord_dynamic_columns)
 								}.flatten.select { |i|
 									i.dynamic_type.to_s.empty? || i.dynamic_type.to_s == self.class.to_s
 								}
 							# belongs_to relationship
-							else
-								self.get_#{configuration[:as]}_field_scope.send("activerecord_dynamic_columns").select { |i|
+							elsif obj.respond_to?(:activerecord_dynamic_columns)
+								obj.send("activerecord_dynamic_columns").select { |i|
 									# Only get things with no dynamic type defined or dynamic types defined as this class
 									i.dynamic_type.to_s.empty? || i.dynamic_type.to_s == self.class.to_s
 								}
+							else
+								[]
 							end
 						end
 
 					protected
 						def get_#{configuration[:as]}_field_scope
+							# Sometimes association doesnt exist
+							begin
 							#{configuration[:field_scope]}
+							rescue
+							end
 						end
 
 						# Whether this is storable

data/lib/has_dynamic_columns/version.rb

@@ -1,3 +1,3 @@
 module HasDynamicColumns
-  VERSION = "0.3.3"
+  VERSION = "0.3.5"
 end

data/lib/has_dynamic_columns.rb

@@ -22,6 +22,7 @@ require "has_dynamic_columns/dynamic_column_string_datum"
 require "has_dynamic_columns/dynamic_column_text_datum"
 require "has_dynamic_columns/dynamic_column_time_datum"
 require "has_dynamic_columns/dynamic_column_timestamp_datum"
+require "has_dynamic_columns/dynamic_column_model_datum"
 
 module HasDynamicColumns
 end

data/spec/factories/account.rb

@@ -12,6 +12,9 @@ FactoryGirl.define do
 			account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "trusted", :data_type => "boolean")
 			account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "last_contacted", :data_type => "datetime")
 			account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "total_purchases", :data_type => "integer")
+			account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "tags", :data_type => "string", :multiple => true)
+			account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "address", :data_type => "model", :class_name => "CustomerAddress", :column_name => "name")
+			account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "products", :data_type => "model", :multiple => true)
 		end
 	end
 

data/spec/factories/customer.rb

@@ -22,9 +22,13 @@ FactoryGirl.define do
 					DateTime.now.change(hour: evaluator.index)
 				when 'boolean'
 					true
+				when 'model'
+					nil
 				else
 					"#{evaluator.index } - #{i.data_type}"
 				end
+
+				hash[i.key.to_s] = [hash[i.key.to_s]]if i.multiple
 			}
 			customer.fields = hash
 

data/spec/has_dynamic_columns/active_record/query_methods_spec.rb

@@ -44,14 +44,63 @@ describe ::HasDynamicColumns::ActiveRecord::QueryMethods do
 	end
 
 	context 'Customer' do
-		it 'should order by first_name' do
+		it 'should store, retrieve, and search array data' do
 			table = Customer.arel_table
 
+			customer = Customer.new(:account => account, :name => "1")
+			customer.fields = {
+				"first_name" => "Butch",
+				"last_name" => "Marshall",
+				"email" => "butch.marshall@unittest.com",
+				"trusted" => false,
+				"last_contacted" => DateTime.parse("2012-01-01 01:01:01"),
+				"total_purchases" => 10,
+				"tags" => [
+					"a", "b", "c"
+				]
+			}
+			customer.save
+
+			customer = Customer.new(:account => account, :name => "1")
+			customer.fields = {
+				"first_name" => "Merridyth",
+				"last_name" => "Marshall",
+				"email" => "merridyth.marshall@unittest.com",
+				"trusted" => false,
+				"last_contacted" => DateTime.parse("2014-05-01 01:01:01"),
+				"total_purchases" => 10,
+				"tags" => [
+					"c", "d", "e"
+				]
+			}
+			customer.save
+
+			result = Customer.where
+					.has_dynamic_columns(table[:tags].eq("e"))
+					.with_scope(account)
+			expect(result.length).to eq(1)
+
+			result = Customer.where
+					.has_dynamic_columns(table[:tags].eq("c"))
+					.with_scope(account)
+			expect(result.length).to eq(2)
+
+			result = Customer.where
+					.has_dynamic_columns(
+						table[:tags].eq("c").and(
+							table[:first_name].eq("Butch")
+						)
+					)
+					.with_scope(account)
+			expect(result.length).to eq(1)
+		end
+
+		it 'should order by first_name' do
 			result = Customer
 				.order
 					.by_dynamic_columns(first_name: :desc)
 					.with_scope(account)
-				.collect { |i|
+			.collect { |i|
 				json = i.as_json(:root => nil)
 				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
 			}
@@ -96,7 +145,7 @@ describe ::HasDynamicColumns::ActiveRecord::QueryMethods do
 			expect(result).to eq([["2", "Butch", "Marshall"], ["1", "Butch", "Casidy"], ["1", "George", "Marshall"]])
 		end
 
-		it 'should order by dynamic and regular columns', :focus => true do
+		it 'should order by dynamic and regular columns' do
 			table = Customer.arel_table
 
 			result = Customer
@@ -253,7 +302,7 @@ describe ::HasDynamicColumns::ActiveRecord::QueryMethods do
 
 	context 'ActiveRecord' do
 		it 'should not clobber where IN queries' do
-			sql = Account.where("id IN (?)", [1,2,3]).to_sql
+			sql = Account.where("id IN (?)", [1,2,3]).to_sql.gsub(/\s\s/,' ')
 			expect(sql).to eq('SELECT "accounts".* FROM "accounts" WHERE (id IN (1,2,3))')
 		end
 	end

data/spec/has_dynamic_columns/dynamic_columns_integer_datum_spec.rb

@@ -16,7 +16,7 @@ describe HasDynamicColumns::DynamicColumnIntegerDatum do
 			}
 			customer.save
 			json = customer.as_json(:root => nil)
-			expect(json["fields"]).to eq({"first_name"=>"Butch", "last_name"=>"Marshall", "email"=>nil, "trusted"=>true, "last_contacted"=>nil, "total_purchases"=>123654})
+			expect(json["fields"]).to eq({"first_name"=>"Butch", "last_name"=>"Marshall", "email"=>nil, "trusted"=>true, "last_contacted"=>nil, "total_purchases"=>123654, "tags" => [], "address"=>nil, "products"=>[]})
 		end
 
 		context 'where.has_dynamic_columns' do

data/spec/has_dynamic_columns/dynamic_columns_model_datum_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe HasDynamicColumns::DynamicColumnModelDatum do
+	let (:account) do
+		FactoryGirl.create(:account_with_customer_dynamic_columns)
+	end
+
+	context 'Customer' do
+		it 'should output json as polymoprhic' do
+			customer = Customer.new(:account => account)
+			customer.fields = {
+				"first_name" => "Butch",
+				"last_name" => "Marshall",
+				"total_purchases" => 123654,
+				"trusted" => true,
+				"address" => CustomerAddress.new(:name => "1796 18th St, San Francisco, CA 94107, United States"),
+				"products" => [
+					Product.new(:name => "P1"),
+					Product.new(:name => "P2"),
+					Product.new(:name => "P3"),
+					Product.new(:name => "P4"),
+					Product.new(:name => "P5"),
+				]
+			}
+			customer.save
+			json = customer.as_json(:root => nil)
+
+			expect(json["fields"]["address"]["name"]).to eq("1796 18th St, San Francisco, CA 94107, United States")
+			expect(json["fields"]["products"].length).to eq(5)
+			# Each of the products should be json
+			json["fields"]["products"].each_with_index { |i, index|
+				expect(i["name"]).to eq("P#{index+1}")
+			}
+		end
+
+		it 'should be searchable', :focus => true do
+			table = Customer.arel_table
+
+			customer = Customer.new(:account => account)
+			customer.fields = {
+				"first_name" => "Linus",
+				"last_name" => "Rorvalds",
+				"total_purchases" => 123654,
+				"trusted" => true,
+				"address" => CustomerAddress.new(:name => "1796 18th St, San Francisco, CA 94107, United States")
+			}
+			customer.save
+
+			customer = Customer.new(:account => account)
+			customer.fields = {
+				"first_name" => "Bill",
+				"last_name" => "Gates",
+				"total_purchases" => 123654,
+				"trusted" => true,
+				"address" => CustomerAddress.new(:name => "15010 NE 36th Street, Redmond, WA 98052, United States")
+			}
+			customer.save
+
+			customer = Customer.new(:account => account)
+			customer.fields = {
+				"first_name" => "Mark",
+				"last_name" => "Zuceberg",
+				"total_purchases" => 123654,
+				"trusted" => true,
+				"address" => CustomerAddress.new(:name => "1 Hacker Way, Menlo Park, CA 94025, United States")
+			}
+			customer.save
+
+			customer = Customer.new(:account => account)
+			customer.fields = {
+				"first_name" => "Larry",
+				"last_name" => "Page",
+				"total_purchases" => 123654,
+				"trusted" => true,
+				"address" => CustomerAddress.new(:name => "1600 Amphitheatre Pkwy, Mountain View, CA 94043, United States")
+			}
+			customer.save
+
+			result = Customer
+				.where
+					.has_dynamic_columns(table[:address].matches("%United States%"))
+					.with_scope(account)
+			expect(result.length).to eq(4)
+
+			result = Customer
+				.where
+					.has_dynamic_columns(table[:address].matches("% CA %"))
+					.with_scope(account)
+			expect(result.length).to eq(3)
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:address].matches("% Hacker %").or(
+							table[:address].matches("1600 %")
+						)
+					)
+					.with_scope(account)
+			expect(result.length).to eq(2)
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:address].matches("% Hacker %").or(
+							table[:first_name].eq("Larry")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(
+						last_name: :asc
+					)
+					.with_scope(account)
+			expect(result.length).to eq(2)
+			expect(result.first.as_json["fields"]["address"]["name"]).to eq("1600 Amphitheatre Pkwy, Mountain View, CA 94043, United States")
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -23,15 +23,23 @@ end
 # Add this directory so the ActiveSupport autoloading works
 ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
 
-# Used to test interactions between DJ and an ORM
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+if RUBY_PLATFORM == 'java'
+	ActiveRecord::Base.establish_connection :adapter => 'jdbcsqlite3', :database => ':memory:'
+else
+	ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+end
+
 ActiveRecord::Migration.verbose = false
 
 require "generators/has_dynamic_columns/templates/migration"
 require "generators/has_dynamic_columns/templates/migration_0.3.0"
+require "generators/has_dynamic_columns/templates/migration_0.3.4"
+require "generators/has_dynamic_columns/templates/migration_0.3.5"
 ActiveRecord::Schema.define do
 	AddHasDynamicColumns.up
 	Upgrade030HasDynamicColumns.up
+	Upgrade034HasDynamicColumns.up
+	Upgrade035HasDynamicColumns.up
 
 	create_table :accounts, force: true do |t|
 		t.string :name

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_dynamic_columns
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - Butch Marshall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-01 00:00:00.000000000 Z
+date: 2015-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -97,6 +97,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -109,7 +110,11 @@ files:
 - lib/generators/has_dynamic_columns/next_migration_version.rb
 - lib/generators/has_dynamic_columns/templates/migration.rb
 - lib/generators/has_dynamic_columns/templates/migration_0.3.0.rb
+- lib/generators/has_dynamic_columns/templates/migration_0.3.4.rb
+- lib/generators/has_dynamic_columns/templates/migration_0.3.5.rb
 - lib/generators/has_dynamic_columns/upgrade_0_3_0_active_record_generator.rb
+- lib/generators/has_dynamic_columns/upgrade_0_3_4_active_record_generator.rb
+- lib/generators/has_dynamic_columns/upgrade_0_3_5_active_record_generator.rb
 - lib/has_dynamic_columns.rb
 - lib/has_dynamic_columns/active_record.rb
 - lib/has_dynamic_columns/active_record/query_methods.rb
@@ -128,6 +133,7 @@ files:
 - lib/has_dynamic_columns/dynamic_column_enum_datum.rb
 - lib/has_dynamic_columns/dynamic_column_float_datum.rb
 - lib/has_dynamic_columns/dynamic_column_integer_datum.rb
+- lib/has_dynamic_columns/dynamic_column_model_datum.rb
 - lib/has_dynamic_columns/dynamic_column_option.rb
 - lib/has_dynamic_columns/dynamic_column_string_datum.rb
 - lib/has_dynamic_columns/dynamic_column_text_datum.rb
@@ -143,6 +149,7 @@ files:
 - spec/factories/customer.rb
 - spec/has_dynamic_columns/active_record/query_methods_spec.rb
 - spec/has_dynamic_columns/dynamic_columns_integer_datum_spec.rb
+- spec/has_dynamic_columns/dynamic_columns_model_datum_spec.rb
 - spec/has_dynamic_columns/dynamic_columns_string_datum_spec.rb
 - spec/has_dynamic_columns_spec.rb
 - spec/spec_helper.rb
@@ -175,6 +182,7 @@ test_files:
 - spec/factories/customer.rb
 - spec/has_dynamic_columns/active_record/query_methods_spec.rb
 - spec/has_dynamic_columns/dynamic_columns_integer_datum_spec.rb
+- spec/has_dynamic_columns/dynamic_columns_model_datum_spec.rb
 - spec/has_dynamic_columns/dynamic_columns_string_datum_spec.rb
 - spec/has_dynamic_columns_spec.rb
 - spec/spec_helper.rb