has_dynamic_columns 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e48635b860c7cac4c800461dab2a70ee3abc71a
+  data.tar.gz: a8bcdec82cd09f2c0d6e78b3b79c5c75c2954c14
+SHA512:
+  metadata.gz: a97dd9c49f2551362311091c7e66137e7baf7fd21d6f2c0fd24fa894c39ce34f32f0cffa98bc616ddb9305bd227b1b61661ac29d46e0da50544cbb3c6199490d
+  data.tar.gz: fda55ebb312d5a7ce6b65494c6fe70999245a48e639a26e046b14b899869eb749434f4932e07f1a1898fa1dc4829ae6c88bcbb56b3a7c81c4cf53df2b604e011

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+# .rspec
+--format documentation --color --fail-fast

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+
+group :test do
+	if ENV['RAILS_VERSION'] == 'edge'
+		gem 'activerecord', :github => 'rails/rails'
+	else
+		gem 'activerecord', (ENV['RAILS_VERSION'] || ['>= 3.0', '< 5.0'])
+	end
+	
+	gem 'coveralls', :require => false
+	gem 'rspec', '>= 3'
+	gem 'rubocop', '>= 0.25'
+end
+
+# Specify your gem's dependencies in has_dynamic_columns.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Butch Marshall
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+has_dynamic_columns
+============
+
+Add dynamic columns to ActiveRecord models
+
+Installation
+============
+
+```ruby
+gem 'has_dynamic_columns', :git => 'git://github.com/butchmarshall/has_dynamic_columns.git'
+```
+
+The Active Record migration is required to create the has_dynamic_columns table. You can create that table by
+running the following command:
+
+    rails generate has_dynamic_columns:active_record
+    rake db:migrate
+
+Usage
+============
+
+```ruby
+class Account < ActiveRecord::Base
+	has_many :customers
+	has_dynamic_columns
+end
+
+class Customer < ActiveRecord::Base
+	belongs_to :account
+	has_many :customer_addresses
+	has_dynamic_columns field_scope: "account", as: "fields"
+end
+
+class CustomerAddress < ActiveRecord::Base
+	belongs_to :customer
+	has_dynamic_columns field_scope: "customer.account"
+end
+```
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "rspec/core/rake_task"
+require "bundler/gem_tasks"
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+	task.rspec_opts = ['--color', '--format', 'nested']
+end
+
+task :default => :spec

data/has_dynamic_columns.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'has_dynamic_columns/version'
+
+Gem::Specification.new do |spec|
+	spec.name          = "has_dynamic_columns"
+	spec.version       = HasDynamicColumns::VERSION
+	spec.authors       = ["Butch Marshall"]
+	spec.email         = ["butch.a.marshall@gmail.com"]
+	spec.summary       = "Dynamic fields for activerecord models"
+	spec.description   = "Adds ability to put dynamic fields into active record models"
+	spec.homepage      = "https://github.com/butchmarshall/has_dynamic_columns"
+	spec.license       = "MIT"
+
+	spec.files         = `git ls-files -z`.split("\x0")
+	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+	spec.require_paths = ["lib"]
+
+	spec.add_dependency "activerecord", [">= 3.0", "< 5.0"]
+
+	spec.add_development_dependency "bundler", "~> 1.7"
+	spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/generators/has_dynamic_columns/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 ActiveRecordGenerator < ::HasDynamicColumnsGenerator
+		include Rails::Generators::Migration
+		extend NextMigrationVersion
+
+		source_paths << File.join(File.dirname(__FILE__), "templates")
+
+		def create_migration_file
+			migration_template "migration.rb", "db/migrate/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/has_dynamic_columns_generator.rb

@@ -0,0 +1,6 @@
+require 'rails/generators/base'
+require 'has_dynamic_columns/compatibility'
+
+class HasDynamicColumnsGenerator < Rails::Generators::Base
+  source_paths << File.join(File.dirname(__FILE__), 'templates')
+end

data/lib/generators/has_dynamic_columns/next_migration_version.rb

@@ -0,0 +1,14 @@
+module HasDynamicColumns
+	module NextMigrationVersion
+		# while methods have moved around this has been the implementation
+		# since ActiveRecord 3.0
+		def next_migration_number(dirname)
+			next_migration_number = current_migration_number(dirname) + 1
+			if ActiveRecord::Base.timestamped_migrations
+				[Time.now.utc.strftime("%Y%m%d%H%M%S"), format("%.14d", next_migration_number)].max
+			else
+				format("%.3d", next_migration_number)
+			end
+		end
+	end
+end

data/lib/generators/has_dynamic_columns/templates/migration.rb

@@ -0,0 +1,43 @@
+class CreateHasDynamicColumns < ActiveRecord::Migration
+	def self.up
+		create_table :dynamic_columns do |t|
+			t.integer :field_scope_id
+			t.string :field_scope_type
+
+			t.string :dynamic_type
+			t.string :key
+			t.string :data_type
+
+			t.timestamps
+		end
+		add_index(:dynamic_columns, [:field_scope_id, :field_scope_type, :dynamic_type], name: 'index1')
+		create_table :dynamic_column_validations do |t|
+			t.integer :dynamic_column_id
+
+			t.string :error
+			t.string :regexp
+
+			t.timestamps
+		end
+		create_table :dynamic_column_options do |t|
+			t.integer :dynamic_column_id
+			t.string :key
+
+			t.timestamps
+		end
+		create_table :dynamic_column_data do |t|
+			t.string :owner_type
+			t.integer :owner_id
+			t.integer :dynamic_column_id
+			t.integer :dynamic_column_option_id
+			t.string :value
+
+			t.timestamps
+		end
+		add_index(:dynamic_column_data, [:owner_id, :owner_type, :dynamic_column_id], name: 'index2')
+	end
+
+	def self.down
+		drop_table :dynamic_columns
+	end
+end

data/lib/has_dynamic_columns/compatibility.rb

@@ -0,0 +1,27 @@
+require 'active_support/version'
+
+module HasDynamicColumns
+	module Compatibility
+		if ActiveSupport::VERSION::MAJOR >= 4
+			require 'active_support/proxy_object'
+
+			def self.executable_prefix
+				'bin'
+			end
+
+			def self.proxy_object_class
+				ActiveSupport::ProxyObject
+			end
+		else
+			require 'active_support/basic_object'
+
+			def self.executable_prefix
+				'script'
+			end
+
+			def self.proxy_object_class
+				ActiveSupport::BasicObject
+			end
+		end
+	end
+end

data/lib/has_dynamic_columns/dynamic_column.rb

@@ -0,0 +1,6 @@
+module HasDynamicColumns
+	class DynamicColumn < ActiveRecord::Base
+		has_many :dynamic_column_options, :class_name => "HasDynamicColumns::DynamicColumnOption"
+		has_many :dynamic_column_validations, :class_name => "HasDynamicColumns::DynamicColumnValidation"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_datum.rb

@@ -0,0 +1,60 @@
+module HasDynamicColumns
+	class DynamicColumnDatum < ActiveRecord::Base
+		belongs_to :dynamic_column, :class_name => "HasDynamicColumns::DynamicColumn"
+		belongs_to :dynamic_column_option, :class_name => "HasDynamicColumns::DynamicColumnOption"
+		belongs_to :owner, :polymorphic => true
+
+		# Get value based on dynamic_column data_type
+		def value
+			if self.dynamic_column
+				case self.dynamic_column.data_type
+					when "list"
+						if self.dynamic_column_option
+							self.dynamic_column_option.key
+						end
+					when "datetime"
+						self[:value]
+					when "boolean"
+						(self[:value] == 1)
+					when "integer"
+						self[:value]
+					when "date"
+						self[:value]
+					when "string"
+						self[:value]
+				end
+			else
+				self[:value]
+			end
+		end
+
+		# Set value base don dynamic_column data_type
+		def value=v
+			if self.dynamic_column
+				case self.dynamic_column.data_type
+					when "list"
+						# Can only set the value to one of the option values
+						if option = self.dynamic_column.dynamic_column_options.select { |i| i.key == v }.first
+							self.dynamic_column_option = option
+						else
+							# Hacky, -1 indicates to the validator that an invalid option was set
+							self.dynamic_column_option = nil
+							self.dynamic_column_option_id = (v.to_s.length > 0)? -1 : nil
+						end
+					when "datetime"
+						self[:value] = v
+					when "boolean"
+						self[:value] = v
+					when "integer"
+						self[:value] = v
+					when "date"
+						self[:value] = v
+					when "string"
+						self[:value] = v
+				end
+			else
+				self[:value] = v
+			end
+		end
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_option.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnOption < ActiveRecord::Base
+		belongs_to :dynamic_column, :class_name => "HasDynamicColumns::DynamicColumn"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_validation.rb

@@ -0,0 +1,11 @@
+module HasDynamicColumns
+	class DynamicColumnValidation < ActiveRecord::Base
+		belongs_to :dynamic_column, :class_name => "HasDynamicColumns::DynamicColumn"
+
+		def is_valid?(str)
+			matches = Regexp.new(self["regexp"]).match(str.to_s)
+
+			return !matches.nil?
+		end
+	end
+end

data/lib/has_dynamic_columns/version.rb

@@ -0,0 +1,3 @@
+module HasDynamicColumns
+  VERSION = "0.0.1"
+end

data/lib/has_dynamic_columns.rb

@@ -0,0 +1,280 @@
+require "active_support"
+
+require "has_dynamic_columns/version"
+require "has_dynamic_columns/dynamic_column"
+require "has_dynamic_columns/dynamic_column_option"
+require "has_dynamic_columns/dynamic_column_validation"
+require "has_dynamic_columns/dynamic_column_datum"
+
+module HasDynamicColumns
+	module Model
+		def self.included(base)
+			base.send :extend, ClassMethods
+		end
+
+		module ClassMethods
+			def has_dynamic_columns(*args)
+				options = args.extract_options!
+				configuration = {
+					:as => "dynamic_columns",
+					:field_scope => nil,
+				}
+		        configuration.update(options) if options.is_a?(Hash)
+
+				class_eval <<-EOV
+					include ::HasDynamicColumns::Model::InstanceMethods
+
+					has_many :activerecord_#{configuration[:as]},
+								class_name: "HasDynamicColumns::DynamicColumn",
+								as: :field_scope
+					has_many :activerecord_#{configuration[:as]}_data,
+								class_name: "HasDynamicColumns::DynamicColumnDatum",
+								as: :owner
+
+					# only add to attr_accessible
+					# if the class has some mass_assignment_protection
+					if defined?(accessible_attributes) and !accessible_attributes.blank?
+						#attr_accessible :#{configuration[:column]}
+					end
+
+					validate :validate_dynamic_column_data
+
+					public
+						# Order by dynamic columns
+						def self.dynamic_order(field_scope, key, direction = :asc)
+							table = self.name.constantize.arel_table
+							column_table = HasDynamicColumns::DynamicColumn.arel_table.alias("dynamic_order_"+key.to_s)
+							column_datum_table = HasDynamicColumns::DynamicColumnDatum.arel_table.alias("dynamic_order_data_"+key.to_s)
+
+							field_scope_type = field_scope.class.name.constantize.to_s
+							dynamic_type = self.name.constantize.to_s
+							field_scope_id = field_scope.id
+
+							# Join on the column with the key
+							column_table_join_on = column_table
+													.create_on(
+														column_table[:field_scope_type].eq(field_scope_type).and(
+															column_table[:dynamic_type].eq(dynamic_type)
+														).and(
+															column_table[:field_scope_id].eq(field_scope_id)
+														).and(
+															column_table[:key].eq(key)
+														)
+													)
+
+							column_table_join = table.create_join(column_table, column_table_join_on)
+							query = joins(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)
+							query = query.joins(column_table_datum_join)
+
+							# Order
+							query = query.order(column_datum_table[:value].send(direction))
+
+							# Group required - we have many rows
+							query = query.group(table[:id])
+
+							query
+						end
+
+						# Find by dynamic columns
+						def self.dynamic_where(*args)
+							field_scope = args[0]
+							options = args.extract_options!
+
+							field_scope_type = field_scope.class.name.constantize.to_s
+							dynamic_type = self.name.constantize.to_s
+							field_scope_id = field_scope.id
+
+							table = self.name.constantize.arel_table
+							query = nil
+
+							# Need to join on each of the keys we are performing where on
+							options.each { |key, value|
+								column_table = HasDynamicColumns::DynamicColumn.arel_table.alias("dynamic_where_"+key.to_s)
+								column_datum_table = HasDynamicColumns::DynamicColumnDatum.arel_table.alias("dynamic_where_data_"+key.to_s)
+
+								# Join on the column with the key
+								column_table_join_on = column_table
+														.create_on(
+															column_table[:field_scope_type].eq(field_scope_type).and(
+																column_table[:dynamic_type].eq(dynamic_type)
+															).and(
+																column_table[:field_scope_id].eq(field_scope_id)
+															).and(
+																column_table[:key].eq(key)
+															)
+														)
+
+								column_table_join = table.create_join(column_table, column_table_join_on)
+								query = (query.nil?)? joins(column_table_join) : query.join(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])
+															).and(
+																column_datum_table[:value].matches("%"+value+"%")
+															)
+														)
+
+								column_table_datum_join = table.create_join(column_datum_table, column_table_datum_join_on)
+								query = query.joins(column_table_datum_join)
+							}
+							# Group required - we have many rows
+							query = (query.nil?)? group(table[:id]) : query.group(table[:id])
+
+							query
+						end
+
+						def as_json(*args)
+							json = super(*args)
+							options = args.extract_options!
+
+							if !options[:root].nil?
+								json[options[:root]][self.dynamic_columns_as] = self.send(self.dynamic_columns_as)
+							else
+								json[self.dynamic_columns_as] = self.send(self.dynamic_columns_as)
+							end
+
+							json
+						end
+
+						# Setter for dynamic field data
+						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
+								dynamic_column = self.#{configuration[:as].to_s.singularize}_key_to_dynamic_column(key)
+
+								# We already have this key in database
+								if existing = self.activerecord_#{configuration[:as]}_data.select { |i| i.dynamic_column == dynamic_column }.first
+									existing.value = value
+								else
+									self.activerecord_#{configuration[:as]}_data.build(:dynamic_column => dynamic_column, :value => value)
+								end
+							}
+						end
+
+						def #{configuration[:as]}
+							h = {}
+							self.field_scope_#{configuration[:as]}.each { |i|
+								h[i.key] = nil
+							}
+							self.activerecord_#{configuration[:as]}_data.each { |i|
+								h[i.dynamic_column.key] = i.value unless !i.dynamic_column
+							}
+							h
+						end
+
+						def #{configuration[:as].to_s.singularize}_keys
+							self.field_scope_#{configuration[:as]}.collect { |i| i.key }
+						end
+
+						def field_scope_#{configuration[:as]}
+							self.field_scope.send("activerecord_"+self.field_scope.dynamic_columns_as).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
+							}
+						end
+
+						def dynamic_columns_as
+							"#{configuration[:as].to_s}"
+						end
+
+					protected
+						# Whether this is storable
+						def storable_#{configuration[:as].to_s.singularize}_key?(key)
+							self.#{configuration[:as].to_s.singularize}_keys.include?(key.to_s)
+						end
+
+						# Figures out which dynamic_column has which key
+						def #{configuration[:as].to_s.singularize}_key_to_dynamic_column(key)
+							found = nil
+							if record = self.send("field_scope_"+self.dynamic_columns_as).select { |i| i.key == key.to_s }.first
+								found = record
+							end
+							found
+						end
+
+						def field_scope
+							#{configuration[:field_scope]}
+						end
+				EOV
+			end
+		end
+
+		module InstanceMethods
+			# Validate all the dynamic_column_data at once
+			def validate_dynamic_column_data
+				field_scope = self.field_scope
+
+				if field_scope
+					# All the fields defined on the parent model
+					dynamic_columns = field_scope.send("activerecord_#{field_scope.dynamic_columns_as}")
+
+					self.send("activerecord_#{self.dynamic_columns_as}_data").each { |dynamic_column_datum|
+						# Collect all validation errors
+						validation_errors = []
+
+						if dynamic_column_datum.dynamic_column_option_id == -1
+							validation_errors << "invalid_option"
+						end
+
+						# Find the dynamic_column defined for this datum
+						dynamic_column = nil
+						dynamic_columns.each { |i|
+							if i == dynamic_column_datum.dynamic_column
+								dynamic_column = i
+								break
+							end
+						}
+						# We have a dynamic_column - validate
+						if dynamic_column
+							dynamic_column.dynamic_column_validations.each { |validation|
+								if !validation.is_valid?(dynamic_column_datum.value.to_s)
+									validation_errors << validation.error
+								end
+							}
+						else
+							# No field found - this is probably bad - should we throw an error?
+							validation_errors << "not_found"
+						end
+
+						# If any errors exist - add them
+						if validation_errors.length > 0
+							errors.add(:dynamic_columns, { "#{dynamic_column.key}" => validation_errors })
+						end
+					}
+				end
+			end
+		end
+	end
+end
+
+if defined?(Rails::Railtie)
+	class Railtie < Rails::Railtie
+		initializer 'has_dynamic_columns.insert_into_active_record' do
+			ActiveSupport.on_load :active_record do
+				ActiveRecord::Base.send(:include, HasDynamicColumns::Model)
+			end
+		end
+	end
+else
+	ActiveRecord::Base.send(:include, HasDynamicColumns::Model) if defined?(ActiveRecord)
+end

data/spec/has_dynamic_columns_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe HasDynamicColumns do
+	let (:account) do
+		account = Account.new(:name => "Account #1")
+
+		# Setup dynamic fields for Customer under this account
+		account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "first_name", :data_type => "string")
+		account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "last_name", :data_type => "string")
+		account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "email", :data_type => "string")
+
+		# Setup dynamic fields for CustomerAddress under this account
+		account.activerecord_dynamic_columns.build(:dynamic_type => "CustomerAddress", :key => "address_1", :data_type => "string")
+		account.activerecord_dynamic_columns.build(:dynamic_type => "CustomerAddress", :key => "address_2", :data_type => "string")
+
+		field = account.activerecord_dynamic_columns.build(:dynamic_type => "CustomerAddress", :key => "country", :data_type => "list")
+		field.dynamic_column_options.build(:key => "canada")
+		field.dynamic_column_options.build(:key => "usa")
+		field.dynamic_column_options.build(:key => "mexico")
+
+		field = account.activerecord_dynamic_columns.build(:dynamic_type => "CustomerAddress", :key => "city", :data_type => "list")
+		field.dynamic_column_options.build(:key => "toronto")
+		field.dynamic_column_options.build(:key => "alberta")
+		field.dynamic_column_options.build(:key => "vancouver")
+
+		field = account.activerecord_dynamic_columns.build(:dynamic_type => "CustomerAddress", :key => "province", :data_type => "list")
+		field.dynamic_column_options.build(:key => "ontario")
+		field.dynamic_column_options.build(:key => "quebec")
+
+		field = account.activerecord_dynamic_columns.build(:dynamic_type => "CustomerAddress", :key => "postal_code", :data_type => "string")
+		field.dynamic_column_validations.build(:regexp => "^[^$]+$", :error => "blank")
+		field.dynamic_column_validations.build(:regexp => "^[ABCEGHJKLMNPRSTVXY]\\d[ABCEGHJKLMNPRSTVWXYZ]( )?\\d[ABCEGHJKLMNPRSTVWXYZ]\\d$", :error => "invalid_format")
+
+		account
+	end
+
+	describe Customer do
+		subject(:customer) { Customer.new(:account => account) }
+		before do
+			customer.fields = {
+				"first_name" => "Butch",
+				"last_name" => "Marshall",
+				"email" => "butch.a.marshall@gmail.com",
+			}
+		end
+
+		context 'when it is valid' do
+			it 'should not find john' do
+				c = customer
+				c.save
+				a = c.account
+
+				expect(a.customers.dynamic_where(a, { first_name: "John" }).length).to eq(0)
+			end
+			it 'should find me' do
+				c = customer
+				c.save
+				a = c.account
+
+				expect(a.customers.dynamic_where(a, { first_name: "Butch" }).length).to eq(1)
+			end
+			it 'should return fields as json' do
+				json = customer.as_json(:root => "customer")
+
+				expect(json["customer"]["fields"]).to eq({
+					"first_name" => "Butch",
+					"last_name" => "Marshall",
+					"email" => "butch.a.marshall@gmail.com",
+				})
+			end
+		end
+
+		describe CustomerAddress do
+			subject(:customer_address) { CustomerAddress.new(:customer => customer) }
+
+			context 'when it has partial data' do
+				before do
+					customer_address.fields = {
+						"country" => "canada",
+						"province" => "ontario",
+						"city" => "toronto",
+						"postal_code" => "H0H0H0",
+					}
+				end
+
+				it 'should return nil for unset fields' do
+					json = customer_address.as_json(:root => "customer_address")
+					
+					expect(json["customer_address"]["fields"]).to eq({
+						"address_1" => nil,
+						"address_2" => nil,
+						"country" => "canada",
+						"province" => "ontario",
+						"city" => "toronto",
+						"postal_code" => "H0H0H0",
+					})
+				end
+			end
+
+			context 'when it is valid' do
+				before do
+					customer_address.fields = {
+						"address_1" => "555 Bloor Street",
+						"country" => "canada",
+						"province" => "ontario",
+						"city" => "toronto",
+						"postal_code" => "H0H0H0",
+					}
+				end
+
+				it 'should return parent customer fields as json' do
+					json = customer_address.customer.as_json(:root => "customer")
+					
+					expect(json["customer"]["fields"]).to eq({
+						"first_name" => "Butch",
+						"last_name" => "Marshall",
+						"email" => "butch.a.marshall@gmail.com",
+					})
+				end
+
+				it 'should return fields as json' do
+					json = customer_address.as_json(:root => "customer_address")
+					expect(json["customer_address"]["fields"]).to eq({
+						"address_1" => "555 Bloor Street",
+						"address_2" => nil,
+						"country" => "canada",
+						"province" => "ontario",
+						"city" => "toronto",
+						"postal_code" => "H0H0H0",
+					})
+				end
+
+				it 'should validate' do
+					expect(customer_address).to be_valid
+				end
+
+				it 'should save successfully' do
+					sub = customer_address
+					expect(sub.save).to eq(true)
+				end
+
+				it 'should should retrieve properly from the database' do
+					sub = customer_address
+					sub.save
+	
+					customer = CustomerAddress.find(sub.id)
+					json = customer.as_json(:root => "customer_address")
+					
+					expect(json["customer_address"]["fields"]).to eq({
+						"address_1" => "555 Bloor Street",
+						"address_2" => nil,
+						"country" => "canada",
+						"province" => "ontario",
+						"city" => "toronto",
+						"postal_code" => "H0H0H0",
+					})
+				end
+			end
+
+			context 'when it is invalid' do
+				before do
+					customer_address.fields = {
+						"address_1" => "555 Bloor Street",
+						"address_2" => nil,
+						"country" => "canadaaaaa",
+						"province" => "ontario",
+						"city" => "toronto",
+						"postal_code" => "H0H0H",
+					}
+				end
+
+				it 'should not validate' do
+					expect(customer_address).to_not be_valid
+				end
+			end
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'logger'
+require 'rspec'
+
+require 'active_support/dependencies'
+require 'active_record'
+
+require 'has_dynamic_columns'
+
+if ENV['DEBUG_LOGS']
+	
+else
+
+end
+ENV['RAILS_ENV'] = 'test'
+
+# Trigger AR to initialize
+ActiveRecord::Base
+
+module Rails
+  def self.root
+    '.'
+  end
+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:'
+ActiveRecord::Migration.verbose = false
+
+require "generators/has_dynamic_columns/templates/migration"
+ActiveRecord::Schema.define do
+	CreateHasDynamicColumns.up
+
+	create_table :accounts, force: true do |t|
+		t.string :name
+		t.timestamps
+	end
+	create_table :customers, force: true do |t|
+		t.string :name
+		t.integer :account_id
+		t.timestamps
+	end
+	create_table :customer_addresses, force: true do |t|
+		t.string :name
+		t.integer :customer_id
+		t.timestamps
+	end
+end
+
+class Account < ActiveRecord::Base
+	has_many :customers
+	has_dynamic_columns
+end
+
+class Customer < ActiveRecord::Base
+	belongs_to :account
+	has_many :customer_addresses
+	has_dynamic_columns field_scope: "account", dynamic_type: "Customer", as: "fields"
+end
+
+class CustomerAddress < ActiveRecord::Base
+	belongs_to :customer
+	has_dynamic_columns field_scope: "customer.account", dynamic_type: "CustomerAddress", as: "fields"
+end
+
+
+RSpec.configure do |config|
+	config.after(:each) do
+		
+	end
+
+	config.expect_with :rspec do |c|
+		c.syntax = :expect
+	end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: has_dynamic_columns
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Butch Marshall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Adds ability to put dynamic fields into active record models
+email:
+- butch.a.marshall@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- has_dynamic_columns.gemspec
+- lib/generators/has_dynamic_columns/active_record_generator.rb
+- lib/generators/has_dynamic_columns/has_dynamic_columns_generator.rb
+- lib/generators/has_dynamic_columns/next_migration_version.rb
+- lib/generators/has_dynamic_columns/templates/migration.rb
+- lib/has_dynamic_columns.rb
+- lib/has_dynamic_columns/compatibility.rb
+- lib/has_dynamic_columns/dynamic_column.rb
+- lib/has_dynamic_columns/dynamic_column_datum.rb
+- lib/has_dynamic_columns/dynamic_column_option.rb
+- lib/has_dynamic_columns/dynamic_column_validation.rb
+- lib/has_dynamic_columns/version.rb
+- spec/has_dynamic_columns_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/butchmarshall/has_dynamic_columns
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Dynamic fields for activerecord models
+test_files:
+- spec/has_dynamic_columns_spec.rb
+- spec/spec_helper.rb