has_dynamic_columns 0.2.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 448332c912f1846a9b67d402a0be6560fe2562c5
-  data.tar.gz: 256541a493f2e38a31683c7076239b42a6da5f6b
+  metadata.gz: f872c8cb5a681f06b58bd3e57477bc275a153c3c
+  data.tar.gz: c4d47b6fb08df2fd3bdd4d531988adc00c5312b0
 SHA512:
-  metadata.gz: 95a6df76f9a6000ebffeac04915cc8c8f8a422ded713a25f4fda3a02ea52d0c9273fbb37398945d16a0ff26754ffd716e6cf4dd4216bb5571b3f540392b74373
-  data.tar.gz: f27225cb04d612c509225626c44625b25f0cc1b1822a4d364e609a6a25e616e538459e3bc368420f3078fa1c78eef43b5d9971adac6ddddcb0d4369d2fe22441
+  metadata.gz: dd399b22a0be68a064d8e9f8e67bbc2558d290035c59fce659be6597d0406d928766d75f514b4c7b7cf67d0aa363abaa6af4c0ec79f85251195ef4bbbc8ca367
+  data.tar.gz: 7de3e24535b04a0b3a5abcbd40d573c6688164e954088f5e3f5878c46a2a2e5364a95b5792c19b78db9cb35564953dbabf3595f51d9c59605383fe93b99af191

data/Gemfile

@@ -2,13 +2,18 @@ source 'https://rubygems.org'
 
 gem 'rake'
 
-group :test do
-	if ENV['RAILS_VERSION'] == 'edge'
+group :development, :test do
+	activerecord_version = ENV['HAS_DYNAMIC_COLUMNS_ACTIVERECORD_VERSION']
+
+	if ENV['RAILS_VERSION'] == 'edge' || activerecord_version == "edge"
+		gem 'arel', :github => 'rails/arel'
 		gem 'activerecord', :github => 'rails/rails'
+	elsif activerecord_version && activerecord_version.strip != ""
+		gem "activerecord", activerecord_version
 	else
 		gem 'activerecord', (ENV['RAILS_VERSION'] || ['>= 3.0', '< 5.0'])
 	end
-	
+
 	gem 'coveralls', :require => false
 	gem 'rspec', '>= 3'
 	gem 'rubocop', '>= 0.25'

data/README.md

@@ -3,6 +3,15 @@ has_dynamic_columns
 
 This plugin gives ActiveRecord models the ability to dynamically define collectable data based on ***has_many*** and ***belongs_to*** relationships.
 
+Release Notes
+============
+
+**0.3.0**
+ - Moved to storing data types in separate tables (where/order now correct!)
+ - Added order.by_dynamic_columns
+ - Improved how joins were built to avoid duplicates
+ - Added ActiveRecord 3 and 4 compatibility
+
 Installation
 ============
 
@@ -14,6 +23,7 @@ The Active Record migration is required to create the has_dynamic_columns table.
 running the following command:
 
     rails generate has_dynamic_columns:active_record
+	rails generate has_dynamic_columns:upgrade_0_3_0_active_record
     rake db:migrate
 
 Usage
@@ -228,4 +238,18 @@ Customer
 
 ## **has_many** relationship
 
-TODO example.
+TODO example.
+
+**Ordering**
+```ruby
+
+# ------------------------------------------------
+# by dynamic column
+# ------------------------------------------------
+
+Customer
+	.order
+		.by_dynamic_columns(country: :asc)
+		.with_scope(Account.find(1))
+
+```

data/has_dynamic_columns.gemspec

@@ -18,8 +18,10 @@ Gem::Specification.new do |spec|
 	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 	spec.require_paths = ["lib"]
 
-	spec.add_dependency "activerecord", "~> 4.2"
+	spec.add_dependency "activerecord", [">= 3.0", "< 5.0"]
 
+	spec.add_development_dependency "sqlite3", "> 0"
+	spec.add_development_dependency "factory_girl", "> 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

@@ -16,7 +16,7 @@ module HasDynamicColumns
 		end
 
 		def self.next_migration_number(dirname)
-			ActiveRecord::Generators::Base.next_migration_number dirname
+			::ActiveRecord::Generators::Base.next_migration_number dirname
 		end
 	end
 end

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

@@ -8,7 +8,7 @@ class AddHasDynamicColumns < ActiveRecord::Migration
 			t.string :key
 			t.string :data_type
 
-			t.timestamps
+			t.timestamps null: false
 		end
 		add_index(:dynamic_columns, [:field_scope_id, :field_scope_type, :dynamic_type], name: 'index1')
 		create_table :dynamic_column_validations do |t|
@@ -17,13 +17,13 @@ class AddHasDynamicColumns < ActiveRecord::Migration
 			t.string :error
 			t.string :regexp
 
-			t.timestamps
+			t.timestamps null: false
 		end
 		create_table :dynamic_column_options do |t|
 			t.integer :dynamic_column_id
 			t.string :key
 
-			t.timestamps
+			t.timestamps null: false
 		end
 		create_table :dynamic_column_data do |t|
 			t.string :owner_type
@@ -32,7 +32,7 @@ class AddHasDynamicColumns < ActiveRecord::Migration
 			t.integer :dynamic_column_option_id
 			t.string :value
 
-			t.timestamps
+			t.timestamps null: false
 		end
 		add_index(:dynamic_column_data, [:owner_id, :owner_type, :dynamic_column_id], name: 'index2')
 	end

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

@@ -0,0 +1,89 @@
+class Upgrade030HasDynamicColumns < ActiveRecord::Migration
+	def self.up
+		add_column :dynamic_column_data, :datum_type, :string
+		add_column :dynamic_column_data, :datum_id, :integer
+
+		create_table :dynamic_column_boolean_data do |t|
+			t.boolean :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_boolean_data, [:value])
+
+		create_table :dynamic_column_date_data do |t|
+			t.date :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_date_data, [:value])
+
+		create_table :dynamic_column_datetime_data do |t|
+			t.datetime :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_datetime_data, [:value])
+
+		create_table :dynamic_column_enum_data do |t|
+			t.string :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_enum_data, [:value])
+
+		create_table :dynamic_column_float_data do |t|
+			t.float :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_float_data, [:value])
+
+		create_table :dynamic_column_integer_data do |t|
+			t.integer :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_integer_data, [:value])
+
+		create_table :dynamic_column_string_data do |t|
+			t.string :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_string_data, [:value])
+
+		create_table :dynamic_column_text_data do |t|
+			t.text :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_text_data, [:value], :length => 255)
+
+		create_table :dynamic_column_time_data do |t|
+			t.time :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_time_data, [:value])
+
+		create_table :dynamic_column_timestamp_data do |t|
+			t.timestamp :value
+			t.timestamps null: false
+		end
+		add_index(:dynamic_column_timestamp_data, [:value])
+
+		# Migrate data
+		["string","integer","boolean","text"].each { |data_type|
+			ActiveRecord::Base.connection.select_all("
+			SELECT
+				`dynamic_column_data`.*
+			FROM `dynamic_columns`
+				INNER JOIN `dynamic_column_data`
+					ON `dynamic_column_data`.`dynamic_column_id` = `dynamic_columns`.`id`
+			WHERE `dynamic_columns`.`data_type` = '#{data_type}'
+			").each { |i|
+				obj = "::HasDynamicColumns::DynamicColumn#{data_type.camelize}Datum".constantize.create(:value => i["value"])
+				if datum = ::HasDynamicColumns::DynamicColumnDatum.where(:id => i["id"]).first
+					datum.datum = obj
+					datum.save
+				end
+			}
+		}
+
+		remove_column :dynamic_column_data, :value
+	end
+
+	def self.down
+	end
+end

data/lib/generators/has_dynamic_columns/upgrade_0_3_0_active_record_generator.rb

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

data/lib/has_dynamic_columns/active_record/query_methods.rb

@@ -1,167 +1 @@
-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
-
-					# 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
-
-					# 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
-
-						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
-
-						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_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
-							rel.right
-						end
-
-						# Join on the column with the key
-						on_query = column_table[:key].eq(col_name)
-						on_query = on_query.and(
-							column_table[:field_scope_type].eq(field_scope_type)
-						) unless field_scope_type.nil?
-
-						on_query = on_query.and(
-							column_table[:field_scope_id].eq(field_scope_id)
-						) unless field_scope_id.nil?
-
-						column_table_join_on = column_table
-												.create_on(
-													on_query
-												)
-
-						column_table_join = table.create_join(column_table, column_table_join_on)
-						self.joins_values += [column_table_join]
-
-						# Join on all the data with the provided key
-						column_table_datum_join_on = column_datum_table
-												.create_on(
-													column_datum_table[:owner_id].eq(table[:id]).and(
-														column_datum_table[:owner_type].eq(dynamic_type)
-													).and(
-														column_datum_table[:dynamic_column_id].eq(column_table[:id])
-													)
-												)
-
-						column_table_datum_join = table.create_join(column_datum_table, column_table_datum_join_on, Arel::Nodes::OuterJoin)
-						self.joins_values += [column_table_datum_join]
-
-					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
-
-			# 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
-		end
-	end
-end
+require_relative "v#{ActiveRecord::VERSION::MAJOR}/query_methods"

data/lib/has_dynamic_columns/active_record/relation.rb

@@ -1,21 +1 @@
-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
+require_relative "v#{ActiveRecord::VERSION::MAJOR}/relation"