custom_fields 2.12.1 → 2.13.0

data/lib/custom_fields/field.rb

@@ -1,12 +1,12 @@
-module CustomFields
+# frozen_string_literal: true
 
+module CustomFields
   class Field
-
     include ::Mongoid::Document
     include ::Mongoid::Timestamps
 
-    AVAILABLE_TYPES = %w(default string text email date date_time boolean file select float integer
-       money tags color relationship_default belongs_to has_many many_to_many password json)
+    AVAILABLE_TYPES = %w[default string text email date date_time boolean file select float integer
+                         money tags color relationship_default belongs_to has_many many_to_many password json].freeze
 
     ## types ##
     AVAILABLE_TYPES.each do |type|
@@ -19,14 +19,14 @@ module CustomFields
     field :type
     field :hint
     field :position,  type: ::Integer, default: 0
-    field :required,  type: ::Boolean, default: false
-    field :unique,    type: ::Boolean, default: false
-    field :localized, type: ::Boolean, default: false
+    field :required,  type: 'Boolean', default: false
+    field :unique,    type: 'Boolean', default: false
+    field :localized, type: 'Boolean', default: false
     field :default
 
     ## validations ##
     validates_presence_of   :label, :type
-    validates_exclusion_of  :name, in: lambda { |f| CustomFields.options[:reserved_names].map(&:to_s) }
+    validates_exclusion_of  :name, in: ->(_f) { CustomFields.options[:reserved_names].map(&:to_s) }
     validates_inclusion_of  :type, in: AVAILABLE_TYPES, allow_blank: true
     validates_format_of     :name, with: /^[a-z]([A-Za-z0-9_]+)?$/, multiline: true
     validate                :uniqueness_of_label_and_name
@@ -45,10 +45,10 @@ module CustomFields
     # @return [ Hash ] The memo object upgraded
     #
     def collect_diff(memo)
-      method_name = :"collect_#{self.type}_diff"
+      method_name = :"collect_#{type}_diff"
 
-      if self.respond_to?(method_name)
-        self.send(method_name, memo)
+      if respond_to?(method_name)
+        send(method_name, memo)
       else
         collect_default_diff(memo)
       end
@@ -61,20 +61,28 @@ module CustomFields
     # @return [ Hash ] The hash
     #
     def to_recipe
-      method_name       = :"#{self.type}_to_recipe"
-      custom_to_recipe  = self.send(method_name) rescue {}
-
-      { 'name'      => self.name,
-        'type'      => self.type,
-        'required'  => self.required?,
-        'unique'    => self.unique?,
-        'localized' => self.localized?,
-        'default'   => self.default }.merge(custom_to_recipe)
+      method_name       = :"#{type}_to_recipe"
+      custom_to_recipe  = begin
+        send(method_name)
+      rescue StandardError
+        {}
+      end
+
+      { 'name' => name,
+        'type' => type,
+        'required' => required?,
+        'unique' => unique?,
+        'localized' => localized?,
+        'default' => default }.merge(custom_to_recipe)
     end
 
     def as_json(options = {})
-      method_name     = :"#{self.type}_as_json"
-      custom_as_json  = self.send(method_name) rescue {}
+      method_name     = :"#{type}_as_json"
+      custom_as_json  = begin
+        send(method_name)
+      rescue StandardError
+        {}
+      end
 
       super(options).merge(custom_as_json)
     end
@@ -82,28 +90,23 @@ module CustomFields
     protected
 
     def uniqueness_of_label_and_name
-      if self.siblings.any? { |f| f.label == self.label && f._id != self._id }
-        self.errors.add(:label, :taken)
-      end
+      errors.add(:label, :taken) if siblings.any? { |f| f.label == label && f._id != _id }
 
-      if self.siblings.any? { |f| f.name == self.name && f._id != self._id }
-        self.errors.add(:name, :taken)
-      end
+      return unless siblings.any? { |f| f.name == name && f._id != _id }
+
+      errors.add(:name, :taken)
     end
 
     def set_name
-      return if self.label.blank? && self.name.blank?
+      return if label.blank? && name.blank?
 
-      if self.name.blank?
-        self.name = self.label.parameterize(separator: '_').gsub('-', '_').downcase
-      end
+      return unless name.blank?
+
+      self.name = ActiveSupport::Inflector.parameterize(label, separator: '_').gsub('-', '_').downcase
     end
 
     def siblings
-      # binding.pry
-      self._parent.send(self.relation_metadata.name)
+      _parent.send(association_name)
     end
-
   end
-
 end

data/lib/custom_fields/source.rb

@@ -1,7 +1,7 @@
-module CustomFields
+# frozen_string_literal: true
 
+module CustomFields
   module Source
-
     extend ActiveSupport::Concern
 
     included do
@@ -35,9 +35,9 @@ module CustomFields
     #
     def klass_with_custom_fields(name)
       # Rails.logger.debug "[CustomFields] klass_with_custom_fields #{self.send(name).metadata.klass} / #{self.send(name).metadata[:old_klass]}" if defined?(Rails) # DEBUG
-      recipe    = self.custom_fields_recipe_for(name)
-      _metadata = self.send(name).relation_metadata
-      target    = _metadata[:original_klass] || _metadata.klass # avoid to use an already enhanced klass
+      recipe    = custom_fields_recipe_for(name)
+      _metadata = send(name)._association
+      target    = _metadata.options[:original_klass] || _metadata.klass # avoid to use an already enhanced klass
       target.klass_with_custom_fields(recipe)
     end
 
@@ -51,7 +51,7 @@ module CustomFields
     # @return [ Collection ] The ordered list.
     #
     def ordered_custom_fields(name)
-      self.send(:"#{name}_custom_fields").sort { |a, b| (a.position || 0) <=> (b.position || 0) }
+      send(:"#{name}_custom_fields").sort { |a, b| (a.position || 0) <=> (b.position || 0) }
     end
 
     # Returns the recipe (meaning all the rules) needed to
@@ -63,10 +63,10 @@ module CustomFields
     #
     def custom_fields_recipe_for(name)
       {
-        'name'     => "#{self.relations[name.to_s].class_name.demodulize}#{self._id}",
-        'rules'    => self.ordered_custom_fields(name).map(&:to_recipe),
-        'version'  => self.custom_fields_version(name),
-        'model_name' => self.relations[name.to_s].class_name.constantize.model_name.to_s
+        'name' => "#{relations[name.to_s].class_name.demodulize}#{_id}",
+        'rules' => ordered_custom_fields(name).map(&:to_recipe),
+        'version' => custom_fields_version(name),
+        'model_name' => relations[name.to_s].class_name.constantize.model_name.to_s
       }
     end
 
@@ -77,7 +77,7 @@ module CustomFields
     # @return [ Integer ] The version number
     #
     def custom_fields_version(name)
-      self.send(:"#{name}_custom_fields_version") || 0
+      send(:"#{name}_custom_fields_version") || 0
     end
 
     # When the fields have been modified and before the object is saved,
@@ -86,8 +86,8 @@ module CustomFields
     # @param [ String, Symbol ] name The name of the relation.
     #
     def bump_custom_fields_version(name)
-      version = self.custom_fields_version(name) + 1
-      self.send(:"#{name}_custom_fields_version=", version)
+      version = custom_fields_version(name) + 1
+      send(:"#{name}_custom_fields_version=", version)
     end
 
     # Change the metadata of a relation enhanced by the custom fields.
@@ -96,21 +96,22 @@ module CustomFields
     # @param [ String, Symbol ] name The name of the relation.
     #
     def refresh_metadata_with_custom_fields(name)
-      return if !self.persisted? || self.send(:"#{name}_custom_fields").blank? # do not generate a klass without all the information
+      return if !persisted? || send(:"#{name}_custom_fields").blank?
 
-      old_metadata = self.send(name).relation_metadata
+      old_metadata = send(name)._association
 
       # puts "old_metadata = #{old_metadata.klass.inspect} / #{old_metadata.object_id.inspect}" # DEBUG
 
       # puts "[CustomFields] refresh_metadata_with_custom_fields, #{name.inspect}, self = #{self.inspect}"
 
-      self.send(name).__metadata = old_metadata.clone.tap do |metadata|
+      send(name)._association = old_metadata.clone.tap do |metadata|
         # Rails.logger.debug "[CustomFields] refresh_metadata_with_custom_fields #{metadata.klass}" if defined?(Rails) # DEBUG
 
         # backup the current klass
-        metadata[:original_klass] ||= metadata.klass
+        metadata.instance_variable_set(:@options, metadata.options.dup)
+        metadata.options[:original_klass] ||= metadata.klass
 
-        metadata.instance_variable_set(:@klass, self.klass_with_custom_fields(name))
+        metadata.instance_variable_set(:@klass, klass_with_custom_fields(name))
       end
       set_attribute_localization(name)
       # puts "new_metadata = #{self.send(name).metadata.klass.inspect} / #{self.send(name).metadata.object_id.inspect}" # DEBUG
@@ -118,9 +119,9 @@ module CustomFields
 
     def set_attribute_localization(name)
       klass_name = name.singularize.to_sym
-      self.send(:"#{name}_custom_fields").each do |cf|
+      send(:"#{name}_custom_fields").each do |cf|
         I18n.backend.store_translations ::I18n.locale,
-                          {mongoid: { attributes: {klass_name => {cf.name.to_sym => cf.label}}}}
+                                        { mongoid: { attributes: { klass_name => { cf.name.to_sym => cf.label } } } }
       end
     end
 
@@ -145,7 +146,7 @@ module CustomFields
     def collect_custom_fields_diff(name, fields)
       # puts "==> collect_custom_fields_diff for #{name}, #{fields.size}" # DEBUG
 
-      memo = self.initialize_custom_fields_diff(name)
+      memo = initialize_custom_fields_diff(name)
 
       fields.map do |field|
         field.collect_diff(memo)
@@ -169,12 +170,13 @@ module CustomFields
       # puts "==> apply_custom_fields_recipes for #{name}, #{self._custom_fields_diff[name].inspect}" # DEBUG
 
       operations = self._custom_fields_diff[name]
-      operations['$set'].merge!({ 'custom_fields_recipe.version' => self.custom_fields_version(name) })
-      collection, selector = self.send(name).collection, self.send(name).criteria.selector
+      operations['$set'].merge!({ 'custom_fields_recipe.version' => custom_fields_version(name) })
+      collection = send(name).collection
+      selector = send(name).criteria.selector
 
       # http://docs.mongodb.org/manual/reference/method/db.collection.update/#update-parameter
       # The <update> document must contain only update operator expressions.
-      %w(set unset rename).each do |operation_name|
+      %w[set unset rename].each do |operation_name|
         _fields = operations.delete("$#{operation_name}")
 
         next if _fields.empty?
@@ -195,31 +197,30 @@ module CustomFields
     def apply_custom_fields_localize_diff(name)
       return if self._custom_field_localize_diff[name].empty?
 
-      self.send(name).all.each do |record|
+      send(name).all.each do |record|
         updates = {}
 
         # puts "[apply_custom_fields_localize_diff] processing: record #{record._id} / #{self._custom_field_localize_diff[name].inspect}" # DEBUG
         self._custom_field_localize_diff[name].each do |changes|
+          value = record.attributes[changes[:field]]
           if changes[:localized]
-            value = record.read_attribute(changes[:field].to_sym)
             updates[changes[:field]] = { Mongoid::Fields::I18n.locale.to_s => value }
           else
             # the other way around
-            value = record.read_attribute(changes[:field].to_sym)
             next if value.nil?
+
             updates[changes[:field]] = value[Mongoid::Fields::I18n.locale.to_s]
           end
         end
 
         next if updates.empty?
 
-        collection = self.send(name).collection
+        collection = send(name).collection
         collection.find(record.atomic_selector).update_one({ '$set' => updates })
       end
     end
 
     module ClassMethods
-
       # Determines if the relation is enhanced by the custom fields
       #
       # @example the Person class has somewhere in its code this: "custom_fields_for :addresses"
@@ -230,7 +231,7 @@ module CustomFields
       # @return [ true, false ] True if enhanced, false if not.
       #
       def custom_fields_for?(name)
-        self._custom_fields_for.include?(name.to_s)
+        _custom_fields_for.include?(name.to_s)
       end
 
       # Enhance a referenced collection OR the instance itself (by passing self) by providing methods to manage custom fields.
@@ -253,12 +254,12 @@ module CustomFields
       #   company.employees.build name: 'Michael Scott', position: 'Regional manager'
       #
       def custom_fields_for(name)
-        self.declare_embedded_in_definition_in_custom_field(name)
+        declare_embedded_in_definition_in_custom_field(name)
 
         # stores the relation name
-        self._custom_fields_for << name.to_s
+        _custom_fields_for << name.to_s
 
-        self.extend_for_custom_fields(name)
+        extend_for_custom_fields(name)
       end
 
       protected
@@ -272,12 +273,12 @@ module CustomFields
         class_eval do
           field :"#{name}_custom_fields_version", type: ::Integer, default: 0
 
-          embeds_many :"#{name}_custom_fields", class_name: self.dynamic_custom_field_class_name(name) #, cascade_callbacks: true # FIXME ?????
+          embeds_many :"#{name}_custom_fields", class_name: dynamic_custom_field_class_name(name) # , cascade_callbacks: true # FIXME ?????
 
           accepts_nested_attributes_for :"#{name}_custom_fields", allow_destroy: true
         end
 
-        class_eval <<-EOV
+        class_eval <<-EOV, __FILE__, __LINE__ + 1
           after_initialize  :refresh_#{name}_metadata
           before_update     :bump_#{name}_custom_fields_version
           before_update     :collect_#{name}_custom_fields_diff
@@ -334,21 +335,22 @@ module CustomFields
       # @return [ Field ] The new field class.
       #
       def declare_embedded_in_definition_in_custom_field(name)
-        klass_name = self.dynamic_custom_field_class_name(name).split('::').last # Use only the class, ignore the modules
+        klass_name = dynamic_custom_field_class_name(name).split('::').last # Use only the class, ignore the modules
 
-        source = self.parents.size > 1 ? self.parents.first : Object
+        source = safe_module_parents.size > 1 ? safe_module_parents.first : Object
 
-        unless source.const_defined?(klass_name)
-          (klass = Class.new(::CustomFields::Field)).class_eval <<-EOF
+        return if source.const_defined?(klass_name)
+
+        (klass = Class.new(::CustomFields::Field)).class_eval <<-EOF, __FILE__, __LINE__ + 1
             embedded_in :#{self.name.demodulize.underscore}, inverse_of: :#{name}_custom_fields, class_name: '#{self.name}'
-          EOF
+        EOF
 
-          source.const_set(klass_name, klass)
-        end
+        source.const_set(klass_name, klass)
       end
 
+      def safe_module_parents
+        respond_to?(:module_parents) ? module_parents : parents
+      end
     end
-
   end
-
 end

data/lib/custom_fields/target.rb

@@ -1,15 +1,14 @@
-module CustomFields
+# frozen_string_literal: true
 
+module CustomFields
   module Target
-
     extend ActiveSupport::Concern
 
     included do
-
       ## types ##
-      %w(default string text email date date_time boolean file select
-        float integer money color belongs_to has_many many_to_many
-        tags password json).each do |type|
+      %w[default string text email date date_time boolean file select
+         float integer money color belongs_to has_many many_to_many
+         tags password json].each do |type|
         include "CustomFields::Types::#{type.camelize}::Target".constantize
       end
 
@@ -20,7 +19,6 @@ module CustomFields
     end
 
     module ClassMethods
-
       # A document with custom fields always returns true.
       #
       # @return [ Boolean ] True
@@ -39,7 +37,7 @@ module CustomFields
       def build_klass_with_custom_fields(recipe)
         name = recipe['name']
         # puts "CREATING #{name}, #{recipe.inspect}" # DEBUG
-        parent.const_set(name, Class.new(self)).tap do |klass|
+        safe_module_parent.const_set(name, Class.new(self)).tap do |klass|
           klass.cattr_accessor :version
 
           klass.version = recipe['version']
@@ -49,10 +47,10 @@ module CustomFields
           # klass.write_inheritable_attribute(:scopes, self.scopes)
 
           recipe['rules'].each do |rule|
-            self.send(:"apply_#{rule['type']}_custom_field", klass, rule)
+            send(:"apply_#{rule['type']}_custom_field", klass, rule)
           end
           recipe_model_name = recipe['model_name']
-          model_name = Proc.new do
+          model_name = proc do
             if recipe_model_name.is_a?(ActiveModel::Name)
               recipe_model_name
             else
@@ -93,8 +91,9 @@ module CustomFields
         klass
       end
 
+      def safe_module_parent
+        respond_to?(:module_parent) ? module_parent : parent
+      end
     end
-
   end
-
 end

data/lib/custom_fields/target_helpers.rb

@@ -1,7 +1,7 @@
-module CustomFields
+# frozen_string_literal: true
 
+module CustomFields
   module TargetHelpers
-
     # Return the list of the getters dynamically based on the
     # custom_fields recipe in order to get the formatted values
     # of the custom fields.
@@ -18,8 +18,8 @@ module CustomFields
     # @return [ List ] a list of method names (string)
     #
     def custom_fields_methods(&filter)
-      self.custom_fields_recipe['rules'].map do |rule|
-        method = self.custom_fields_getters_for rule['name'], rule['type']
+      custom_fields_recipe['rules'].map do |rule|
+        method = custom_fields_getters_for rule['name'], rule['type']
         if block_given?
           filter.call(rule) ? method : nil
         else
@@ -34,7 +34,7 @@ module CustomFields
     # @return [ List ] a list of method names (string)
     #
     def custom_fields_safe_setters
-      self.custom_fields_recipe['rules'].map do |rule|
+      custom_fields_recipe['rules'].map do |rule|
         case rule['type'].to_sym
         when :date, :date_time, :money  then "formatted_#{rule['name']}"
         when :file                      then [rule['name'], "remove_#{rule['name']}", "remote_#{rule['name']}_url"]
@@ -54,8 +54,9 @@ module CustomFields
     #
     def custom_fields_basic_attributes
       {}.tap do |hash|
-        self.non_relationship_custom_fields.each do |rule|
-          name, type = rule['name'], rule['type'].to_sym
+        non_relationship_custom_fields.each do |rule|
+          name = rule['name']
+          type = rule['type'].to_sym
 
           # method of the custom getter
           method_name = "#{type}_attribute_get"
@@ -71,8 +72,9 @@ module CustomFields
     # @param [ Hash ] The attributes for the custom fields and their related fields.
     #
     def custom_fields_basic_attributes=(attributes)
-      self.non_relationship_custom_fields.each do |rule|
-        name, type = rule['name'], rule['type'].to_sym
+      non_relationship_custom_fields.each do |rule|
+        name = rule['name']
+        type = rule['type'].to_sym
 
         # method of the custom getter
         method_name = "#{type}_attribute_set"
@@ -89,7 +91,7 @@ module CustomFields
     # @return [ Boolean ] True if the rule is a "many" relationship kind.
     #
     def is_a_custom_field_many_relationship?(name)
-      rule = self.custom_fields_recipe['rules'].detect do |rule|
+      rule = custom_fields_recipe['rules'].detect do |rule|
         rule['name'] == name && _custom_field_many_relationship?(rule['type'])
       end
     end
@@ -99,8 +101,8 @@ module CustomFields
     # @return [ Array ] List of rules (Hash)
     #
     def non_relationship_custom_fields
-      self.custom_fields_recipe['rules'].find_all do |rule|
-        !%w(belongs_to has_many many_to_many).include?(rule['type'])
+      custom_fields_recipe['rules'].find_all do |rule|
+        !%w[belongs_to has_many many_to_many].include?(rule['type'])
       end
     end
 
@@ -109,8 +111,8 @@ module CustomFields
     # @return [ Array ] List of rules (Hash)
     #
     def relationship_custom_fields
-      self.custom_fields_recipe['rules'].find_all do |rule|
-        %w(belongs_to has_many many_to_many).include?(rule['type'])
+      custom_fields_recipe['rules'].find_all do |rule|
+        %w[belongs_to has_many many_to_many].include?(rule['type'])
       end
     end
 
@@ -173,20 +175,16 @@ module CustomFields
       end
     end
 
-    #:nodoc:
+    # :nodoc:
     def _custom_field_many_relationship?(type)
-      %w(has_many many_to_many).include?(type)
+      %w[has_many many_to_many].include?(type)
     end
 
-    #:nodoc:
+    # :nodoc:
     def group_custom_fields(type, &block)
-      unless block_given?
-        block = lambda { |rule| rule['name'] }
-      end
+      block = ->(rule) { rule['name'] } unless block_given?
 
-      self.custom_fields_recipe['rules'].find_all { |rule| rule['type'] == type }.map(&block)
+      custom_fields_recipe['rules'].find_all { |rule| rule['type'] == type }.map(&block)
     end
-
   end
-
 end

data/lib/custom_fields/types/belongs_to.rb

@@ -1,33 +1,26 @@
-module CustomFields
+# frozen_string_literal: true
 
+module CustomFields
   module Types
-
     module BelongsTo
-
       module Field
-
         extend ActiveSupport::Concern
 
         included do
-
           def belongs_to_to_recipe
-            { 'class_name' => self.class_name, 'inverse_of' => self.inverse_of }
+            { 'class_name' => class_name, 'inverse_of' => inverse_of }
           end
 
           def belongs_to_is_relationship?
-            self.type == 'belongs_to'
+            type == 'belongs_to'
           end
-
         end
-
       end
 
       module Target
-
         extend ActiveSupport::Concern
 
         module ClassMethods
-
           # Adds a belongs_to relationship between 2 models
           #
           # @param [ Class ] klass The class to modify
@@ -43,26 +36,19 @@ module CustomFields
             klass.field position_name, type: ::Integer, default: 0
 
             options = { class_name: rule['class_name'], optional: true }
-            options[:inverse_of] = rule['inverse_of'] unless rule['inverse_of'].blank? # an empty String can cause weird behaviours
+            options[:inverse_of] = rule['inverse_of'] unless rule['inverse_of'].blank?
 
             klass.belongs_to rule['name'].to_sym, options
 
-            if rule['required']
-              klass.validates_presence_of rule['name'].to_sym
-            end
+            klass.validates_presence_of rule['name'].to_sym if rule['required']
 
             klass.before_create do |object|
               position = (object.class.max(position_name.to_sym) || 0) + 1
               object.send(:"#{position_name}=", position)
             end
           end
-
         end
-
       end
-
     end
-
   end
-
 end

data/lib/custom_fields/types/boolean.rb

@@ -1,24 +1,22 @@
-module CustomFields
+# frozen_string_literal: true
 
+module CustomFields
   module Types
-
     module Boolean
-
       module Field; end
 
       module Target
-
         extend ActiveSupport::Concern
 
         module ClassMethods
-
           # Adds a boolean field. It can not be required.
           #
           # @param [ Class ] klass The class to modify
           # @param [ Hash ] rule It contains the name of the field.
           #
           def apply_boolean_custom_field(klass, rule)
-            klass.field rule['name'], type: ::Boolean, localize: rule['localized'] || false, default: rule['default'].nil? ? false : rule['default']
+            klass.field rule['name'], type: 'Boolean', localize: rule['localized'] || false,
+                                      default: rule['default'].nil? ? false : rule['default']
           end
 
           # Build a hash storing the boolean value (true / false) for
@@ -41,15 +39,10 @@ module CustomFields
           # @param [ Hash ] attributes The attributes used to fetch the values
           #
           def boolean_attribute_set(instance, name, attributes)
-            self.default_attribute_set(instance, name, attributes)
+            default_attribute_set(instance, name, attributes)
           end
-
         end
-
       end
-
     end
-
   end
-
 end