has_dynamic_columns 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e226dfbdf7a08adfe5c9fe89fd93704b94ce06c
-  data.tar.gz: f0a3a6de371ded59b17db4690d54093d2ab98d16
+  metadata.gz: 448332c912f1846a9b67d402a0be6560fe2562c5
+  data.tar.gz: 256541a493f2e38a31683c7076239b42a6da5f6b
 SHA512:
-  metadata.gz: 8dd05a3bd91dc8419c67506b463cb0c6741e1756901d9b4979202e4da4ea4c7a01b809de42d33a215f888ea490b458f5321ba2cad17291306d5e092db4bf0399
-  data.tar.gz: a543799ebbf31103a117652fe127a002e8fa6bbc00870e6c65c5eb54035f7c73af1eb2c8d81eed5eae3bddd3139cddb92c41da28fb749f39ee983511028da179
+  metadata.gz: 95a6df76f9a6000ebffeac04915cc8c8f8a422ded713a25f4fda3a02ea52d0c9273fbb37398945d16a0ff26754ffd716e6cf4dd4216bb5571b3f540392b74373
+  data.tar.gz: f27225cb04d612c509225626c44625b25f0cc1b1822a4d364e609a6a25e616e538459e3bc368420f3078fa1c78eef43b5d9971adac6ddddcb0d4369d2fe22441

data/README.md

@@ -139,30 +139,49 @@ puts customer.as_json
 account = Account.find(1)
 
 # 1 result
-Customer.where.has_dynamic_scope({ :first_name => "Butch" }).with_scope(account)
+Customer
+	.where
+		.has_dynamic_columns({ :first_name => "Butch" })
+		.with_scope(account)
 
 # 1 result
-Customer.where.has_dynamic_scope({ :first_name => "Butch", :company => "Aperture Science" }).with_scope(account)
+Customer
+	.where
+		.has_dynamic_columns({ :first_name => "Butch", :company => "Aperture Science" })
+		.with_scope(account)
 
 # 0 results
-Customer.where.has_dynamic_scope({ :first_name => "Butch", :company => "Blaaaaa" }).with_scope(account)
+Customer
+	.where
+		.has_dynamic_columns({ :first_name => "Butch", :company => "Blaaaaa" })
+		.with_scope(account)
 
 # 2 results
-Customer.where.has_dynamic_scope({ :company => "Aperture Science" }).with_scope(account)
+Customer
+	.where.has_dynamic_columns({ :company => "Aperture Science" })
+	.with_scope(account)
 
 # ------------------------------------------------
 # Find customers under the second account
 # ------------------------------------------------
 account = Account.find(2)
 # 1 result
-Customer.where.has_dynamic_scope({ :first_name => "Butch" }).with_scope(account)
+Customer
+	.where
+		.has_dynamic_columns({ :first_name => "Butch" })
+		.with_scope(account)
 
 # 1 result
-Customer.where.has_dynamic_scope({ :first_name => "Butch", :country => "Canada" }).with_scope(account)
+Customer
+	.where
+		.has_dynamic_columns({ :first_name => "Butch", :country => "Canada" })
+		.with_scope(account)
 
 # 0 results
-Customer.where.has_dynamic_scope({ :first_name => "Butch", :country => "Japan" }).with_scope(account)
-```
+Customer
+	.where
+		.has_dynamic_columns({ :first_name => "Butch", :country => "Japan" })
+		.with_scope(account)
 
 # ------------------------------------------------
 # without_scope
@@ -170,18 +189,42 @@ Customer.where.has_dynamic_scope({ :first_name => "Butch", :country => "Japan" }
 
 # 6 results
 # finds everyone named butch, no matter what account they're apart of
-Customer.where.has_dynamic_scope({ :first_name => "Butch" }).without_scope
+Customer
+	.where
+		.has_dynamic_columns({ :first_name => "Butch" })
+		.without_scope
 
 # ------------------------------------------------
 # with Arel
-# WARNING: compound conditionals such as Customer.arel_table[:first_Name].matches("B%").and(Customer.arel_table[:first_Name].eq("Canada")) are NOT currently supported
 # ------------------------------------------------
 
 # 6 matches
-Customer.where.has_dynamic_scope(Customer.arel_table[:first_Name].matches("B%")).without_scope
+Customer
+	.where.has_dynamic_columns(Customer.arel_table[:first_Name].matches("B%"))
+	.without_scope
 
 # 1 match
-Customer.where.has_dynamic_scope(Customer.arel_table[:first_Name].eq("Canada")).with_scope(Account.find(1))
+Customer
+	.where
+		.has_dynamic_columns(Customer.arel_table[:country].eq("Canada"))
+		.with_scope(Account.find(1))
+
+# ------------------------------------------------
+# with nested or/and Arel
+# ------------------------------------------------
+
+# Anyone with country: Canada or first_name: John
+# 2 match
+Customer
+	.where
+		.has_dynamic_columns(
+			Customer.arel_table[:country].eq("Canada").or(
+				Customer.arel_table[:first_name].eq("John")
+			)
+		)
+		.with_scope(Account.find(1))
+
+```
 
 ## **has_many** relationship
 

data/lib/has_dynamic_columns/active_record/query_methods.rb

@@ -2,46 +2,59 @@ module HasDynamicColumns
 	module ActiveRecord
 		module QueryMethods
 			def self.included(base)
-
 				base.class_eval do
 					alias_method_chain :where, :dynamic_columns
 					alias_method_chain :build_arel, :dynamic_columns
-				end
 
-				base.instance_eval do
-					def has_dynamic_column_values=a
-					end
-					def has_dynamic_column_values
+					# Recurses through arel nodes until it finds one it can work with
+					def dynamic_column_process_nodes(rel, scope, index)
+						case rel
+						when Arel::Nodes::Grouping
+							dynamic_column_process_nodes(rel.expr, scope, index+1)
+						when Arel::Nodes::Or
+							dynamic_column_process_nodes(rel.left, scope, index+1)
+							dynamic_column_process_nodes(rel.right, scope, index+10000) # Hack - queries with over 10,000 dynamic where conditions may break
+						when Arel::Nodes::And
+							dynamic_column_process_nodes(rel.left, scope, index+1)
+							dynamic_column_process_nodes(rel.right, scope, index+10000) # Hack - queries with over 10,000 dynamic where conditions may break
+						# We can work with this
+						else	
+							dynamic_column_build_arel_joins_and_modify_wheres(rel, scope, index+1)
+						end
 					end
-				end
-			end
 
-			# When arel starts building - filter
-			def build_arel_with_dynamic_columns
-				#arel = Arel::SelectManager.new(table.engine, table)
+					# 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
+					def dynamic_column_build_arel_joins_and_modify_wheres(rel, scope, index)
+						col_name = rel.left.name
+						value = rel.right
 
-				# Calculate any dynamic scope that was passed
-				self.has_dynamic_columns_values.each { |dynamic_scope|
-					field_scope = dynamic_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
+						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
 
-					# TODO - make this work on compound arel queries like: table[:last_name].eq("Paterson").or(table[:first_name].eq("John"))
-					#collapsed = collapse_wheres(arel, dynamic_scope[:where])
+						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}")
 
-					dynamic_scope[:where].each_with_index { |rel, index|
-						case rel
-						when String
-							next
+						dynamic_type = rel.left.relation.engine.to_s
+						rel.left.relation = column_datum_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
+
+						rel.right = case rel.right
+						# Map true -> 1
+						when ::TrueClass
+							1
+						# Map false -> 0
+						when ::FalseClass
+							0
 						else
-							dynamic_type = rel.left.relation.engine.to_s
-							col_name = rel.left.name
-							value = rel.right
+							rel.right
 						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}")
-
 						# Join on the column with the key
 						on_query = column_table[:key].eq(col_name)
 						on_query = on_query.and(
@@ -60,13 +73,6 @@ module HasDynamicColumns
 						column_table_join = table.create_join(column_table, column_table_join_on)
 						self.joins_values += [column_table_join]
 
-						arel_node = case rel
-							when Arel::Nodes::Equality
-								column_datum_table[:value].eq(value)
-							else
-								column_datum_table[:value].matches(value)
-						end
-
 						# Join on all the data with the provided key
 						column_table_datum_join_on = column_datum_table
 												.create_on(
@@ -74,15 +80,37 @@ module HasDynamicColumns
 														column_datum_table[:owner_type].eq(dynamic_type)
 													).and(
 														column_datum_table[:dynamic_column_id].eq(column_table[:id])
-													).and(
-														arel_node
 													)
 												)
 
-						column_table_datum_join = table.create_join(column_datum_table, column_table_datum_join_on)
+						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]
+
+					end
+				end
+			end
+
+			# When arel starts building - filter
+			def build_arel_with_dynamic_columns
+				# Calculate any dynamic scope that was passed
+				self.has_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_nodes(rel, dynamic_scope[:scope], (index_outer*1000)+(index_inner*10000))
+
+						# It's now safe to use the original where query
+						# All the conditions in rel have been modified to be a where of the aliases dynamic_where_data table
+						
+						# 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]
 					}
 				}
+				# At least one dynamic where run - we need to group or we're going to get duplicates
+				if self.has_dynamic_columns_values.length > 0
+					self.group_values += [Arel::Nodes::Group.new(table[:id])]
+				end
 
 				build_arel_without_dynamic_columns
 			end
@@ -134,98 +162,6 @@ module HasDynamicColumns
 					where_without_dynamic_columns(opts, rest)
 				end
 			end
-=begin
-			def where_with_dynamic_columns(opts = :chain, *rest)
-				puts "--------------------------------------"
-				puts "Calling where_with_dynamic_columns"
-				puts opts.inspect
-				puts rest.inspect
-				
-				if opts == :chain
-					scope = spawn
-					scope.extend(WhereChainCompatibility)
-					chain = ::ActiveRecord::QueryMethods::WhereChain.new(scope)
-					chain.instance_eval do
-						# Provide search on dynamic columns
-						def dynamic(opts, *rest)				
-							options = rest.extract_options!
-							field_scope = opts.respond_to?(:class) && opts.class.respond_to?(:ancestors) && (opts.class.ancestors.include?(::ActiveRecord::Base)) ? opts : nil
-	
-							# Field scope passed to the where clause
-							if !field_scope.nil?
-								opts = options
-								rest = []
-							end
-	
-							field_scope_id = (!field_scope.nil?) ? field_scope.id : nil
-							field_scope_type = (!field_scope.nil?) ? field_scope.class.name.constantize.to_s : nil
-	
-							# Join dynamic_column table
-							# This filter by scope if field_scope is passed
-							@scope.joins_values += @scope.send(:build_where, opts, rest).map do |rel|
-								dynamic_type = rel.left.relation.engine.to_s
-	
-								col_name = rel.left.name
-								value = rel.right
-	
-								table = dynamic_type.constantize.arel_table
-								column_table = ::HasDynamicColumns::DynamicColumn.arel_table.alias("dynamic_where_#{col_name}")
-	
-								on_query = column_table[:key].eq(col_name)
-								if !field_scope_type.nil?
-									on_query = on_query.and(
-										column_table[:field_scope_type].eq(field_scope_type)
-									)
-								end
-								if !field_scope_id.nil?
-									on_query = on_query.and(
-										column_table[:field_scope_id].eq(field_scope_id)
-									)
-								end
-	
-								column_table_join_on = column_table.create_on(on_query)
-								table.create_join(column_table, column_table_join_on)
-							end unless field_scope.nil?
-	
-							# Join dynamic_column_data table
-							# This filters on data irrigardless of scope
-							join_value = @scope.send(:build_where, opts, rest).map do |rel|
-								dynamic_type = rel.left.relation.engine.to_s
-	
-								col_name = rel.left.name
-								value = rel.right
-	
-								table = dynamic_type.constantize.arel_table
-								column_table = ::HasDynamicColumns::DynamicColumn.arel_table.alias("dynamic_where_#{col_name}")
-								column_datum_table = ::HasDynamicColumns::DynamicColumnDatum.arel_table.alias("dynamic_where_data_#{col_name}")
-	
-								# 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+"%")
-															)
-														)
-	
-								table.create_join(column_datum_table, column_table_datum_join_on)
-							end
-							@scope.joins_values += join_value
-	
-							@scope
-						end
-					end
-					
-					chain
-				else
-					# Default where
-					where_without_dynamic_columns(opts, rest)
-				end
-			end
-=end
 		end
 	end
 end

data/lib/has_dynamic_columns/model/class_methods.rb

@@ -140,6 +140,7 @@ module HasDynamicColumns
 							query
 						end
 
+						# Depricated
 						# Find by dynamic columns
 						def self.dynamic_where(*args)
 							field_scope = args[0].is_a?(Hash) ? nil : args[0]

data/lib/has_dynamic_columns/version.rb

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

data/spec/has_dynamic_columns_spec.rb

@@ -38,8 +38,22 @@ describe HasDynamicColumns do
 		account
 	end
 
+	let (:account2) do
+		account = Account.new(:name => "Account #2")
 
-	describe HasDynamicColumns::ActiveRecord, :focus => true do
+		# 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 => "country", :data_type => "string")
+		account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "company", :data_type => "string")
+
+		# Product fields
+		account.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "rarity", :data_type => "string")
+
+		account
+	end
+
+	describe HasDynamicColumns::ActiveRecord, :focus => true  do
 		it 'should find everyone in the current account scope' do
 			customer = Customer.create(:account => account)
 			customer.fields = {
@@ -71,7 +85,7 @@ describe HasDynamicColumns do
 			customer = Customer.create(:account => account)
 			customer.fields = {
 				"first_name" => "Carl",
-				"last_name" => "Marx",
+				"last_name" => "Paterson",
 				"email" => "carl@communist.com",
 				"trusted" => false,
 			}
@@ -81,17 +95,17 @@ describe HasDynamicColumns do
 
 			# 1 communist
 			result = Customer.where.has_dynamic_columns(table[:email].matches("%gmail.com")).with_scope(account)
-			expect(result.length).to eq(3)
+			expect(result.all.length).to eq(3)
 
 			# 2 patersons
 			result = Customer.where.has_dynamic_columns(table[:last_name].eq("Paterson")).with_scope(account)
-			expect(result.length).to eq(2)
-			
+			expect(result.all.length).to eq(3)
+
 			# 1 john paterson
 			result = Customer
 						.where.has_dynamic_columns(table[:first_name].eq("John")).with_scope(account)
 						.where.has_dynamic_columns(table[:last_name].eq("Paterson")).with_scope(account)
-			expect(result.length).to eq(1)
+			expect(result.all.length).to eq(1)
 		end
 
 		it 'should find the single person in this scope' do
@@ -105,12 +119,88 @@ describe HasDynamicColumns do
 			customer.save
 
 			result = Customer.where.has_dynamic_columns(Customer.arel_table[:email].matches("%gmail.com")).with_scope(account)
-			expect(result.length).to eq(1)
+			expect(result.all.length).to eq(1)
 		end
 
 		it 'should find all 4 gmail users when no scope passed' do
 			result = Customer.where.has_dynamic_columns(Customer.arel_table[:email].matches("%gmail.com")).without_scope
-			expect(result.length).to eq(4)
+			expect(result.all.length).to eq(4)
+		end
+
+		it 'should find anyone with first names Steve or John in account 1\'s scope' do
+			customer = Customer.create(:account => account)
+			customer.fields = {
+				"first_name" => "Steve",
+				"last_name" => "Jobs",
+				"email" => "steve.jobs@apple.com",
+				"trusted" => false,
+			}
+			customer.save
+			
+			result = Customer.where.has_dynamic_columns(Customer.arel_table[:first_name].eq("Steve").or(Customer.arel_table[:first_name].eq("John"))).with_scope(Account.find(1))
+			expect(result.all.length).to eq(2)
+		end
+
+		it 'should find anyone with first names Steve or John in any scope' do
+			result = Customer.where.has_dynamic_columns(Customer.arel_table[:first_name].eq("Steve").or(Customer.arel_table[:first_name].eq("John"))).without_scope
+			expect(result.all.length).to eq(3)
+		end
+
+		it 'should find anyone with first names Steve or John and is trusted in any scope' do
+			result = Customer
+						.where.has_dynamic_columns(Customer.arel_table[:trusted].eq(true)).without_scope
+						.where.has_dynamic_columns(Customer.arel_table[:first_name].eq("Steve").or(Customer.arel_table[:first_name].eq("John"))).without_scope
+			expect(result.all.length).to eq(2)
+		end
+
+		it 'should find anyone with first names Steve and is not trusted in any scope' do
+			result = Customer
+						.where.has_dynamic_columns(Customer.arel_table[:trusted].eq(false)).without_scope
+						.where.has_dynamic_columns(Customer.arel_table[:first_name].eq("Steve")).without_scope
+			expect(result.all.length).to eq(1)
+		end
+		
+		it 'should find all the Steves who are trusted in account 3\'s scope' do
+			result = Customer
+						.where.has_dynamic_columns(Customer.arel_table[:trusted].eq(true)).with_scope(Account.find(3))
+						.where.has_dynamic_columns(Customer.arel_table[:first_name].eq("Steve")).without_scope
+			expect(result.all.length).to eq(0)
+		end
+
+		it 'should find all the Steves who are trusted in account 1\'s scope' do
+			result = Customer
+						.where.has_dynamic_columns(Customer.arel_table[:trusted].eq(true)).with_scope(Account.find(1))
+						.where.has_dynamic_columns(Customer.arel_table[:first_name].eq("Steve")).without_scope
+			expect(result.all.length).to eq(1)
+		end
+
+		it 'should find across column types if no scope specified' do
+			customer = Customer.create(:account => account2)
+			customer.fields = {
+				"first_name" => "Steve",
+				"last_name" => "Jobs",
+				"company" => "Apple Computers",
+				"country" => "USA",
+			}
+			customer.save
+
+			result = Customer
+						.where.has_dynamic_columns(
+							Customer.arel_table[:first_name].eq("John").or(
+								Customer.arel_table[:company].eq("Apple Computers")
+							)
+						).without_scope
+			expect(result.all.length).to eq(2)
+		end
+
+		it 'should restrict if scope specified' do
+			result = Customer
+						.where.has_dynamic_columns(
+							Customer.arel_table[:first_name].eq("John").or(
+								Customer.arel_table[:company].eq("Apple Computers")
+							)
+						).with_scope(Account.find(4))
+			expect(result.all.length).to eq(1)
 		end
 	end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_dynamic_columns
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Butch Marshall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-11 00:00:00.000000000 Z
+date: 2015-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord