has_dynamic_columns 0.1.1 → 0.2.0

data/lib/has_dynamic_columns/active_record.rb

@@ -0,0 +1,12 @@
+module HasDynamicColumns
+	module ActiveRecord
+		def self.included(base)
+			base.extend ClassMethods
+			
+		end
+
+		module ClassMethods
+			include HasDynamicColumns::ActiveRecordRelation
+		end
+	end
+end

data/lib/has_dynamic_columns/active_record/query_methods.rb

@@ -0,0 +1,231 @@
+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
+					end
+				end
+			end
+
+			# When arel starts building - filter
+			def build_arel_with_dynamic_columns
+				#arel = Arel::SelectManager.new(table.engine, table)
+
+				# 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
+
+					# 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])
+
+					dynamic_scope[:where].each_with_index { |rel, index|
+						case rel
+						when String
+							next
+						else
+							dynamic_type = rel.left.relation.engine.to_s
+							col_name = rel.left.name
+							value = 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(
+							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]
+
+						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(
+													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(
+														arel_node
+													)
+												)
+
+						column_table_datum_join = table.create_join(column_datum_table, column_table_datum_join_on)
+						self.joins_values += [column_table_datum_join]
+					}
+				}
+
+				build_arel_without_dynamic_columns
+			end
+
+			# lifted from
+			# http://erniemiller.org/2013/10/07/activerecord-where-not-sane-true/
+			module WhereChainCompatibility
+				#include ::ActiveRecord::QueryMethods
+				#define_method :build_where,
+				#	::ActiveRecord::QueryMethods.instance_method(:build_where)
+
+				# Extends where to chain a has_dynamic_columns method
+				# This builds all the joins needed to search the has_dynamic_columns_data tables
+				def has_dynamic_columns(opts = :chain, *rest)
+					# Map
+					dynamic_columns_value = {
+						:scope => nil,
+						:where => @scope.send(:build_where, opts, rest)
+					}
+					@scope.has_dynamic_columns_values = dynamic_columns_value
+
+					chain = ::ActiveRecord::QueryMethods::WhereChain.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
+						def without_scope
+							@scope
+						end
+					end
+
+					chain
+				end
+			end
+
+			def where_with_dynamic_columns(opts = :chain, *rest)
+				if opts == :chain
+					scope = spawn
+					chain = ::ActiveRecord::QueryMethods::WhereChain.new(scope)
+					chain.send(:extend, WhereChainCompatibility)
+				else
+					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/active_record/relation.rb

@@ -0,0 +1,21 @@
+module HasDynamicColumns
+	module ActiveRecord
+		module Relation
+			def self.included(base)
+				base.class_eval do
+					def has_dynamic_columns_values
+						@values[:has_dynamic_columns_values] || []
+					end
+					def has_dynamic_columns_values=values
+						raise ImmutableRelation if @loaded
+						@values[:has_dynamic_columns_values] ||= []
+						@values[:has_dynamic_columns_values] << values
+					end
+				end
+
+				base.instance_eval do
+				end
+			end
+		end
+	end
+end

data/lib/has_dynamic_columns/active_record_relation.rb

@@ -0,0 +1,105 @@
+module HasDynamicColumns
+	module ActiveRecordRelation
+		def self.included(base)
+			base.class_eval do
+			end
+
+			base.instance_eval do
+			end
+		end
+
+		# lifted from
+		# http://erniemiller.org/2013/10/07/activerecord-where-not-sane-true/
+		module WhereChainCompatibility
+			module_function
+			include ::ActiveRecord::QueryMethods
+			define_method :build_where,
+				::ActiveRecord::QueryMethods.instance_method(:build_where)
+		end
+
+		def where(opts = :chain, *rest)
+			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
+				super
+			end
+		end
+	end
+end

data/lib/has_dynamic_columns/dynamic_column.rb

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

data/lib/has_dynamic_columns/dynamic_column_datum.rb

@@ -1,5 +1,5 @@
 module HasDynamicColumns
-	class DynamicColumnDatum < ActiveRecord::Base
+	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

data/lib/has_dynamic_columns/dynamic_column_option.rb

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

data/lib/has_dynamic_columns/dynamic_column_validation.rb

@@ -1,5 +1,5 @@
 module HasDynamicColumns
-	class DynamicColumnValidation < ActiveRecord::Base
+	class DynamicColumnValidation < ::ActiveRecord::Base
 		belongs_to :dynamic_column, :class_name => "HasDynamicColumns::DynamicColumn"
 
 		def is_valid?(str)

data/lib/has_dynamic_columns/model.rb

@@ -0,0 +1,10 @@
+require "has_dynamic_columns/model/class_methods"
+require "has_dynamic_columns/model/instance_methods"
+
+module HasDynamicColumns
+	module Model
+		def self.included(base)
+			base.send :extend, ClassMethods
+		end
+	end
+end

data/lib/has_dynamic_columns/model/class_methods.rb

@@ -0,0 +1,294 @@
+module HasDynamicColumns
+	module Model
+		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
+					alias_method :as_json_before_#{configuration[:as]}, :as_json
+
+					# Store all our configurations for usage later
+					@@has_dynamic_columns_configurations ||= []		        
+			        @@has_dynamic_columns_configurations << #{configuration}
+
+					include ::HasDynamicColumns::Model::InstanceMethods
+
+					has_many :activerecord_dynamic_columns,
+								class_name: "HasDynamicColumns::DynamicColumn",
+								as: :field_scope
+					has_many :activerecord_dynamic_column_data,
+								class_name: "HasDynamicColumns::DynamicColumnDatum",
+								as: :owner,
+								autosave: true
+
+					# 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 do |field_scope|
+						field_scope = self.get_#{configuration[:as]}_field_scope
+
+						if field_scope
+							# has_many association
+							if field_scope.respond_to?(:select) && field_scope.respond_to?(:collect)
+
+							# belongs_to association
+							else
+								# All the fields defined on the parent model
+								dynamic_columns = field_scope.send("activerecord_dynamic_columns")
+
+								self.send("activerecord_dynamic_column_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
+										if dynamic_column.nil?
+											# TODO - fix  from the has_many - need to fix validations
+											#errors.add(:dynamic_columns, { "unknown" => validation_errors })
+										else
+											errors.add(:dynamic_columns, { dynamic_column.key.to_s => validation_errors })
+										end
+									end
+								}
+							end
+						end
+					end
+
+					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_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
+
+							# Join on the column with the key
+							on_query = column_table[:key].eq(key)
+							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
+													)
+
+							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].is_a?(Hash) ? nil : args[0]
+							options = args.extract_options!
+
+							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
+							query = nil
+
+							# Need to join on each of the keys we are performing where on
+							options.each { |key, value|
+								# Don't bother with empty values
+								next if value.to_s.empty?
+
+								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
+								on_query = column_table[:key].eq(key)
+								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
+														)
+
+								column_table_join = table.create_join(column_table, column_table_join_on)
+								query = (query.nil?)? joins(column_table_join) : 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])
+															).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!
+
+							@@has_dynamic_columns_configurations.each { |config|
+								if !options[:root].nil?
+									json[options[:root]][config[:as].to_s] = self.send(config[:as].to_s)
+								else
+									json[config[:as].to_s] = self.send(config[:as].to_s)
+								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_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
+							}
+						end
+
+						def #{configuration[:as]}
+							h = {}
+							self.field_scope_#{configuration[:as]}.each { |i|
+								h[i.key] = 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)
+							}
+
+							h
+						end
+
+						def #{configuration[:as].to_s.singularize}_keys
+							self.field_scope_#{configuration[:as]}.collect { |i| i.key }
+						end
+
+						def field_scope_#{configuration[:as]}
+							# 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")
+								}.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|
+									# 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
+						end
+
+					protected
+						def get_#{configuration[:as]}_field_scope
+							#{configuration[:field_scope]}
+						end
+
+						# 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_#{configuration[:as]}').select { |i| i.key == key.to_s }.first
+								found = record
+							end
+							found
+						end
+				EOV
+			end
+		end
+	end
+end