has_sparse_attributes 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b2787e2a6883d3d5453cdad9b12137910475140
+  data.tar.gz: 72a17b2ca0542d12cd31d2d8197ecc0a7f104a68
+SHA512:
+  metadata.gz: 79f92cf8585ce27d4ac04f23825472d52cd588a907c675815cf60d46a1ea79149e2cc90fe50e8069351fddf7beef0153bfdda2e56c490f8f35fde701e5fdbb06
+  data.tar.gz: d5de310d95fc804ff09019f4694b5618dda8a0cc5f048c8be55540140f2419b98e6edd716a201d6d23a9f2c1f6a96e30b3a11b8c50174cec48eca16c8052e80b

data/lib/active_record/has/sparse_attributes.rb

@@ -0,0 +1,135 @@
+require 'active_record/has/sparse_attributes/storage'
+require 'active_record/has/sparse_attributes/column_storage'
+require 'active_record/has/sparse_attributes/table_storage'
+
+module ActiveRecord #:nodoc:
+	module Has #:nodoc:
+		module SparseAttributes #:nodoc:
+			def self.included(base) #:nodoc:
+				base.extend(ClassMethods)
+			end
+			
+			module ClassMethods #:nodoc:
+				
+				def has_sparse_attributes(attribute_names, *options)
+					options = options.extract_options!
+					options[:storage] ||= :column
+					options[:serialize] ||= false
+					storage = options[:storage].to_sym
+					
+					# First-time initialization
+					if not self.methods.include?('sparse_attributes')
+						class_eval <<-EOV
+							cattr_accessor :sparse_attributes, :instance_accessor => false
+							@@sparse_attributes = {}
+
+							cattr_accessor :sparse_attribute_storage_configs
+							@@sparse_attribute_storage_configs = []
+							
+							before_update :sparse_attributes_before_update
+							before_save :sparse_attributes_before_save
+							after_save :sparse_attributes_after_save
+
+							def self.has_sparse_attribute?(name)
+								attribute = name.to_s
+								attribute = attribute[0..-2] if attribute.ends_with?('=')
+								return @@sparse_attributes.has_key?(attribute.to_sym)
+							end
+
+							include ActiveRecord::Has::SparseAttributes::InstanceMethods
+						EOV
+					end
+					
+					# Add getters and setters for each sparse attribute
+					attribute_names.each do |name|
+						class_eval <<-EOV
+							def #{name}()
+								get_sparse_attribute(:#{name})
+							end
+						
+							def #{name}=(v)
+								set_sparse_attribute(:#{name}, v)
+							end
+						EOV
+					end
+					
+					if storage == :column
+						storage_config = ColumnStorageConfig.new(self, options)
+					elsif storage == :table
+						storage_config = TableStorageConfig.new(self, options)
+					else
+						raise StandardError.new("Invalid storage option for has_sparse_attributes")
+					end
+					
+					self.sparse_attribute_storage_configs << storage_config
+					storage_id = self.sparse_attribute_storage_configs.length - 1
+
+					attribute_names.each do |name|
+						self.sparse_attributes[name.to_sym] = storage_id
+					end
+
+				end
+			end
+
+			module InstanceMethods
+
+				def get_sparse_attributes()
+					r = {}
+					self.class.sparse_attributes.each_key do |k|
+						v = self.get_sparse_attribute(k)
+						r[k] = v unless v.nil?
+					end
+					return r
+				end
+			
+				def get_sparse_attribute(name)
+					self.get_sparse_attribute_storage(name).get(name)
+				end
+				
+				def set_sparse_attribute(name, value)
+					self.get_sparse_attribute_storage(name).set(name, value)
+				end
+
+			protected
+				
+				attr_accessor :sparse_attribute_storage
+				
+				def get_sparse_attribute_storage(name)
+					create_sparse_attribute_storage()
+					self.sparse_attribute_storage[self.class.sparse_attributes[name.to_sym]]
+				end
+				
+				def create_sparse_attribute_storage()
+					if self.sparse_attribute_storage.nil?
+						self.sparse_attribute_storage = []
+						self.class.sparse_attribute_storage_configs.each do |config|
+							self.sparse_attribute_storage << config.instance(self)
+						end
+					end
+				end
+				
+				def sparse_attributes_before_update(*args)
+					create_sparse_attribute_storage()
+					self.sparse_attribute_storage.each do |store|
+						store.before_update(*args)
+					end
+				end
+				
+				def sparse_attributes_before_save(*args)
+					create_sparse_attribute_storage()
+					self.sparse_attribute_storage.each do |store|
+						store.before_save(*args)
+					end
+				end
+				
+				def sparse_attributes_after_save(*args)
+					create_sparse_attribute_storage()
+					self.sparse_attribute_storage.each do |store|
+						store.after_save(*args)
+					end
+				end
+
+			end
+		end
+	end
+end

data/lib/active_record/has/sparse_attributes/column_storage.rb

@@ -0,0 +1,84 @@
+module ActiveRecord #:nodoc:
+	module Has #:nodoc:
+		module SparseAttributes #:nodoc:
+			
+			class ColumnStorageConfig < StorageConfig
+				attr_accessor :column_name
+				
+				def initialize(klass, options = {})
+					super
+					@column_name = options[:column_name] || 'sparse_attributes'
+					serialize_class = options[:serialize_class]
+					if serialize_class != false
+						@model_class.class_eval "serialize '#{@column_name}'" + 
+							(serialize_class ? ", #{serialize_class.to_s}" : '')
+					end
+				end
+				
+				def instance(record)
+					ColumnStorage.new(record, self)
+				end
+			end
+			
+			class ColumnStorage < Storage
+				attr_accessor :updated_attributes
+
+				def get(name)
+					col = @config.column_name
+					return nil if @record[col].nil?
+					return @record[col][name.to_s]
+				end
+				
+				def set(name, value)
+					name = name.to_s
+					col = @config.column_name
+					@updated_attributes = {} if @updated_attributes.nil?
+					if @record[col].nil?
+						@record[col] = {}
+					end
+					a = @record[col]
+					if value.nil?
+						a.delete(name)
+					else
+						value = value.to_s if !@config.serialize_values
+						a[name] = value
+					end
+					@updated_attributes[name] = true
+					@record[col] = a
+				end
+				
+				def before_update(*args)
+					merge_sparse_attributes()
+				end
+				
+				def after_save(*args)
+					clear_updated_sparse_attributes()
+				end
+				
+			protected
+				
+				def merge_sparse_attributes()
+					return if @updated_attributes.nil?
+					col = @config.column_name
+					obj = @config.model_class.select(col.to_s).find(@record.id)
+					current = obj[col]
+					if current.nil? or current.empty?
+						return
+					end
+					@updated_attributes.each do |key, value|
+						if @record[col].has_key?(key)
+							current[key] = @record[col][key]
+						else
+							current.delete(key)
+						end
+					end
+					@record[col] = current
+				end
+				
+				def clear_updated_sparse_attributes
+					@updated_attributes = {}
+				end
+			end
+		end
+	end
+end

data/lib/active_record/has/sparse_attributes/storage.rb

@@ -0,0 +1,43 @@
+module ActiveRecord #:nodoc:
+	module Has #:nodoc:
+		module SparseAttributes #:nodoc:
+			class StorageConfig
+				
+				attr_accessor :model_class
+				attr_accessor :serialize_values
+				
+				def initialize(klass, options = {})
+					@model_class = klass
+					@serialize_values = options[:serialize] || false
+				end
+
+			end
+
+			class Storage
+				
+				attr_accessor :config
+				attr_accessor :record
+				
+				def initialize(record, config)
+					@record = record
+					@config = config
+				end
+				
+				def get(name)
+				end
+				
+				def set(name, value)
+				end
+				
+				def before_save(*args)
+				end
+			
+				def before_update(*args)
+				end
+				
+				def after_save(*args)
+				end
+			end
+		end
+	end
+end

data/lib/active_record/has/sparse_attributes/table_storage.rb

@@ -0,0 +1,153 @@
+module ActiveRecord #:nodoc:
+	module Has #:nodoc:
+		module SparseAttributes #:nodoc:
+			
+			class TableStorageConfig < StorageConfig
+				attr_accessor :attribute_model
+				attr_accessor :id_column
+				
+				def initialize(klass, options = {})
+					super
+					options[:attribute_class_name] ||= 'SparseAttribute'
+					options[:id_column] ||= @model_class.model_name.singular.to_s + '_id'
+					if !options[:table_name].blank?
+						if ActiveRecord::Base.methods.include?(:set_table_name)
+							table_name = ('set_table_name "' + options[:table_name] + '";') || ''
+						else
+							table_name = 'self.table_name = "' + options[:table_name] + '";'
+						end
+					else
+						table_name = ''						
+					end
+					@id_column = options[:id_column]
+					klass.class_eval "class #{options[:attribute_class_name]} < ActiveRecord::Base; #{table_name} validates_presence_of :#{@id_column}, :name; end"
+					@attribute_model = eval("klass::#{options[:attribute_class_name]}")
+				end
+				
+				def instance(record)
+					TableStorage.new(record, self)
+				end
+			end
+			
+			class TableStorage < Storage
+				attr_accessor :sparse_attributes
+				attr_accessor :sparse_attribute_values
+				attr_accessor :updated_sparse_attributes
+				
+				def after_save(*args)
+					save()
+				end
+
+				def load()
+					@sparse_attributes = {}
+					@sparse_attribute_values = {}
+					@updated_sparse_attributes = []
+					
+					# The item has not been saved - nothing to load
+					if @record.id.nil?
+						return
+					end
+					
+					unserialize = @config.serialize_values
+					attributes = @config.attribute_model.where(@config.id_column => @record.id)
+					attributes.each do |attr|
+						@sparse_attributes[attr.name] = attr
+						@sparse_attribute_values[attr.name] = unserialize ? YAML::load(attr.value) : attr.value
+					end
+				end
+				
+				def save()
+					return 0 if @updated_sparse_attributes.nil?
+					num_updates = 0
+					klass = @config.attribute_model
+					klass_id_column = @config.id_column
+					serialize = @config.serialize_values
+					@updated_sparse_attributes.each do |name|
+						value = @sparse_attribute_values[name]
+						have_attribute = @sparse_attributes.has_key?(name)
+						
+						# If the value is nil we will delete the attribute row
+						if value.nil?
+							num_updates += delete_row(name)
+						else
+							value = value.to_yaml if serialize
+							num_updates += 1 if set_row(name, value)
+						end
+					end
+				
+					@updated_sparse_attributes = []
+					return num_updates
+				end
+				
+				def get(name)
+					load() if @sparse_attributes.nil?
+					return @sparse_attribute_values[name.to_s]
+				end
+				
+				def set(name, value)
+					load() if @sparse_attributes.nil?
+
+					name = name.to_s
+					if value.nil?
+						@sparse_attribute_values[name] = nil
+					else
+						value = value.to_s unless @config.serialize_values
+						@sparse_attribute_values[name] = value
+					end
+					@updated_sparse_attributes << name
+				end
+				
+			protected
+			
+				def delete_row(name)
+					klass = @config.attribute_model
+					have_attribute = @sparse_attributes.has_key?(name)
+							
+					# If we have the attribute ActiveRecord instance
+					# we may be able to just delete the row
+					deleted = klass.delete(@sparse_attributes[name].id) if have_attribute
+
+					# If the attribute couldn't be deleted by id 
+					# we just scan for the record
+					if !have_attribute || deleted == 0
+						deleted = klass.where(["#{@config.id_column} = ? AND name = ?", @record.id, name]).delete_all
+					end
+					return deleted
+				end
+				
+				def set_row(name, value)
+					klass = @config.attribute_model
+					klass_id_column = @config.id_column
+					have_attribute = @sparse_attributes.has_key?(name)
+
+					if have_attribute					
+						# We already have the attribute so we should be able to just update
+						# the row based on the id, unless it has been deleted
+						attribute = @sparse_attributes[name]
+						attribute.value = value
+						updated = attribute.save
+					end
+						
+					if !have_attribute || updated == false
+						if klass.respond_to?(:find_or_create_by)
+							attribute = klass.create_with(:value => value).find_or_create_by(klass_id_column => @record.id, :name => name)
+						else
+							method_name = ('find_or_create_by_' + klass_id_column.to_s + '_and_name').to_sym
+							attribute = klass.send(method_name, klass_id_column => @record.id, :name => name, :value => value)
+						end
+						if attribute.value != value
+							attribute.value = value
+							updated = attribute.save
+						else
+							updated = 1
+						end
+						
+						@sparse_attributes[name] = attribute
+					end
+					return updated
+				end
+				
+			end
+		end
+	end
+end

data/lib/has_sparse_attributes.rb

@@ -0,0 +1,2 @@
+require 'active_record/has/sparse_attributes'
+ActiveRecord::Base.class_eval { include ActiveRecord::Has::SparseAttributes }

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: has_sparse_attributes
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Edward Potocko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-05 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: epotocko@equallevel.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_record/has/sparse_attributes.rb
+- lib/active_record/has/sparse_attributes/column_storage.rb
+- lib/active_record/has/sparse_attributes/storage.rb
+- lib/active_record/has/sparse_attributes/table_storage.rb
+- lib/has_sparse_attributes.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 3
+summary: Extension for ActiveRecord to allow sparse attributes
+test_files: []