custom_fields 2.12.1 → 2.13.0

data/lib/custom_fields/types/json.rb

@@ -1,17 +1,15 @@
-module CustomFields
+# frozen_string_literal: true
 
+require 'English'
+module CustomFields
   module Types
-
     module Json
-
       module Field; end
 
       module Target
-
         extend ActiveSupport::Concern
 
         module ClassMethods
-
           # Adds a json field
           #
           # @param [ Class ] klass The class to modify
@@ -39,7 +37,7 @@ module CustomFields
           # @return [ Hash ] field name => JSON
           #
           def json_attribute_get(instance, name)
-            self.default_attribute_get(instance, name)
+            default_attribute_get(instance, name)
           end
 
           # Set the value for the instance and the date field specified by
@@ -50,44 +48,35 @@ module CustomFields
           # @param [ Hash ] attributes The attributes used to fetch the values
           #
           def json_attribute_set(instance, name, attributes)
-            self.default_attribute_set(instance, name, attributes)
+            default_attribute_set(instance, name, attributes)
           end
-
         end
 
         protected
 
         def decode_json(name, json)
-          begin
-            value = json.respond_to?(:to_str) && !json.blank? ? ActiveSupport::JSON.decode(URI.unescape(json)) : json
-            value = nil if json.blank?
+          value = json.respond_to?(:to_str) && !json.blank? ? ActiveSupport::JSON.decode(URI.decode_www_form_component(json)) : json
+          value = nil if json.blank?
 
-            # Only hashes are accepted
-            if value && !value.is_a?(Hash)
-              raise ActiveSupport::JSON.parse_error.new('Only a Hash object is accepted')
-            end
+          # Only hashes are accepted
+          raise ActiveSupport::JSON.parse_error, 'Only a Hash object is accepted' if value && !value.is_a?(Hash)
 
-            instance_variable_set(:"@#{name}_json_parsing_error", nil)
-            value
-          rescue ActiveSupport::JSON.parse_error
-            instance_variable_set(:"@#{name}_json_parsing_error", $!.message)
-            nil
-          end
+          instance_variable_set(:"@#{name}_json_parsing_error", nil)
+          value
+        rescue ActiveSupport::JSON.parse_error
+          instance_variable_set(:"@#{name}_json_parsing_error", $ERROR_INFO.message)
+          nil
         end
 
         def add_json_parsing_error(name)
           error = instance_variable_get(:"@#{name}_json_parsing_error")
 
-          if error
-            msg = "Invalid #{name}: \"#{error}\". Check it out on http://jsonlint.com"
-            self.errors.add(name, msg)
-          end
-        end
+          return unless error
 
+          msg = "Invalid #{name}: \"#{error}\". Check it out on http://jsonlint.com"
+          errors.add(name, msg)
+        end
       end
-
     end
-
   end
-
 end

data/lib/custom_fields/types/many_to_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CustomFields
   module Types
     module ManyToMany
@@ -6,11 +8,11 @@ module CustomFields
 
         included do
           def many_to_many_to_recipe
-            { 'class_name' => self.class_name, 'inverse_of' => self.inverse_of, 'order_by' => self.order_by }
+            { 'class_name' => class_name, 'inverse_of' => inverse_of, 'order_by' => order_by }
           end
 
           def many_to_many_is_relationship?
-            self.type == 'many_to_many'
+            type == 'many_to_many'
           end
         end
       end
@@ -19,7 +21,6 @@ module CustomFields
         extend ActiveSupport::Concern
 
         module ClassMethods
-
           # Adds a many_to_many relationship between 2 mongoid models
           #
           # @param [ Class ] klass The class to modify
@@ -28,10 +29,10 @@ module CustomFields
           def apply_many_to_many_custom_field(klass, rule)
             # puts "#{klass.inspect}.many_to_many #{rule['name'].inspect}, class_name: #{rule['class_name'].inspect} / #{rule['order_by']}" # DEBUG
 
-            klass.has_and_belongs_to_many rule['name'], class_name: rule['class_name'], inverse_of: rule['inverse_of'], validate: false, order: rule['order_by'] do
-
+            klass.has_and_belongs_to_many rule['name'], class_name: rule['class_name'], inverse_of: rule['inverse_of'],
+                                                        validate: false, order: rule['order_by'] do
               def filtered(conditions = {}, order_by = nil)
-                list = conditions.empty? ? self : self.where(conditions)
+                list = conditions.empty? ? self : where(conditions)
 
                 if order_by
                   list.order_by(order_by)
@@ -40,17 +41,17 @@ module CustomFields
                 end
               end
 
-              alias :ordered :filtered # backward compatibility + semantic purpose
+              alias_method :ordered, :filtered # backward compatibility + semantic purpose
 
-              def _naturally_ordered(criteria, order_by = nil)
+              def _naturally_ordered(criteria, _order_by = nil)
                 # use the natural order given by the initial array (ex: project_ids).
                 # Warning: it returns an array and not a criteria object meaning it breaks the chain
-                ids = base.send(relation_metadata.key.to_sym)
+                ids = _base.send(_association.name.to_sym)
                 criteria.entries.sort { |a, b| ids.index(a.id) <=> ids.index(b.id) }
               end
 
               def pluck_with_natural_order(*attributes)
-                criteria = self.only([:_id] + [*attributes])
+                criteria = only([:_id] + [*attributes])
                 _naturally_ordered(criteria).map do |entry|
                   if attributes.size == 1
                     entry.public_send(attributes.first.to_sym)
@@ -59,20 +60,14 @@ module CustomFields
                   end
                 end
               end
-
             end
 
-            if rule['required']
-              klass.validates_collection_size_of rule['name'], minimum: 1, message: :at_least_one_element
-            end
-          end
+            return unless rule['required']
 
+            klass.validates_collection_size_of rule['name'], minimum: 1, message: :at_least_one_element
+          end
         end
-
       end
-
     end
-
   end
-
 end

data/lib/custom_fields/types/money.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
+require 'English'
+
 module CustomFields
   module Types
     module Money
-
       module Field
         extend ActiveSupport::Concern
 
@@ -10,7 +13,7 @@ module CustomFields
           # to provide another currency instead of the the default
           # e.g. default is 'EUR' and User sets '100.11 USD'
           field :default_currency
-          field :allow_currency_from_symbol, type: ::Boolean, default: false
+          field :allow_currency_from_symbol, type: 'Boolean', default: false
 
           before_validation :set_default
 
@@ -23,26 +26,22 @@ module CustomFields
           def check_currency
             ::Money::Currency.find(self.default_currency)
           end
-
-        end # included
+        end
 
         def money_to_recipe
           { 'default_currency' => self.default_currency,
-            'allow_currency_from_symbol' => self.allow_currency_from_symbol }
+            'allow_currency_from_symbol' => allow_currency_from_symbol }
         end
 
-        def money_as_json(options = {})
+        def money_as_json(_options = {})
           money_to_recipe
         end
-
-      end # module Field
-
+      end
 
       module Target
         extend ActiveSupport::Concern
 
         module ClassMethods
-
           # Adds a Money field
           #
           # uses the money gem (https://github.com/RubyMoney/money)
@@ -54,16 +53,15 @@ module CustomFields
           # and the currency
 
           def apply_money_custom_field(klass, rule)
-
             # the field names
             name = rule['name']
             names = {
-              name:                       name.to_sym,
-              cents_field:                "#{name}_cents".to_sym,
-              currency_field:             "#{name}_currency".to_sym,
-              formatted_name_field:       "formatted_#{name}".to_sym,
+              name: name.to_sym,
+              cents_field: "#{name}_cents".to_sym,
+              currency_field: "#{name}_currency".to_sym,
+              formatted_name_field: "formatted_#{name}".to_sym,
               allow_currency_from_symbol: "#{name}_allow_currency_from_symbol".to_sym,
-              default_currency:           "#{name}_default_currency".to_sym
+              default_currency: "#{name}_default_currency".to_sym
             }
 
             # fields
@@ -84,7 +82,6 @@ module CustomFields
             klass.validate { _check_money(names) } if rule['required']
             klass.validates_presence_of(names[:cents_field], names[:currency_field]) if rule['required']
             klass.validates_numericality_of names[:cents_field], only_integer: true, if: names[:cents_field]
-
           end
 
           def money_attribute_get(instance, name)
@@ -95,51 +92,53 @@ module CustomFields
             end
           end
 
-         def money_attribute_set(instance, name, attributes)
+          def money_attribute_set(instance, name, attributes)
             return unless attributes.key?(name) || attributes.key?("formatted_#{name}")
+
             value = attributes[name] || attributes["formatted_#{name}"]
             instance.send(:"formatted_#{name}=", value)
           end
-
-
         end
 
         protected
 
         def _set_money_defaults(names)
-          ::Monetize.assume_from_symbol = self.send(names[:allow_currency_from_symbol])
-          ::Money.default_currency = self.send(names[:default_currency])
+          ::Monetize.assume_from_symbol = send(names[:allow_currency_from_symbol])
+          ::Money.default_currency = send(names[:default_currency])
         end
 
         def _get_money(names)
           _set_money_defaults(names)
-          ::Money.new(self.read_attribute(names[:cents_field]), self.read_attribute(names[:currency_field]) || ::Money.default_currency)
+          ::Money.new(read_attribute(names[:cents_field]),
+                      read_attribute(names[:currency_field]) || ::Money.default_currency)
         end
 
         def _check_money(names)
-          if [nil, ''].include? self.read_attribute.names[:cents_field]
-            raise ArgumentError.new 'Unrecognized amount'
-          end
+          raise ArgumentError, 'Unrecognized amount' if [nil, ''].include? read_attribute.names[:cents_field]
+
           _get_money(names)
-        rescue
-          self.errors.add(names[:name], "#{$!}")
+        rescue StandardError
+          errors.add(names[:name], $ERROR_INFO.to_s)
           false
         end
 
         def _set_money(_money, names)
           return if _money.blank?
+
           _set_money_defaults(names)
-          money = _money.kind_of?(Money) ? _money : ::Monetize.parse(_money)
-          self.write_attribute(names[:cents_field], money.cents)
-          self.write_attribute(names[:currency_field], money.currency.iso_code)
-        rescue
-          self.errors.add(names[:name], "#{$!}")
+          money = _money.is_a?(Money) ? _money : ::Monetize.parse(_money)
+          write_attribute(names[:cents_field], money.cents)
+          write_attribute(names[:currency_field], money.currency.iso_code)
+        rescue StandardError
+          errors.add(names[:name], $ERROR_INFO.to_s)
         end
 
         def _get_formatted_money(names)
-          _get_money(names).format(symbol: self.send(names[:allow_currency_from_symbol]), no_cents_if_whole: true) rescue nil
+          _get_money(names).format(symbol: send(names[:allow_currency_from_symbol]),
+                                   no_cents_if_whole: true)
+        rescue StandardError
+          nil
         end
-
       end
     end
   end

data/lib/custom_fields/types/password.rb

@@ -1,25 +1,24 @@
+# frozen_string_literal: true
+
 module CustomFields
   module Types
     module Password
-
       module Field
-
         MIN_PASSWORD_LENGTH = 6
-
       end
 
       module Target
         extend ActiveSupport::Concern
 
         module ClassMethods
-
           # Add a password field
           #
           # @param [ Class ] klass The class to modify
           # @param [ Hash ] rule It contains the name of the field and if it is required or not
           #
           def apply_password_custom_field(klass, rule)
-            label, name = rule['label'], rule['name']
+            label = rule['label']
+            name = rule['name']
 
             klass.field :"#{name}_hash"
 
@@ -39,7 +38,7 @@ module CustomFields
           #
           # @return [ Hash ] field name => raw value
           #
-          def password_attribute_get(instance, name)
+          def password_attribute_get(_instance, _name)
             {}
           end
 
@@ -53,38 +52,35 @@ module CustomFields
           def password_attribute_set(instance, name, attributes)
             instance._encrypt_password(name, attributes[name])
           end
-
-        end # ClassMethods
+        end
 
         def _set_confirmation_password(name, confirmation)
-          self.instance_variable_set(:"@#{name}_confirmation", confirmation)
+          instance_variable_set(:"@#{name}_confirmation", confirmation)
         end
 
         def _encrypt_password(name, new_password)
           return if new_password.blank?
 
-          self.instance_variable_set(:"@#{name}", new_password)
+          instance_variable_set(:"@#{name}", new_password)
 
-          self.send(:"#{name}_hash=", BCrypt::Password.create(new_password))
+          send(:"#{name}_hash=", BCrypt::Password.create(new_password))
         end
 
         def _check_password(label, name)
-          new_password = self.instance_variable_get(:"@#{name}")
-          confirmation = self.instance_variable_get(:"@#{name}_confirmation")
+          new_password = instance_variable_get(:"@#{name}")
+          confirmation = instance_variable_get(:"@#{name}_confirmation")
 
           return if new_password.blank?
 
           if new_password.size < CustomFields::Types::Password::Field::MIN_PASSWORD_LENGTH
-            self.errors.add(name, :too_short, count: CustomFields::Types::Password::Field::MIN_PASSWORD_LENGTH)
-          end
-
-          if confirmation && confirmation != new_password
-            self.errors.add("#{name}_confirmation", :confirmation, attribute: label || name)
+            errors.add(name, :too_short, count: CustomFields::Types::Password::Field::MIN_PASSWORD_LENGTH)
           end
-        end
 
-      end # Target
+          return unless confirmation && confirmation != new_password
 
-    end # Password
-  end # Types
-end # CustomFields
+          errors.add("#{name}_confirmation", :confirmation, attribute: label || name)
+        end
+      end
+    end
+  end
+end

data/lib/custom_fields/types/relationship_default.rb

@@ -1,15 +1,12 @@
-module CustomFields
+# frozen_string_literal: true
 
+module CustomFields
   module Types
-
     module RelationshipDefault
-
       module Field
-
         extend ActiveSupport::Concern
 
         included do
-
           field :class_name
           field :inverse_of
           field :order_by
@@ -18,8 +15,8 @@ module CustomFields
           validate              :ensure_class_name_security,  if: :is_relationship?
 
           def is_relationship?
-            method_name = :"#{self.type}_is_relationship?"
-            self.respond_to?(method_name) && self.send(method_name)
+            method_name = :"#{type}_is_relationship?"
+            respond_to?(method_name) && send(method_name)
           end
 
           protected
@@ -28,17 +25,8 @@ module CustomFields
             true
             # FIXME: to be overridden in the target application
           end
-
         end
-
       end
-
     end
-
   end
-
 end
-
-
-
-