create_custom_attributes 0.5.0

data/lib/custom_attributes/api/custom_attributes_controller_helper.rb

@@ -0,0 +1,32 @@
+require 'custom_attributes/custom_attributes_api_helper'
+
+module CustomAttributes
+  module ControllerHelper
+    module Customizable
+      def self.all_available_fields(customizable_type)
+        customizable = customizable_type
+        if customizable_type.is_a? String
+          customizable = get_customizable_class_or_fail(customizable_type).new
+        end
+
+        customizable.available_custom_fields
+      end
+
+      def self.all_values(customizable)
+        return customizable.custom_field_values
+      end
+
+      def self.value_by_field_id(customizable, field_id)
+        return customizable.populated_custom_field_value(field_id)
+      end
+
+      def self.update_field_value(customizable, field_id, value)
+        to_change = { field_id => value }
+        customizable.custom_field_values = to_change
+        customizable.save!
+
+        customizable.custom_value_for(field_id)
+      end
+    end
+  end
+end

data/lib/custom_attributes/concerns/searchable.rb

@@ -0,0 +1,64 @@
+require 'elasticsearch/model'
+require 'custom_attributes/fluent_search_query'
+
+module CustomAttributes
+  module Searchable
+    extend ActiveSupport::Concern
+
+    included do
+      include Elasticsearch::Model
+
+      index_name "#{name.downcase.pluralize}-#{Rails.env}"
+
+      # For ActiveRecord-based models, use the after_commit callback to
+      # protect your data against inconsistencies caused by transaction rollbacks
+      if any? { |obj| obj.is_a?(ActiveRecord::Base) }
+        after_commit on: [:create] do
+          index_document_or_fail
+        end
+
+        after_commit on: [:update] do
+          index_document_or_fail
+        end
+
+        after_commit on: [:destroy] do
+          delete_document_or_fail
+        end
+      else
+        # everything else can use the standard implementation
+        include Elasticsearch::Model::Callbacks
+      end
+
+      # helper function to initialize index
+      def self.set_up_search
+        __elasticsearch__.create_index!
+        __elasticsearch__.refresh_index!
+        import
+      end
+
+      # entrypoint for the fluent query builder
+      def self.searchable
+        CustomAttributes::FluentSearchQuery.new new
+      end
+
+      # default connection error handling, override in model!
+      def self.handle_search_connection_error(exception)
+        raise exception
+      end
+
+      private
+
+      def index_document_or_fail
+        __elasticsearch__.index_document
+      rescue Faraday::ConnectionFailed => e
+        handle_search_connection_error(e)
+      end
+
+      def delete_document_or_fail
+        __elasticsearch__.delete_document
+      rescue Faraday::ConnectionFailed => e
+        handle_search_connection_error(e)
+      end
+    end
+  end
+end

data/lib/custom_attributes/custom_attributes_api_helper.rb

@@ -0,0 +1,6 @@
+def get_customizable_class_or_fail(type)
+  model = type.camelize.constantize
+
+  return nil unless model.method_defined? :custom_field_values
+  model
+end

data/lib/custom_attributes/custom_field_value.rb

@@ -0,0 +1,54 @@
+module CustomAttributes
+  # Decorator for CustomValues
+  class CustomFieldValue
+    attr_accessor :custom_field, :customizable, :value, :value_was
+
+    def initialize(attributes = {})
+      attributes.each do |name, v|
+        send "#{name}=", v
+      end
+    end
+
+    def custom_field_id
+      custom_field.id
+    end
+
+    def custom_field_slug
+      custom_field.slug
+    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
+
+    def value=(v)
+      @value = custom_field.set_custom_field_value(self, v)
+    end
+
+    def value_present?
+      if value.is_a?(Array)
+        value.any?(&:present?)
+      else
+        value.present?
+      end
+    end
+
+    def validate_value
+      custom_field.validate_custom_value(self).each do |message|
+        customizable.errors.add(:base, custom_field.name + ' ' + message)
+      end
+    end
+  end
+end

data/lib/custom_attributes/field_type.rb

@@ -0,0 +1,153 @@
+module CustomAttributes
+  class FieldType
+    class_attribute :type_name
+    class_attribute :multiple_supported
+
+    # Defines if this type
+    self.multiple_supported = false
+
+    # Pretty name of the field
+    self.type_name = nil
+
+    def name
+      self.class.type_name
+    end
+
+    def label
+      "label_#{name}"
+    end
+
+    def self.available_types
+      descendants
+    end
+
+    def self.find(name)
+      "CustomAttributes::#{name}FieldType".constantize.instance
+    rescue NameError
+      nil
+    end
+
+    # Validate a CustomValue according to the type roles. This method can  be
+    # overridden by field types if the way bulk handling should happen changes
+    # (e.g. List type)
+    def validate_custom_value(custom_value)
+      # 1. Wrap in Array so we can pass Array of values and single values, reject empty values
+      values = Array.wrap(custom_value.value).reject { |value| value.to_s == '' }
+      # 2. Validate each value
+      errors = values.map do |value|
+        validate_single_value(custom_value.custom_field, value, custom_value.customizable)
+      end
+      errors.flatten.uniq
+    end
+
+    # Override this in subclass to validate custom values
+    def validate_single_value(_custom_field, _value, _customizable = nil)
+      []
+    end
+
+    # Overide this in subclass to validate custom fields
+    def validate_custom_field(_custom_field)
+      []
+    end
+
+    def after_save_custom_value(custom_field, custom_value); end
+
+    def before_custom_field_save(custom_field); end
+
+    # Prepares and sets CustomFieldValues value.
+    def set_custom_field_value(_custom_field, _custom_field_value, value)
+      if value.is_a?(Array)
+        value = value.map(&:to_s).reject { |v| v == '' }.uniq
+        value << '' if value.empty?
+      else
+        value = value.to_s
+      end
+
+      value
+    end
+
+    # Cast the value of an existing CustomValue
+    def cast_custom_value(custom_value)
+      cast_value(custom_value.custom_field, custom_value.value, custom_value.customizable)
+    end
+
+    # Cast the value according to field type rules
+    def cast_value(custom_field, value, customizable = nil)
+      if value.blank?
+        nil
+      elsif value.is_a?(Array)
+        casted = value.map do |v|
+          cast_single_value(custom_field, v, customizable)
+        end
+        casted.compact.sort
+      else
+        cast_single_value(custom_field, value, customizable)
+      end
+    end
+
+    def cast_single_value(_custom_field, value, _customizable = nil)
+      value.to_s
+    end
+
+    # Checks if a keyword is in the possible values and returns the possible value if found
+    # If there are no possible values, returns the keyword
+    def value_from_keyword(custom_field, keyword, object)
+      possible_values_options = possible_values_options(custom_field, object)
+      if possible_values_options.present?
+        parse_keyword(custom_field, keyword) do |k|
+          if v = possible_values_options.detect { |text, _id| k.casecmp(text) == 0 }
+            if v.is_a?(Array)
+              v.last
+            else
+              v
+            end
+          end
+        end
+      else
+        keyword
+      end
+    end
+
+    # Parses keyword, allows comma delimited values
+    def parse_keyword(custom_field, keyword)
+      separator = Regexp.escape ','
+      keyword = keyword.to_s
+
+      if custom_field.multiple?
+        values = []
+        until keyword.empty?
+          k = keyword.dup
+          loop do
+            if value = yield(k.strip)
+              values << value
+              break
+            elsif k.slice!(/#{separator}([^#{separator}]*)\Z/).nil?
+              break
+            end
+          end
+          keyword.slice!(/\A#{Regexp.escape k}#{separator}?/)
+        end
+        values
+      else
+        yield keyword.strip
+      end
+    end
+    protected :parse_keyword
+
+    # Use to get the possible values of a CustomValue
+    def possible_custom_value_options(custom_value)
+      possible_values_options(custom_value.custom_field, custom_value.customizable)
+    end
+
+    # Override this in subclass to specify the possible values for the field with this type
+    def possible_values_options(_custom_field, _object = nil)
+      []
+    end
+
+    # Returns the HTML Tag to edit this field format.
+    def edit_tag(view, tag_id, tag_name, custom_value, options = {})
+      view.text_field_tag(tag_name, custom_value.value, options.merge(id: tag_id))
+    end
+
+  end
+end

data/lib/custom_attributes/field_types/bool_field_type.rb

@@ -0,0 +1,40 @@
+module CustomAttributes
+  class BoolFieldType < List
+    include Singleton
+
+    self.multiple_supported = false
+
+    def label
+      'label_boolean'
+    end
+
+    def cast_single_value(_custom_field, value, _customizable = nil)
+      value == '1'
+    end
+
+    # Boolean supports either True or False as value
+    def possible_values_options(_custom_field, _object = nil)
+      [[::I18n.t(:general_text_Yes), '1'], [::I18n.t(:general_text_No), '0']]
+    end
+
+    # Boolean supports either checkbox, radiobutton or select field as edit tag
+    def edit_tag(view, tag_id, tag_name, custom_value, options = {})
+      case custom_value.custom_field.edit_tag_style
+      when 'check_box'
+        single_check_box_edit_tag(view, tag_id, tag_name, custom_value, options)
+      when 'radio'
+        check_box_edit_tag(view, tag_id, tag_name, custom_value, options)
+      else
+        select_edit_tag(view, tag_id, tag_name, custom_value, options)
+      end
+    end
+
+    # Renders the edit tag as a simple check box
+    def single_check_box_edit_tag(view, tag_id, tag_name, custom_value, options = {})
+      s = ''.html_safe
+      s << view.hidden_field_tag(tag_name, '0', id: nil)
+      s << view.check_box_tag(tag_name, '1', custom_value.value.to_s == '1', id: tag_id)
+      view.content_tag('span', s, options)
+    end
+  end
+end

data/lib/custom_attributes/field_types/date_field_type.rb

@@ -0,0 +1,28 @@
+module CustomAttributes
+  class DateFieldType < Unbounded
+    include Singleton
+
+    def cast_single_value(_custom_field, value, _customized = nil)
+      value.to_date
+    rescue
+      nil
+    end
+
+    def validate_single_value(_custom_field, value, _customizable = nil)
+      if value =~ /^\d{4}-\d{2}-\d{2}$/ && (begin
+                                              value.to_date
+                                            rescue
+                                              false
+                                            end)
+        []
+      else
+        [::I18n.t('activerecord.errors.messages.not_a_date')]
+      end
+    end
+
+    def edit_tag(view, tag_id, tag_name, custom_value, options = {})
+      view.date_field_tag(tag_name, custom_value.value, options.merge(id: tag_id, size: 10)) +
+        view.calendar_for(tag_id)
+    end
+  end
+end

data/lib/custom_attributes/field_types/float_field_type.rb

@@ -0,0 +1,19 @@
+module CustomAttributes
+  class FloatFieldType < Numeric
+    include Singleton
+
+    def cast_single_value(_custom_field, value, _customizable = nil)
+      value.to_f
+    end
+
+    def validate_single_value(custom_field, value, customizable = nil)
+      errs = super
+      errs << ::I18n.t('activerecord.errors.messages.invalid') unless begin
+                                                                          Kernel.Float(value)
+                                                                        rescue
+                                                                          nil
+                                                                        end
+      errs
+    end
+  end
+end

data/lib/custom_attributes/field_types/int_field_type.rb

@@ -0,0 +1,19 @@
+module CustomAttributes
+  class IntFieldType < Numeric
+    include Singleton
+
+    def label
+      "label_integer"
+    end
+
+    def cast_single_value(custom_field, value, customized=nil)
+      value.to_i
+    end
+
+    def validate_single_value(custom_field, value, customizable = nil)
+      errs = super
+      errs << ::I18n.t('activerecord.errors.messages.not_a_number') unless value.to_s =~ /^[+-]?\d+$/
+      errs
+    end
+  end
+end

data/lib/custom_attributes/field_types/list.rb

@@ -0,0 +1,57 @@
+module CustomAttributes
+  class List < FieldType
+    self.multiple_supported = true
+
+    def edit_tag(view, tag_id, tag_name, custom_value, options = {})
+      if custom_value.custom_field.edit_tag_style == 'check_box'
+        check_box_edit_tag(view, tag_id, tag_name, custom_value, options)
+      else
+        select_edit_tag(view, tag_id, tag_name, custom_value, options)
+      end
+    end
+
+    protected
+
+    # Renders the edit tag as a select tag
+    def select_edit_tag(view, tag_id, tag_name, custom_value, options = {})
+      blank_option = ''.html_safe
+      unless custom_value.custom_field.multiple?
+        if custom_value.custom_field.is_required?
+          unless custom_value.custom_field.default_value.present?
+            blank_option = view.content_tag('option', "--- #{::I18n.t('actionview_instancetag_blank_option')} ---", value: '')
+          end
+        else
+          blank_option = view.content_tag('option', '&nbsp;'.html_safe, value: '')
+        end
+      end
+      options_tags = blank_option + view.options_for_select(possible_custom_value_options(custom_value), custom_value.value)
+      s = view.select_tag(tag_name, options_tags, options.merge(id: tag_id, multiple: custom_value.custom_field.multiple?))
+      if custom_value.custom_field.multiple?
+        s << view.hidden_field_tag(tag_name, '')
+      end
+      s
+    end
+
+    # Renders the edit tag as check box or radio tags
+    def check_box_edit_tag(view, _tag_id, tag_name, custom_value, options = {})
+      opts = []
+      unless custom_value.custom_field.multiple? || custom_value.custom_field.is_required?
+        opts << ["(#{::I18n.t('label_none')})", '']
+      end
+      opts += possible_custom_value_options(custom_value)
+      s = ''.html_safe
+      tag_method = custom_value.custom_field.multiple? ? :check_box_tag : :radio_button_tag
+      opts.each do |label, value|
+        value ||= label
+        checked = (custom_value.value.is_a?(Array) && custom_value.value.include?(value)) || custom_value.value.to_s == value
+        tag = view.send(tag_method, tag_name, value, checked, id: nil)
+        s << view.content_tag('label', tag + ' ' + label)
+      end
+      if custom_value.custom_field.multiple?
+        s << view.hidden_field_tag(tag_name, '', id: nil)
+      end
+      css = "#{options[:class]} check_box_group"
+      view.content_tag('span', s, options.merge(class: css))
+    end
+  end
+end