has_dynamic_columns 0.2.1 → 0.3.2

data/lib/has_dynamic_columns/dynamic_column_enum_datum.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnEnumDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_float_datum.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnFloatDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_integer_datum.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnIntegerDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_string_datum.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnStringDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_text_datum.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnTextDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_time_datum.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnTimeDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+	end
+end

data/lib/has_dynamic_columns/dynamic_column_timestamp_datum.rb

@@ -0,0 +1,5 @@
+module HasDynamicColumns
+	class DynamicColumnTimestampDatum < ::ActiveRecord::Base
+		belongs_to :dynamic_column_datum, :class_name => "HasDynamicColumns::DynamicColumnDatum"
+	end
+end

data/lib/has_dynamic_columns/model/class_methods.rb

@@ -148,6 +148,7 @@ module HasDynamicColumns
 
 							field_scope_id = (!field_scope.nil?) ? field_scope.id : nil
 							field_scope_type = (!field_scope.nil?) ? field_scope.class.name.constantize.to_s : nil
+
 							dynamic_type = self.name.constantize.to_s
 
 							table = self.name.constantize.arel_table
@@ -158,8 +159,14 @@ module HasDynamicColumns
 								# Don't bother with empty values
 								next if value.to_s.empty?
 
+								column_datum_store_table_type = "HasDynamicColumns::DynamicColumnStringDatum"
+								if !field_scope.nil? && a = field_scope.activerecord_dynamic_columns.where(key: key.to_s).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_"+key.to_s)
 								column_datum_table = HasDynamicColumns::DynamicColumnDatum.arel_table.alias("dynamic_where_data_"+key.to_s)
+								column_datum_store_table = column_datum_store_table_type.constantize.arel_table.alias("dynamic_where_data_store_"+key.to_s)
 
 								# Join on the column with the key
 								on_query = column_table[:key].eq(key)
@@ -189,13 +196,26 @@ module HasDynamicColumns
 																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)
+								
+
+								# 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)
+															).and(
+																column_datum_store_table[:value].matches("%"+value+"%")
+															)
+														)
+		
+								column_table_datum_store_join = table.create_join(column_datum_store_table, column_table_datum_store_join_on)
+
+								query = query.joins(column_table_datum_store_join)
 							}
 							# Group required - we have many rows
 							query = (query.nil?)? group(table[:id]) : query.group(table[:id])

data/lib/has_dynamic_columns/version.rb

@@ -1,3 +1,3 @@
 module HasDynamicColumns
-  VERSION = "0.2.1"
+  VERSION = "0.3.2"
 end

data/lib/has_dynamic_columns.rb

@@ -12,6 +12,17 @@ require "has_dynamic_columns/dynamic_column_option"
 require "has_dynamic_columns/dynamic_column_validation"
 require "has_dynamic_columns/dynamic_column_datum"
 
+require "has_dynamic_columns/dynamic_column_boolean_datum"
+require "has_dynamic_columns/dynamic_column_date_datum"
+require "has_dynamic_columns/dynamic_column_datetime_datum"
+require "has_dynamic_columns/dynamic_column_enum_datum"
+require "has_dynamic_columns/dynamic_column_float_datum"
+require "has_dynamic_columns/dynamic_column_integer_datum"
+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"
+
 module HasDynamicColumns
 end
 

data/rspec_rvm

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+set -e
+
+if [[ -s "$HOME/.rvm/scripts/rvm" ]] ; then
+	source "$HOME/.rvm/scripts/rvm"
+elif [[ -s "/usr/local/rvm/scripts/rvm" ]] ; then
+	source "/usr/local/rvm/scripts/rvm"
+else
+	printf "ERROR: An RVM installation was not found.n"
+fi
+
+function run {
+	value=$( gem list --local bundler )
+	if [[ ! $value =~ "^bundler " ]]; then
+		gem install bundler --no-ri --no-rdoc
+	fi
+
+	echo 'Running bundle exec rspec spec against activesupport / activerecord 3.2.17'
+	HAS_DYNAMIC_COLUMNS_ACTIVERECORD_VERSION=3.2.17 bundle update activerecord
+	bundle exec rspec spec
+
+	echo 'Running bundle exec rspec spec against activesupport / activerecord 4.2.0'
+	HAS_DYNAMIC_COLUMNS_ACTIVERECORD_VERSION=4.2.0 bundle update activerecord
+	bundle exec rspec spec
+
+	echo 'Running bundle exec rspec spec against activesupport / activerecord edge'
+	HAS_DYNAMIC_COLUMNS_ACTIVERECORD_VERSION="edge" bundle update activerecord
+	bundle exec rspec spec
+}
+
+rvm use ruby-2.1.1@has_dynamic_columns --create
+run
+
+rvm use ruby-2.0.0@has_dynamic_columns --create
+run
+
+rvm use ruby-1.9.3@has_dynamic_columns --create
+run

data/spec/factories/account.rb

@@ -0,0 +1,24 @@
+FactoryGirl.define do
+	factory :account do |f|
+		f.name "Account Name Here"
+	end
+
+	factory :account_with_customer_dynamic_columns, parent: :account do
+		before(:create, :build) do |account|
+			# 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")
+			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")
+		end
+	end
+
+	factory :account_with_product_dynamic_columns, parent: :account do
+		before(:create, :build) do |account|
+			# Product fields
+			account.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "rarity", :data_type => "string")
+		end
+	end
+end

data/spec/factories/customer.rb

@@ -0,0 +1,35 @@
+FactoryGirl.define do
+	factory :customer do |f|
+		initialize_with {
+			Customer.new(account: account)
+		}
+
+		f.name "Customer"
+	end
+
+	factory :customer_with_dynamic_column_data, parent: :customer do |f|
+		transient do
+			index 0
+		end
+
+		before(:create, :build) do |customer, evaluator|
+			hash = {}
+			customer.account.activerecord_dynamic_columns.each_with_index { |i,index|
+				hash[i.key.to_s] = case i.data_type
+				when 'integer'
+					evaluator.index
+				when 'datetime'
+					DateTime.now.change(hour: evaluator.index)
+				when 'boolean'
+					true
+				else
+					"#{evaluator.index } - #{i.data_type}"
+				end
+			}
+			customer.fields = hash
+
+			customer
+		end
+	end
+
+end

data/spec/has_dynamic_columns/active_record/query_methods_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+describe ::HasDynamicColumns::ActiveRecord::QueryMethods do
+	let (:account) do
+		FactoryGirl.create(:account_with_customer_dynamic_columns)
+	end
+
+	before do
+		(1..10).each { |i|
+			FactoryGirl.create(:customer_with_dynamic_column_data, account: account, index: i)
+		}
+		customer = Customer.new(:account => account, :name => "2")
+		customer.fields = {
+			"first_name" => "Butch",
+			"last_name" => "Marshall",
+			"email" => "butch.a.marshall@unittest.com",
+			"trusted" => true,
+			"last_contacted" => DateTime.parse("2015-01-01 01:01:01"),
+			"total_purchases" => 30
+		}
+		customer.save
+
+		customer = Customer.new(:account => account, :name => "1")
+		customer.fields = {
+			"first_name" => "Butch",
+			"last_name" => "Casidy",
+			"email" => "butch.marshall@unittest.com",
+			"trusted" => true,
+			"last_contacted" => DateTime.parse("2011-01-01 01:01:01"),
+			"total_purchases" => 30
+		}
+		customer.save
+
+		customer = Customer.new(:account => account, :name => "1")
+		customer.fields = {
+			"first_name" => "George",
+			"last_name" => "Marshall",
+			"email" => "george.marshall@unittest.com",
+			"trusted" => false,
+			"last_contacted" => DateTime.parse("2014-01-01 01:01:01"),
+			"total_purchases" => 10
+		}
+		customer.save
+	end
+	context 'Customer' do
+		it 'should order by first_name' do
+			table = Customer.arel_table
+
+			result = Customer
+				.order
+					.by_dynamic_columns(first_name: :desc)
+					.with_scope(account)
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", "George", "Marshall"], ["2", "Butch", "Marshall"], ["1", "Butch", "Casidy"], ["Customer", "9 - string", "9 - string"], ["Customer", "8 - string", "8 - string"], ["Customer", "7 - string", "7 - string"], ["Customer", "6 - string", "6 - string"], ["Customer", "5 - string", "5 - string"], ["Customer", "4 - string", "4 - string"], ["Customer", "3 - string", "3 - string"], ["Customer", "2 - string", "2 - string"], ["Customer", "10 - string", "10 - string"], ["Customer", "1 - string", "1 - string"]])
+		end
+
+		it 'should order by first_name and filter' do
+			table = Customer.arel_table
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(first_name: :desc)
+					.with_scope(account)
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", "George", "Marshall"], ["2", "Butch", "Marshall"], ["1", "Butch", "Casidy"]])
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(first_name: :asc)
+					.with_scope(account)
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			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
+			table = Customer.arel_table
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(first_name: :desc)
+					.with_scope(account)
+				.order('"customers"."name" DESC')
+
+			result = result.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", "George", "Marshall"], ["2", "Butch", "Marshall"], ["1", "Butch", "Casidy"]])
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(first_name: :desc)
+					.with_scope(account)
+				.order('"customers"."name" ASC')
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", "George", "Marshall"], ["1", "Butch", "Casidy"], ["2", "Butch", "Marshall"]])
+		end
+
+		it 'should preserve order precedence' do
+			table = Customer.arel_table
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order('"customers"."name" ASC')
+				.order
+					.by_dynamic_columns(first_name: :desc)
+					.with_scope(account)
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", "George", "Marshall"], ["1", "Butch", "Casidy"], ["2", "Butch", "Marshall"]])
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(first_name: :desc)
+					.with_scope(account)
+				.order('"customers"."name" ASC')
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", "George", "Marshall"], ["1", "Butch", "Casidy"], ["2", "Butch", "Marshall"]])
+		end
+
+		it 'should preserve order by multiple dynamic columns' do
+			table = Customer.arel_table
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(last_name: :desc, first_name: :desc)
+					.with_scope(account)
+				.order('"customers"."name" ASC')
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", "George", "Marshall"], ["2", "Butch", "Marshall"], ["1", "Butch", "Casidy"]])
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(last_name: :desc, first_name: :asc)
+					.with_scope(account)
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["2", "Butch", "Marshall"], ["1", "George", "Marshall"], ["1", "Butch", "Casidy"]])
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(total_purchases: :desc, last_name: :desc, first_name: :asc)
+					.with_scope(account)
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["total_purchases"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["2", 30, "Butch", "Marshall"], ["1", 30, "Butch", "Casidy"], ["1", 10, "George", "Marshall"]])
+
+			result = Customer
+				.where
+					.has_dynamic_columns(
+						table[:first_name].eq("Butch").or(
+							table[:first_name].eq("George")
+						)
+					)
+					.with_scope(account)
+				.order
+					.by_dynamic_columns(total_purchases: :desc, last_name: :asc, first_name: :asc)
+					.with_scope(account)
+				.collect { |i|
+				json = i.as_json(:root => nil)
+				[json["name"], json["fields"]["total_purchases"], json["fields"]["first_name"], json["fields"]["last_name"]]
+			}
+			expect(result).to eq([["1", 30, "Butch", "Casidy"], ["2", 30, "Butch", "Marshall"], ["1", 10, "George", "Marshall"]])
+		end
+	end
+end

data/spec/has_dynamic_columns/dynamic_columns_integer_datum_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe HasDynamicColumns::DynamicColumnIntegerDatum do
+	let (:account) do
+		FactoryGirl.create(:account_with_customer_dynamic_columns)
+	end
+
+	context 'Customer' do
+		it 'should output json as integer' do
+			customer = Customer.new(:account => account)
+			customer.fields = {
+				"first_name" => "Butch",
+				"last_name" => "Marshall",
+				"total_purchases" => 123654,
+				"trusted" => true,
+			}
+			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})
+		end
+
+		context 'where.has_dynamic_columns' do
+			before do
+				(0..1).each { |k|
+					(0..10).each { |i|
+						customer = Customer.new(:account => account)
+						customer.fields = {
+							"first_name" => "Butch",
+							"last_name" => "Marshall",
+							"total_purchases" => i,
+							"trusted" => (i%2 == 0),
+						}
+						customer.save
+					}
+				}
+			end
+
+			it 'should find using hash' do
+				expect(account.customers.length).to eq(22)
+	
+				result = Customer
+					.where
+						.has_dynamic_columns(total_purchases: 5)
+						.with_scope(account)
+	
+				expect(result.length).to eq(2)
+			end
+			it 'should find all customers with less than 5 purchases' do
+				table = Customer.arel_table
+				expect(account.customers.length).to eq(22)
+	
+				result = Customer
+					.where
+						.has_dynamic_columns(
+							table[:total_purchases].lt(5)
+						)
+						.with_scope(account)
+	
+				expect(result.length).to eq(10)
+			end
+			it 'should find all customers with greater than 5 purchases' do
+				table = Customer.arel_table
+				expect(account.customers.length).to eq(22)
+	
+				result = Customer
+					.where
+						.has_dynamic_columns(
+							table[:total_purchases].gt(5)
+						)
+						.with_scope(account)
+	
+				expect(result.length).to eq(10)
+			end
+			it 'should find all customers with less than 7 purchases but more than 3' do
+				table = Customer.arel_table
+				expect(account.customers.length).to eq(22)
+	
+				result = Customer
+					.where
+						.has_dynamic_columns(
+							table[:total_purchases].lt(7).and(
+								table[:total_purchases].gt(3)
+							)
+						)
+						.with_scope(account)
+	
+				expect(result.length).to eq(6)
+			end
+		end
+		it 'should kitchen sink' do
+			table = Customer.arel_table
+			first_names =  ['Allison', 'Arthur', 'Ana', 'Beryl', 'Chantal', 'Cristobal', 'Claudette']
+			last_names = ['Abbott', 'Acevedo', 'Anderson', 'Andrews', 'Anthony', 'Armstrong']
+
+			customers = []
+			(0..first_names.length).each { |j|
+				(0..last_names.length).each { |k|
+					customers << [{
+						:account => account,
+						:fields => {
+						"first_name" => first_names[j%first_names.length],
+						"last_name" => last_names[k%last_names.length],
+						"total_purchases" => j+k,
+						"trusted" => (k%2 == 0),
+					}
+					}]
+				}
+			}
+
+			Customer.create(customers)
+			result = Customer
+					.where
+					.has_dynamic_columns(
+						table[:first_name].matches("A%").and(
+							table[:trusted].eq(true)
+						).or(
+							table[:last_name].eq("Armstrong")
+						)
+					)
+					.with_scope(account)
+			expect(result.length).to eq(24)
+		end
+	end
+end

data/spec/has_dynamic_columns/dynamic_columns_string_datum_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe HasDynamicColumns::DynamicColumnStringDatum do
+	it 'test' do
+		#puts FactoryGirl.create(:account_with_customer_dynamic_columns).inspect
+	end
+end