has_dynamic_columns 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e80b2327256e42bf94544f2002936cf1170de952
-  data.tar.gz: 8da148b09230ca67502a734597cb595390fa32a4
+  metadata.gz: 8adcb2fa0100a0caea34697193e9d0f008eb633a
+  data.tar.gz: 7dcd964a4ed65285fb819ad51f1f7656491b2610
 SHA512:
-  metadata.gz: 24a2777ffcd2b9feb28512fedb92ad9b224893a399bbdf50ec43160b4dd301e27e14b466736a68979347105d26db496f5e0359ddbcdd3f1b45f325ac53810195
-  data.tar.gz: e23a81b217be7906f6b8f65d8e7d65baf74f19dc1b7ca1a739a3de5205b1becda01a483e6c229e5cd0cbdbbbef30680b1e3d5351ec9432e833d4ec9a4f269812
+  metadata.gz: 0f933582fe5fce22e3cae11bb0af740581b08d221aa24b555fbcbb92323082b49bd5c19191204601d0a24a96a01382ee96f8a07a7387852bec36eddde7fe3904
+  data.tar.gz: 8b6f80d4116c9074149469cd4f6c33c047c1b96dabc517217578b2e0878eddbf2de0a770370398b868eaf81fc05491672fce6c131e3a043939f875d5e990f983

data/lib/has_dynamic_columns/version.rb

@@ -1,3 +1,3 @@
 module HasDynamicColumns
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/has_dynamic_columns.rb

@@ -22,12 +22,18 @@ module HasDynamicColumns
 		        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_#{configuration[:as]},
+					has_many :activerecord_dynamic_columns,
 								class_name: "HasDynamicColumns::DynamicColumn",
 								as: :field_scope
-					has_many :activerecord_#{configuration[:as]}_data,
+					has_many :activerecord_dynamic_column_data,
 								class_name: "HasDynamicColumns::DynamicColumnDatum",
 								as: :owner,
 								autosave: true
@@ -38,7 +44,59 @@ module HasDynamicColumns
 						#attr_accessible :#{configuration[:column]}
 					end
 
-					validate :validate_dynamic_column_data
+					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?
+										puts validation_errors.inspect
+											#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
@@ -148,11 +206,13 @@ module HasDynamicColumns
 							json = super(*args)
 							options = args.extract_options!
 
-							if !options[:root].nil?
-								json[options[:root]][self.dynamic_columns_as] = self.send(self.dynamic_columns_as)
-							else
-								json[self.dynamic_columns_as] = self.send(self.dynamic_columns_as)
-							end
+							@@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
@@ -167,10 +227,10 @@ module HasDynamicColumns
 								dynamic_column = self.#{configuration[:as].to_s.singularize}_key_to_dynamic_column(key)
 
 								# We already have this key in database
-								if existing = self.activerecord_#{configuration[:as]}_data.select { |i| i.dynamic_column == dynamic_column }.first
+								if existing = self.activerecord_dynamic_column_data.select { |i| i.dynamic_column == dynamic_column }.first
 									existing.value = value
 								else
-									self.activerecord_#{configuration[:as]}_data.build(:dynamic_column => dynamic_column, :value => value)
+									self.activerecord_dynamic_column_data.build(:dynamic_column => dynamic_column, :value => value)
 								end
 							}
 						end
@@ -180,9 +240,11 @@ module HasDynamicColumns
 							self.field_scope_#{configuration[:as]}.each { |i|
 								h[i.key] = nil
 							}
-							self.activerecord_#{configuration[:as]}_data.each { |i|
-								h[i.dynamic_column.key] = i.value unless !i.dynamic_column
+
+							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
 
@@ -191,17 +253,27 @@ module HasDynamicColumns
 						end
 
 						def field_scope_#{configuration[:as]}
-							self.field_scope.send("activerecord_"+self.field_scope.dynamic_columns_as).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
-							}
+							# 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
 
-						def dynamic_columns_as
-							"#{configuration[:as].to_s}"
+					protected
+						def get_#{configuration[:as]}_field_scope
+							#{configuration[:field_scope]}
 						end
 
-					protected
 						# Whether this is storable
 						def storable_#{configuration[:as].to_s.singularize}_key?(key)
 							self.#{configuration[:as].to_s.singularize}_keys.include?(key.to_s)
@@ -210,62 +282,19 @@ module HasDynamicColumns
 						# 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_"+self.dynamic_columns_as).select { |i| i.key == key.to_s }.first
+							if record = self.send('field_scope_#{configuration[:as]}').select { |i| i.key == key.to_s }.first
 								found = record
 							end
 							found
 						end
-
-						def field_scope
-							#{configuration[:field_scope]}
-						end
 				EOV
 			end
 		end
 
 		module InstanceMethods
 			# Validate all the dynamic_column_data at once
-			def validate_dynamic_column_data
-				field_scope = self.field_scope
-
-				if field_scope
-					# All the fields defined on the parent model
-					dynamic_columns = field_scope.send("activerecord_#{field_scope.dynamic_columns_as}")
-
-					self.send("activerecord_#{self.dynamic_columns_as}_data").each { |dynamic_column_datum|
-						# Collect all validation errors
-						validation_errors = []
+			def validate_dynamic_column_data(field_scope = nil)
 
-						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
-							errors.add(:dynamic_columns, { "#{dynamic_column.key}" => validation_errors })
-						end
-					}
-				end
 			end
 		end
 	end

data/spec/has_dynamic_columns_spec.rb

@@ -32,9 +32,154 @@ describe HasDynamicColumns do
 		field.dynamic_column_validations.build(:regexp => "^[^$]+$", :error => "blank")
 		field.dynamic_column_validations.build(:regexp => "^[ABCEGHJKLMNPRSTVXY]\\d[ABCEGHJKLMNPRSTVWXYZ]( )?\\d[ABCEGHJKLMNPRSTVWXYZ]\\d$", :error => "invalid_format")
 
+		# Product fields
+		account.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "rarity", :data_type => "string")
+
 		account
 	end
 
+	describe Product do
+		subject(:product) {
+			Product.new(:name => "Product #1", :account => account)
+		}
+		before do
+			@category0 = Category.new(:name => "Category 0", :account => product.account)
+			@category0.save
+
+			@category1 = Category.new(:name => "Category 1", :account => product.account)
+			@category1.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "vin_number", :data_type => "string")
+			@category1.save
+
+			@category2 = Category.new(:name => "Category 2", :account => product.account)
+			@category2.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "serial_number", :data_type => "string")
+			@category2.save
+			
+			@category3 = Category.new(:name => "Category 3", :account => product.account)
+			@category3.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "funky_data", :data_type => "string")
+			@category3.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "funkier_data", :data_type => "string")
+			@category3.save
+			
+			@category4 = Category.new(:name => "Category 4", :account => product.account)
+			@category4.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "funkiest_data", :data_type => "string")
+			@category4.activerecord_dynamic_columns.build(:dynamic_type => "Product", :key => "ok_data", :data_type => "string")
+		end
+
+		context 'when it has a defined has_many relationship' do
+
+			context 'when it has_many categories' do
+
+				it 'should return empty category_fields when no categories associated' do
+					json = product.as_json
+					expect(json["category_fields"]).to eq({})
+				end
+
+				it 'should return empty category_fields when no category has no dynamic_columns' do
+					product.categories << @category0
+					json = product.as_json
+					expect(json["category_fields"]).to eq({})
+				end
+
+				context 'when not saved' do
+					it 'should return a categories fields' do
+						product.categories << @category1
+						product.category_fields = {
+							"vin_number" => "123"
+						}
+
+						json = product.as_json
+						expect(json["category_fields"]).to eq({"vin_number"=>"123"})
+						expect(product.new_record?).to eq(true)
+					end
+				end
+				context 'when saved' do
+					it 'should return a categories fields' do
+						product.categories << @category1
+						product.category_fields = {
+							"vin_number" => "345"
+						}
+						product.save
+
+						json = product.as_json
+						expect(json["category_fields"]).to eq({"vin_number"=>"345"})
+						expect(product.new_record?).to eq(false)
+						
+						product_id = product.id
+						product = Product.find(product_id)
+						json = product.as_json
+						expect(json["category_fields"]).to eq({"vin_number"=>"345"})
+					end
+				end
+
+				it 'should kitchen sink' do
+					product.product_fields = {
+						"rarity" => "very rare"
+					}
+
+					# Add category 1 to the product - it should now have the fields of "vin number"
+					product.categories << @category1
+					product.categories << @category2
+
+					product.category_fields = {
+						"vin_number" => "first:this is the vin number",
+						"serial_number" => "first:serial number!"
+					}
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"first:serial number!"})
+
+					product.save
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"first:serial number!"})
+
+					product_id = product.id
+					product = Product.find(product_id)
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"first:serial number!"})
+
+					product.category_fields = {
+						"serial_number" => "second:serial number!"
+					}
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"second:serial number!"})
+
+					product.save
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"second:serial number!"})
+
+					product = Product.find(product_id)
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"second:serial number!"})
+
+					expect(@category4.new_record?).to eq(true)
+
+					product.categories << @category3
+					product.categories << @category4
+
+					expect(@category4.new_record?).to eq(false)
+
+					product.category_fields = {
+						"funkier_data" => "this is funkier data",
+						"ok_data" => "this is ok data"
+					}
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"second:serial number!", "funky_data"=>nil, "funkier_data"=>"this is funkier data", "funkiest_data"=>nil, "ok_data"=>"this is ok data"})
+
+					product.save
+					product = Product.find(product_id)
+					json = product.as_json
+					expect(json["product_fields"]).to eq({"rarity"=>"very rare"})
+					expect(json["category_fields"]).to eq({"vin_number"=>"first:this is the vin number", "serial_number"=>"second:serial number!", "funky_data"=>nil, "funkier_data"=>"this is funkier data", "funkiest_data"=>nil, "ok_data"=>"this is ok data"})
+				end
+			end
+		end
+	end
+
 	describe Customer do
 		subject(:customer) { Customer.new(:account => account) }
 		before do
@@ -56,7 +201,7 @@ describe HasDynamicColumns do
 			end
 			it 'should find me' do
 				c = customer
-				c.save
+				expect(c.save).to eq(true)
 				a = c.account
 
 				expect(a.customers.dynamic_where(a, { first_name: "Butch" }).length).to eq(1)
@@ -183,10 +328,10 @@ describe HasDynamicColumns do
 				it 'should should retrieve properly from the database' do
 					sub = customer_address
 					sub.save
-	
+
 					customer = CustomerAddress.find(sub.id)
 					json = customer.as_json(:root => "customer_address")
-					
+
 					expect(json["customer_address"]["fields"]).to eq({
 						"address_1" => "555 Bloor Street",
 						"address_2" => nil,

data/spec/spec_helper.rb

@@ -47,6 +47,22 @@ ActiveRecord::Schema.define do
 		t.integer :customer_id
 		t.timestamps
 	end
+	create_table :products, force: true do |t|
+		t.string :name
+		t.integer :account_id
+		t.timestamps
+	end
+	create_table :categories, force: true do |t|
+		t.string :name
+		t.integer :account_id
+		t.timestamps
+	end
+	create_table :category_owners, force: true do |t|
+		t.integer :category_id
+		t.integer :owner_id
+		t.string :owner_type
+		t.timestamps
+	end
 end
 
 class Account < ActiveRecord::Base
@@ -65,6 +81,29 @@ class CustomerAddress < ActiveRecord::Base
 	has_dynamic_columns field_scope: "customer.account", dynamic_type: "CustomerAddress", as: "fields"
 end
 
+class Product < ActiveRecord::Base
+	belongs_to :account
+	has_many :category_owners, :as => :owner
+	has_many :categories, :through => :category_owners
+
+	# Fields defined via the account
+	has_dynamic_columns field_scope: "account", dynamic_type: "Product", as: "product_fields"
+
+	# Fields defined via any associated categories
+	has_dynamic_columns field_scope: "categories", dynamic_type: "Product", as: "category_fields"
+end
+
+class Category < ActiveRecord::Base
+	belongs_to :account
+	has_many :category_owners
+
+	has_dynamic_columns field_scope: "account"
+end
+
+class CategoryOwner < ActiveRecord::Base
+	belongs_to :category
+	belongs_to :owner, :polymorphic => true
+end
 
 RSpec.configure do |config|
 	config.after(:each) do

metadata

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