has_dynamic_columns 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69d28ea4aadd2689e5653aceb6092dd913dbb831
-  data.tar.gz: 26a14d5b8a98d70565094e588f2a40ee3355de01
+  metadata.gz: 8e226dfbdf7a08adfe5c9fe89fd93704b94ce06c
+  data.tar.gz: f0a3a6de371ded59b17db4690d54093d2ab98d16
 SHA512:
-  metadata.gz: cff1aba3d57c28d9ebe93d660555a6959e064546c5d16768bdc308836fc89facdbd46b578cd94adfccc0c18b8e7dd40019a8a9d694d2912d0d53c050bf6a5f66
-  data.tar.gz: 9981d60459e0c61e76247ac59a11fe9a7558ec3429026de3904dd05a1e0c59cbc9957ede55a120d1896e50291ee8cba17f06dc9b1c0a8cd7f790ddf6b2e19b66
+  metadata.gz: 8dd05a3bd91dc8419c67506b463cb0c6741e1756901d9b4979202e4da4ea4c7a01b809de42d33a215f888ea490b458f5321ba2cad17291306d5e092db4bf0399
+  data.tar.gz: a543799ebbf31103a117652fe127a002e8fa6bbc00870e6c65c5eb54035f7c73af1eb2c8d81eed5eae3bddd3139cddb92c41da28fb749f39ee983511028da179

data/README.md

@@ -1,13 +1,13 @@
 has_dynamic_columns
 ============
 
-Add dynamic columns to ActiveRecord models
+This plugin gives ActiveRecord models the ability to dynamically define collectable data based on ***has_many*** and ***belongs_to*** relationships.
 
 Installation
 ============
 
 ```ruby
-gem 'has_dynamic_columns', :git => 'git://github.com/butchmarshall/has_dynamic_columns.git'
+gem "has_dynamic_columns"
 ```
 
 The Active Record migration is required to create the has_dynamic_columns table. You can create that table by
@@ -19,6 +19,22 @@ running the following command:
 Usage
 ============
 
+has_dynamic_columns
+
+ - as: 
+	 - the setter/getter method
+ - field_scope:
+	 - **belongs_to** or **has_many** relationship 
+
+## **belongs_to** relationship
+
+Our example is a data model where an **account** ***has_many*** **customers** and each **customer** ***has_many*** **customer_addresses**
+
+Each customers collectable info is uniquely defined by the associated account.
+
+Each customer addresses collectable info is defined by the associated customers account.
+
+**Models**
 ```ruby
 class Account < ActiveRecord::Base
 	has_many :customers
@@ -27,8 +43,7 @@ end
 
 class Customer < ActiveRecord::Base
 	belongs_to :account
-	has_many :customer_addresses
-	has_dynamic_columns field_scope: "account", as: "fields"
+	has_dynamic_columns field_scope: "account", as: "customer_fields"
 end
 
 class CustomerAddress < ActiveRecord::Base
@@ -37,3 +52,137 @@ class CustomerAddress < ActiveRecord::Base
 end
 ```
 
+**Setup**
+```ruby
+# ------------------------------------------------
+# Create our first account
+# ------------------------------------------------
+account = Account.new(:name => "Account #1")
+
+# Define a first_name field
+account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "first_name", :data_type => "string")
+# Define a last_name field
+account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "last_name", :data_type => "string")
+# Define a company field
+account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "company", :data_type => "string")
+
+# save
+account.save
+
+# ------------------------------------------------
+# Create our second account
+# ------------------------------------------------
+account = Account.new(:name => "Account #2")
+
+# Define a first_name field
+account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "first_name", :data_type => "string")
+# Define a last_name field
+account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "last_name", :data_type => "string")
+# Define a country field
+account.activerecord_dynamic_columns.build(:dynamic_type => "Customer", :key => "country", :data_type => "string")
+
+# save
+account.save
+```
+
+**Data**
+```ruby
+# Add a customer to our first account
+account = Account.find(1)
+customer = Customer.new(:account => account)
+customer.customer_fields = {
+	"first_name" => "Butch",
+	"last_Name" => "Marshall",
+	"company" => "Aperture Science"
+}
+customer.save
+
+# as_json
+customer.as_json
+# == { "id": 1, "account_id": 1, "customer_fields" => { "first_name" => "Butch", "last_Name" => "Marshall", "company" => "Aperture Science" } }
+
+# Add a customer to our first account
+account = Account.find(1)
+customer = Customer.new(:account => account)
+customer.customer_fields = {
+	"first_name" => "John",
+	"last_Name" => "Paterson",
+	"company" => "Aperture Science"
+}
+customer.save
+
+# Add a customer to our second account
+account = Account.find(2)
+customer = Customer.new(:account => account)
+customer.customer_fields = {
+	"first_name" => "Butch",
+	"last_Name" => "Marshall",
+	"country" => "Canada"
+}
+customer.save
+
+# as_json
+puts customer.as_json
+# == { "id": 2, "account_id": 2, "customer_fields" => { "first_name" => "Butch", "last_Name" => "Marshall", "country" => "Canada" } }
+```
+
+**Searching**
+```ruby
+
+# ------------------------------------------------
+# with_scope
+# ------------------------------------------------
+
+# ------------------------------------------------
+# Find customers under the first account
+# ------------------------------------------------
+account = Account.find(1)
+
+# 1 result
+Customer.where.has_dynamic_scope({ :first_name => "Butch" }).with_scope(account)
+
+# 1 result
+Customer.where.has_dynamic_scope({ :first_name => "Butch", :company => "Aperture Science" }).with_scope(account)
+
+# 0 results
+Customer.where.has_dynamic_scope({ :first_name => "Butch", :company => "Blaaaaa" }).with_scope(account)
+
+# 2 results
+Customer.where.has_dynamic_scope({ :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)
+
+# 1 result
+Customer.where.has_dynamic_scope({ :first_name => "Butch", :country => "Canada" }).with_scope(account)
+
+# 0 results
+Customer.where.has_dynamic_scope({ :first_name => "Butch", :country => "Japan" }).with_scope(account)
+```
+
+# ------------------------------------------------
+# without_scope
+# ------------------------------------------------
+
+# 6 results
+# finds everyone named butch, no matter what account they're apart of
+Customer.where.has_dynamic_scope({ :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
+
+# 1 match
+Customer.where.has_dynamic_scope(Customer.arel_table[:first_Name].eq("Canada")).with_scope(Account.find(1))
+
+## **has_many** relationship
+
+TODO example.

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_record"
+require "has_dynamic_columns"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/has_dynamic_columns.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
 	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 	spec.require_paths = ["lib"]
 
-	spec.add_dependency "activerecord", [">= 3.0", "< 5.0"]
+	spec.add_dependency "activerecord", "~> 4.2"
 
 	spec.add_development_dependency "bundler", "~> 1.7"
 	spec.add_development_dependency "rake", "~> 10.0"

data/lib/has_dynamic_columns.rb

@@ -1,5 +1,11 @@
 require "active_support"
+require 'active_support/dependencies'
+require "active_record"
 
+require "has_dynamic_columns/active_record/query_methods"
+require "has_dynamic_columns/active_record/relation"
+
+require "has_dynamic_columns/model"
 require "has_dynamic_columns/version"
 require "has_dynamic_columns/dynamic_column"
 require "has_dynamic_columns/dynamic_column_option"
@@ -7,305 +13,6 @@ 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
-					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
-
-		module InstanceMethods
-		end
-	end
 end
 
 if defined?(Rails::Railtie)
@@ -313,9 +20,13 @@ if defined?(Rails::Railtie)
 		initializer 'has_dynamic_columns.insert_into_active_record' do
 			ActiveSupport.on_load :active_record do
 				ActiveRecord::Base.send(:include, HasDynamicColumns::Model)
+				ActiveRecord::Relation.send(:include, HasDynamicColumns::ActiveRecord::Relation)
+				ActiveRecord::QueryMethods.send(:include, HasDynamicColumns::ActiveRecord::QueryMethods)
 			end
 		end
 	end
-else
-	ActiveRecord::Base.send(:include, HasDynamicColumns::Model) if defined?(ActiveRecord)
+elsif defined?(ActiveRecord)
+	ActiveRecord::Base.send(:include, HasDynamicColumns::Model)
+	ActiveRecord::Relation.send(:include, HasDynamicColumns::ActiveRecord::Relation)
+	ActiveRecord::QueryMethods.send(:include, HasDynamicColumns::ActiveRecord::QueryMethods)
 end