create_custom_attributes 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7018b4e9074371f1263c36a537695fd2d9b92165
+  data.tar.gz: ba70ed21c53fa7b2363959714627e2a0f7f90651
+SHA512:
+  metadata.gz: 151eca8d70347c7318b44c92cc90aa3a808db5b82351630020704424798a859c99c2814356e45291d8d5738a81d5c88d39a2171d4b368eee8e28aab1123ac5de
+  data.tar.gz: 46ce57830f19bca3f35a33d68a8da4a9b32bcdc02760311cbd4284d3479e117343c07cafd2fe8a1cc7200f3d91ff38f938b31adae8b4d25d0dedae5fa5ba038e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Daniel Grützmacher
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,12 @@
+
+# CustomAttributes
+CustomAttributes allows the management of custom attributes (or metadata, meta fields) for ActiveRecord models.
+
+## Usage
+
+
+## Installation
+This gem is not suited for standalone use, please use it by adding it to the Gemfile of a Rails application.
+
+## License
+CustomAttributes is open source and released under the terms of the GNU General Public License v2 (GPL).

data/Rakefile

@@ -0,0 +1,35 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CustomAttributes'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+  t.warning = false
+end
+
+
+task default: :test

data/lib/custom_attributes.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+
+require 'custom_attributes/acts_as/acts_as_customizable'
+require 'custom_attributes/acts_as/acts_as_custom_field'
+require 'custom_attributes/acts_as/acts_as_custom_value'
+
+require 'custom_attributes/field_type'
+require 'custom_attributes/field_types/unbounded'
+require 'custom_attributes/field_types/list'
+require 'custom_attributes/field_types/numeric'
+
+require 'custom_attributes/field_types/bool_field_type'
+require 'custom_attributes/field_types/date_field_type'
+require 'custom_attributes/field_types/float_field_type'
+require 'custom_attributes/field_types/text_field_type'
+require 'custom_attributes/field_types/string_field_type'
+require 'custom_attributes/field_types/list_field_type'
+require 'custom_attributes/field_types/int_field_type'
+
+require 'custom_attributes/custom_field_value'
+
+require 'custom_attributes/api/custom_attributes_controller_helper'
+
+require 'custom_attributes/concerns/searchable'
+
+module CustomAttributes
+  # Gem configuration credits to: https://stackoverflow.com/questions/6233124/where-to-place-access-config-file-in-gem#10112179
+  @config = {
+    search_user: 'elastic',
+    search_pass: 'changeme',
+    search_host: 'localhost:9200'
+  }
+
+  @valid_config_keys = @config.keys
+
+  # Configure through hash
+  def self.configure(opts = {})
+    opts.each { |k, v| @config[k.to_sym] = v if @valid_config_keys.include? k.to_sym }
+
+    after_configuration
+  end
+
+  # Configure through yaml file
+  def self.configure_with(path_to_yaml_file)
+    begin
+      config = YAML.safe_load(IO.read(path_to_yaml_file))
+    rescue Errno::ENOENT
+      log(:warning, "YAML configuration file couldn't be found. Using defaults."); return
+    rescue Psych::SyntaxError
+      log(:warning, 'YAML configuration file contains invalid syntax. Using defaults.'); return
+    end
+
+    configure(config)
+  end
+
+  def self.config
+    @config
+  end
+
+  def self.after_configuration
+    # Set up ElasticSearch
+    Elasticsearch::Model.client = Elasticsearch::Client.new host: "http://#{@config[:search_user]}:#{@config[:search_pass]}@#{@config[:search_host]}"
+  end
+end

data/lib/custom_attributes/acts_as/acts_as_custom_field.rb

@@ -0,0 +1,167 @@
+module CustomAttributes
+  module ActsAsCustomField
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      def acts_as_custom_field(_options = {})
+        include CustomAttributes::ActsAsCustomField::InstanceMethods
+
+        scope :sorted, -> { order(:position) }
+
+        serialize :possible_values
+
+        attr_accessor :edit_tag_style
+
+        validates_numericality_of :min_length, :only_integer => true, :greater_than_or_equal_to => 0
+        validates_numericality_of :max_length, :only_integer => true, :greater_than_or_equal_to => 0
+        validates_presence_of :name, :field_type
+        validates_uniqueness_of :name, scope: :model_type
+        validates_length_of :name, maximum: 30
+        validates_inclusion_of :field_type, in: proc { CustomAttributes::FieldType.available_types.map { |ft| ft.name.gsub(/CustomAttributes::|FieldType/, '') } }
+        validate :validate_custom_field
+
+        before_create do |field|
+          field.set_slug
+        end
+
+        before_save do |field|
+          field.type.before_custom_field_save(field)
+        end
+      end
+    end
+
+    module InstanceMethods
+      def type
+        @type ||= CustomAttributes::FieldType.find(field_type)
+      end
+
+      # Called upon Customizable Model validation
+      # Actual validation handled by FieldType
+      def validate_custom_value(custom_value)
+        value = custom_value.value
+        errs = type.validate_custom_value(custom_value)
+
+        unless errs.any?
+          if value.is_a?(Array)
+            errs << ::I18n.t('activerecord.errors.messages.invalid') unless multiple?
+            if is_required? && value.detect(&:present?).nil?
+              errs << ::I18n.t('activerecord.errors.messages.blank')
+            end
+          else
+            if is_required? && value.blank?
+              errs << ::I18n.t('activerecord.errors.messages.blank')
+            end
+          end
+        end
+
+        errs
+      end
+
+      # Returns possible *options* that are determined by the *FieldType*
+      # Don't mistake for possible_values, which is a CustomField specific dynamic setting
+      def possible_custom_value_options(custom_value)
+        type.possible_custom_value_options(custom_value)
+      end
+
+      # Validate the CustomField according to type rules and check if the selected default value
+      # is indeed a valid value for this field
+      def validate_custom_field
+        if type.nil?
+          errors.add :default, ::I18n.t('activerecord.errors.messages.invalid_type')
+          return
+        end
+
+        type.validate_custom_field(self).each do |attribute, message|
+          errors.add attribute, message
+        end
+
+        if default.present?
+          validate_field_value(default).each do |message|
+            errors.add :default, message
+          end
+        end
+      end
+
+      # Helper function used in validate_custom_field
+      def validate_field_value(value)
+        validate_custom_value(CustomAttributes::CustomFieldValue.new(custom_field: self, value: value))
+      end
+
+      # Helper function to check if a value is a valid value for this field
+      def valid_field_value?(value)
+        validate_field_value(value).empty?
+      end
+
+      # Used to set the value of CustomFieldValue. No database persistance happening.
+      # A convenient way to override how values are being parsed via FieldType
+      def set_custom_field_value(custom_field_value, value)
+        type.set_custom_field_value(self, custom_field_value, value)
+      end
+
+      # Called after CustomValue has been saved
+      # Overrideable through FieldType
+      def after_save_custom_value(custom_value)
+        type.after_save_custom_value(self, custom_value)
+      end
+
+      # Serializer for possible values attribute
+      def possible_values
+        values = read_attribute(:possible_values)
+        if values.is_a?(Array)
+          values.each do |value|
+            value.to_s.force_encoding('UTF-8')
+          end
+          values
+        else
+          []
+        end
+      end
+
+      # Returns the value in type specific form (Integer, Float, ...)
+      def cast_value(value)
+        type.cast_value(self, value)
+      end
+
+      # Finds a value in a field that has predefined possible values.
+      # Returns array of values if the field supports multiple values
+      # Comma delimited keywords possible
+      def value_from_keyword(keyword, customized)
+        type.value_from_keyword(self, keyword, customized)
+      end
+
+      def field_type=(arg)
+        # cannot change type of a saved custom field
+        if new_record?
+          @type = nil
+          super
+        end
+      end
+
+      def possible_values=(arg)
+        if arg.is_a?(Array)
+          values = arg.compact.map { |a| a.to_s.strip }.reject(&:blank?)
+          write_attribute(:possible_values, values)
+        else
+          self.possible_values = arg.to_s.split(/[\n\r]+/)
+        end
+      end
+
+      protected
+
+      def set_slug
+        self.slug = create_slug
+      end
+
+      def create_slug(iterator = 0)
+        new_slug = name.strip.gsub(/([^A-Za-z0-9])+/) { '_' }.downcase
+
+        new_slug = "#{new_slug}_#{iterator}" unless iterator == 0
+        new_slug = create_slug(iterator += 1) unless CustomField.where(slug: new_slug).count == 0
+        new_slug
+      end
+    end
+  end
+end

data/lib/custom_attributes/acts_as/acts_as_custom_value.rb

@@ -0,0 +1,53 @@
+module CustomAttributes
+  module ActsAsCustomValue
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      def acts_as_custom_value(_options = {})
+        include CustomAttributes::ActsAsCustomValue::InstanceMethods
+
+        belongs_to :custom_field
+        belongs_to :customizable, polymorphic: true
+
+        after_save :custom_field_after_save_custom_value
+      end
+    end
+
+    module InstanceMethods
+      def initialize(attributes = nil, *args)
+        super
+        if new_record? && custom_field && !attributes.key?(:value)
+          self.value ||= custom_field.default
+        end
+      end
+
+      def true?
+        value == '1'
+      end
+
+      def visible?
+        custom_field.visible?
+      end
+
+      def required?
+        custom_field.is_required?
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      private
+
+      # Calls CustomAttributes::FieldType.after_save_custom_value
+      # Thus extendable by FieldType
+      # Default is: do nothing
+      def custom_field_after_save_custom_value
+        custom_field.after_save_custom_value(self)
+      end
+    end
+  end
+end

data/lib/custom_attributes/acts_as/acts_as_customizable.rb

@@ -0,0 +1,216 @@
+module CustomAttributes
+  module ActsAsCustomizable
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      def acts_as_customizable(options = {})
+        cattr_accessor :customizable_options
+
+        self.customizable_options = options
+        has_many :custom_values, -> { includes(:custom_field).order("#{CustomField.table_name}.position") },
+                 as: :customizable,
+                 inverse_of: :customizable,
+                 dependent: :delete_all,
+                 validate: false
+
+        include CustomAttributes::ActsAsCustomizable::InstanceMethods
+
+        validate :validate_custom_field_values
+        after_save :save_custom_field_values
+      end
+
+      # Helper function to index custom values
+      # Use this in mapping context and pass `self` as parameter
+      def index_custom_values(context)
+        return unless context.class.name == 'Elasticsearch::Model::Indexing::Mappings'
+
+        context.indexes :visible_in_search, type: 'boolean'
+        context.indexes :custom_values, type: 'nested' do
+          context.indexes :value, type: 'text', fields: { raw: { type: 'keyword' } }
+          context.indexes :custom_field_id, type: 'integer'
+        end
+      end
+
+      def available_custom_fields
+        CustomField.where("model_type = '#{self.name}CustomField'").sorted.to_a
+      end
+
+      def default_fields
+        []
+      end
+    end
+
+    module InstanceMethods
+      # Set JSON representation in elasticsearch. 
+      # Default is to decorate the models JSON presentation with custom values
+      def use_custom_value_json(hash = {})
+        to_json = {
+          methods: :visible_in_search,
+          include: {
+            custom_values: { 
+              only: %i[custom_field_id value]
+            } 
+          }
+        }.merge(hash)
+        as_json(
+          to_json
+        )
+      end
+
+      # Helper function to access available custom fields from an instance
+      def available_custom_fields
+        self.class.available_custom_fields
+      end
+
+      # Override this to have control over entity visibility in search.
+      # Entities that return false here will be filtered out by default.
+      def visible_in_search
+        true
+      end
+
+      # Sets the values of the object's custom fields
+      # values is an array like [{'id' => 1, 'value' => 'foo'}, {'id' => 2, 'value' => 'bar'}]
+      def assign_custom_values=(values)
+        values_to_hash = values.each_with_object({}) do |v, hash|
+          v = v.stringify_keys
+          hash[v['id']] = v['value'] if v['id'] && v.key?('value')
+        end
+
+        self.custom_field_values = values_to_hash
+      end
+
+      # Sets the values of the object's custom fields
+      # values is a hash like {'1' => 'foo', 2 => 'bar'}
+      def custom_field_values=(values)
+        values = values.stringify_keys
+
+        custom_field_values.each do |custom_field_value|
+          key = custom_field_value.custom_field_id.to_s
+          slug = custom_field_value.custom_field_slug
+
+          if values.key?(key)
+            custom_field_value.value = values[key]
+          elsif values.key?(slug)
+            custom_field_value.value = values[slug]
+          end
+        end
+
+        @custom_field_values_changed = true
+      end
+
+      # Accessor for custom fields, returns array of CustomFieldValues
+      def custom_field_values
+        @custom_field_values ||= available_custom_fields.collect do |field|
+          populate_custom_field_value(field)
+        end
+      end
+
+      def populated_custom_field_value(c)
+        field_id = (c.is_a?(CustomField) ? c.id : c.to_i)
+        field = available_custom_fields.select { |field| field.id == field_id }.first
+
+        return populate_custom_field_value(field) unless field.nil?
+        CustomAttributes::CustomFieldValue.new
+      end
+
+      def populate_custom_field_value(field)
+        x = CustomAttributes::CustomFieldValue.new
+        x.custom_field = field
+        x.customizable = self
+        if field.multiple?
+          values = custom_values.select { |v| v.custom_field == field }
+          if values.empty?
+            values << custom_values.build(customizable: self, custom_field: field)
+          end
+          x.instance_variable_set('@value', values.map(&:value))
+        else
+          cv = custom_values.detect { |v| v.custom_field == field }
+          cv ||= custom_values.build(customizable: self, custom_field: field)
+          x.instance_variable_set('@value', cv.value)
+        end
+        x.value_was = x.value.dup if x.value
+        x
+      end
+
+      def visible_custom_field_values
+        custom_field_values.select(&:visible?)
+      end
+
+      def custom_field_values_changed?
+        @custom_field_values_changed == true
+      end
+
+      # Returns a CustomValue object for the passed CustomField object or ID
+      def custom_value_for(c)
+        field_id = (c.is_a?(CustomField) ? c.id : c.to_i)
+        custom_values.detect { |v| v.custom_field_id == field_id }
+      end
+
+      # Returns the value for the passed CustomField object or ID
+      def custom_field_value(c)
+        field_id = (c.is_a?(CustomField) ? c.id : c.to_i)
+        custom_field_values.detect { |v| v.custom_field_id == field_id }.try(:value)
+      end
+
+      # Extends model validation
+      # 1. Calls .validate_value on each CustomFieldValue
+      # 2. .validate_value calls .validate_custom_value on the CustomField,
+      # 3. which calls the validate_custom_value method on the assigned FieldType.
+      #
+      # The FieldType is therefor responsible for CustomValue validation.
+      def validate_custom_field_values
+        if new_record? || custom_field_values_changed?
+          custom_field_values.each(&:validate_value)
+        end
+      end
+
+      # Called *after* save of the extended model, so validation should already be over.
+      # This method is responsible for persisting the values that have been written to
+      # the CustomFieldValues and handle and save CustomValues correctly.
+      def save_custom_field_values
+        target_custom_values = []
+
+        custom_field_values.each do |custom_field_value|
+          if custom_field_value.value.is_a?(Array)
+            custom_field_value.value.each do |v|
+              target = custom_values.detect { |cv| cv.custom_field == custom_field_value.custom_field && cv.value == v }
+              target ||= custom_values.build(customizable: self, custom_field: custom_field_value.custom_field, value: v)
+              target_custom_values << target
+            end
+          else
+            target = custom_values.detect { |cv| cv.custom_field == custom_field_value.custom_field }
+            target ||= custom_values.build(customizable: self, custom_field: custom_field_value.custom_field)
+            target.value = custom_field_value.value
+            target_custom_values << target
+          end
+        end
+        self.custom_values = target_custom_values
+        custom_values.each(&:save)
+        @custom_field_values_changed = false
+        true
+      end
+
+      def reassign_custom_field_values
+        if @custom_field_values
+          values = @custom_field_values.each_with_object({}) { |v, h| h[v.custom_field_id] = v.value; }
+          @custom_field_values = nil
+          self.custom_field_values = values
+        end
+      end
+
+      def reset_custom_values!
+        @custom_field_values = nil
+        @custom_field_values_changed = true
+      end
+
+      def reload(*args)
+        @custom_field_values = nil
+        @custom_field_values_changed = false
+        super
+      end
+    end
+  end
+end