custom_fields 2.1.0 → 2.2.0

data/lib/custom_fields/target.rb

@@ -7,15 +7,15 @@ module CustomFields
     included do
 
       ## types ##
-      %w(default string text date boolean file select belongs_to has_many many_to_many).each do |type|
-        include "CustomFields::Types::#{type.classify}::Target".constantize
+      %w(default string text email date boolean file select float integer money
+         belongs_to has_many many_to_many tags).each do |type|
+        include "CustomFields::Types::#{type.camelize}::Target".constantize
       end
 
       include ::CustomFields::TargetHelpers
 
       ## fields ##
-      field :custom_fields_recipe, :type => Hash
-
+      field :custom_fields_recipe, type: Hash
     end
 
     module ClassMethods
@@ -33,13 +33,11 @@ module CustomFields
       #
       # @param [ Hash ] recipe The recipe describing the fields to add
       #
-      # @return [ Class] the anonymous custom klass
+      # @return [ Class ] the anonymous custom klass
       #
       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|
           klass.cattr_accessor :version
 
@@ -52,6 +50,16 @@ module CustomFields
           recipe['rules'].each do |rule|
             self.send(:"apply_#{rule['type']}_custom_field", klass, rule)
           end
+          recipe_model_name = recipe['model_name']
+          model_name = Proc.new do
+            if recipe_model_name.is_a?(ActiveModel::Name)
+              recipe_model_name
+            else
+              recipe_model_name.constantize.model_name
+            end
+          end
+          klass.send :define_method,           :model_name, model_name
+          klass.send :define_singleton_method, :model_name, model_name
         end
       end
 
@@ -86,4 +94,4 @@ module CustomFields
 
   end
 
-end
+end

data/lib/custom_fields/target_helpers.rb

@@ -36,7 +36,7 @@ module CustomFields
     def custom_fields_safe_setters
       self.custom_fields_recipe['rules'].map do |rule|
         case rule['type'].to_sym
-        when :date                    then "formatted_#{rule['name']}"
+        when :date, :money            then "formatted_#{rule['name']}"
         when :file                    then [rule['name'], "remove_#{rule['name']}"]
         when :select, :belongs_to     then ["#{rule['name']}_id", "position_in_#{rule['name']}"]
         when :has_many, :many_to_many then nil
@@ -164,10 +164,10 @@ module CustomFields
     #
     def custom_fields_getters_for(name, type)
       case type.to_sym
-      when :select      then [name, "#{name}_id"]
-      when :date        then "formatted_#{name}"
-      when :file        then "#{name}_url"
-      when :belongs_to  then "#{name}_id"
+      when :select       then [name, "#{name}_id"]
+      when :date, :money then "formatted_#{name}"
+      when :file         then "#{name}_url"
+      when :belongs_to   then "#{name}_id"
       else
         name
       end
@@ -189,4 +189,4 @@ module CustomFields
 
   end
 
-end
+end

data/lib/custom_fields/types/belongs_to.rb

@@ -34,15 +34,15 @@ module CustomFields
           # @param [ Hash ] rule It contains the name of the field and if it is required or not
           #
           def apply_belongs_to_custom_field(klass, rule)
-            # puts "#{klass.inspect}.belongs_to #{rule['name'].inspect}, :class_name => #{rule['class_name'].inspect}" # DEBUG
+            # puts "#{klass.inspect}.belongs_to #{rule['name'].inspect}, class_name: #{rule['class_name'].inspect}" # DEBUG
 
             position_name = "position_in_#{rule['name'].underscore}"
 
             # puts "#{klass.inspect}.field :#{position_name}" # DEBUG
 
-            klass.field position_name, :type => Integer, :default => 0
+            klass.field position_name, type: ::Integer, default: 0
 
-            klass.belongs_to rule['name'].to_sym, :class_name => rule['class_name']
+            klass.belongs_to rule['name'].to_sym, class_name: rule['class_name']
 
             if rule['required']
               klass.validates_presence_of rule['name'].to_sym
@@ -62,4 +62,4 @@ module CustomFields
 
   end
 
-end
+end

data/lib/custom_fields/types/boolean.rb

@@ -18,7 +18,7 @@ module CustomFields
           # @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 => false
+            klass.field rule['name'], type: ::Boolean, localize: rule['localized'] || false, default: false
           end
 
           # Build a hash storing the boolean value (true / false) for

data/lib/custom_fields/types/date.rb

@@ -20,7 +20,7 @@ module CustomFields
           def apply_date_custom_field(klass, rule)
             name = rule['name']
 
-            klass.field name, :type => ::Date, :localize => rule['localized'] || false
+            klass.field name, type: ::Date, localize: rule['localized'] || false
 
             # other methods
             klass.send(:define_method, :"formatted_#{name}") { _get_formatted_date(name) }
@@ -90,4 +90,4 @@ module CustomFields
 
   end
 
-end
+end

data/lib/custom_fields/types/default.rb

@@ -19,8 +19,8 @@ module CustomFields
             if self.destroyed?
               memo['$unset'][self.name] = 1
             elsif self.changed?
-              if self.changes.key?(:name)
-                old_name, new_name = self.changes[:name]
+              if self.changes.key?('name')
+                old_name, new_name = self.changes['name']
                 memo['$rename'][old_name] = new_name
               end
             end
@@ -47,11 +47,10 @@ module CustomFields
           # @param [ Hash ] rule It contains the name of the field and if it is required or not
           #
           def apply_custom_field(klass, rule)
-            klass.field rule['name'], :localize => rule['localized'] || false
+            klass.field rule['name'], localize: rule['localized'] || false
 
-            if rule['required']
-              klass.validates_presence_of rule['name']
-            end
+            klass.validates_presence_of rule['name'] if rule['required']
+            klass.validates_uniqueness_of rule['name'], scope: :_type if rule['unique']
           end
 
           # Build a hash storing the formatted (or not) values

data/lib/custom_fields/types/email.rb

@@ -0,0 +1,60 @@
+module CustomFields
+
+  module Types
+
+    module Email
+
+      module Field; end
+
+      module Target
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Add a string 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_email_custom_field(klass, rule)
+            name = rule['name']
+
+            klass.field name, type: ::String, localize: rule['localized'] || false
+            klass.validates_presence_of name if rule['required']
+            klass.validates_format_of name, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/, allow_blank: !rule['required']
+            klass.validates_uniqueness_of rule['name'], scope: :_type if rule['unique']
+          end
+
+          # Build a hash storing the raw value for
+          # a string custom field of an instance.
+          #
+          # @param [ Object ] instance An instance of the class enhanced by the custom_fields
+          # @param [ String ] name The name of the string custom field
+          #
+          # @return [ Hash ] field name => raw value
+          #
+          def email_attribute_get(instance, name)
+            self.default_attribute_get(instance, name)
+          end
+
+          # Set the value for the instance and the string field specified by
+          # the 2 params.
+          #
+          # @param [ Object ] instance An instance of the class enhanced by the custom_fields
+          # @param [ String ] name The name of the string custom field
+          # @param [ Hash ] attributes The attributes used to fetch the values
+          #
+          def email_attribute_set(instance, name, attributes)
+            self.default_attribute_set(instance, name, attributes)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/custom_fields/types/file.rb

@@ -39,7 +39,7 @@ module CustomFields
           # @return [ Hash ] field name => url or empty hash if no file
           #
           def file_attribute_get(instance, name)
-            if instance.send(:"#{name}?")
+            if instance.send(:"#{name}?") #"
               value = instance.send(name.to_sym).url
               { name => value, "#{name}_url" => value }
             else
@@ -71,4 +71,4 @@ module CustomFields
 
   end
 
-end
+end

data/lib/custom_fields/types/float.rb

@@ -0,0 +1,52 @@
+module CustomFields
+  module Types
+    module Float
+
+      module Field; end
+
+      module Target
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Add a string 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_float_custom_field(klass, rule)
+            klass.field rule['name'], type: ::Float, localize: rule['localized'] || false
+            klass.validates_presence_of rule['name'] if rule['required']
+            klass.validates rule['name'], numericality: true, if: ->(x){ rule['required'] }
+          end
+
+          # Build a hash storing the raw value for
+          # a string custom field of an instance.
+          #
+          # @param [ Object ] instance An instance of the class enhanced by the custom_fields
+          # @param [ String ] name The name of the string custom field
+          #
+          # @return [ Hash ] field name => raw value
+          #
+          def float_attribute_get(instance, name)
+            self.default_attribute_get(instance, name)
+          end
+
+          # Set the value for the instance and the string field specified by
+          # the 2 params.
+          #
+          # @param [ Object ] instance An instance of the class enhanced by the custom_fields
+          # @param [ String ] name The name of the string custom field
+          # @param [ Hash ] attributes The attributes used to fetch the values
+          #
+          def float_attribute_set(instance, name, attributes)
+            self.default_attribute_set(instance, name, attributes)
+          end
+
+        end # ClassMethods
+
+      end # Target
+
+    end # Float
+  end # Types
+end # CustomFields

data/lib/custom_fields/types/has_many.rb

@@ -34,14 +34,13 @@ module CustomFields
           # @param [ Hash ] rule It contains the name of the relation and if it is required or not
           #
           def apply_has_many_custom_field(klass, rule)
-            # puts "#{klass.inspect}.has_many #{rule['name'].inspect}, :class_name => #{rule['class_name'].inspect}, :inverse_of => #{rule['inverse_of']}" # DEBUG
-
+            # puts "#{klass.inspect}.has_many #{rule['name'].inspect}, class_name: #{rule['class_name'].inspect}, inverse_of: #{rule['inverse_of']}" # DEBUG
             position_name = "position_in_#{rule['inverse_of']}"
 
             _order_by   = rule['order_by'] || position_name.to_sym.asc
             _inverse_of = rule['inverse_of'].blank? ? nil : rule['inverse_of'] # an empty String can cause weird behaviours
 
-            klass.has_many rule['name'], :class_name => rule['class_name'], :inverse_of => _inverse_of, :order => _order_by do
+            klass.has_many rule['name'], class_name: rule['class_name'], inverse_of: _inverse_of, order: _order_by do
 
               def filtered(conditions = {}, order_by = nil)
                 list = conditions.empty? ? self : self.where(conditions)
@@ -49,8 +48,7 @@ module CustomFields
                 if order_by
                   list.order_by(order_by)
                 else
-                  # calling all on a has_many relationship makes us lose the default order_by (mongoid bug ?)
-                  list.order(metadata.order)
+                  list.order_by(metadata.order)
                 end
               end
 
@@ -58,10 +56,10 @@ module CustomFields
 
             end
 
-            klass.accepts_nested_attributes_for rule['name'], :allow_destroy => true
+            klass.accepts_nested_attributes_for rule['name'], allow_destroy: true
 
             if rule['required']
-              klass.validates_length_of rule['name'], :minimum => 1
+              klass.validates_length_of rule['name'], minimum: 1
             end
           end
 
@@ -73,4 +71,4 @@ module CustomFields
 
   end
 
-end
+end

data/lib/custom_fields/types/integer.rb

@@ -0,0 +1,54 @@
+module CustomFields
+  module Types
+    module Integer
+
+      module Field; end
+
+      module Target
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Add a integer 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_integer_custom_field(klass, rule)
+            name = rule['name']
+
+            klass.field name, type: ::Integer, localize: rule['localized'] || false
+            klass.validates_presence_of name if rule['required']
+            klass.validates name, numericality: { only_integer: true }, if: ->(x){ rule['required'] }
+          end
+
+          # Build a hash storing the raw value for
+          # a string custom field of an instance.
+          #
+          # @param [ Object ] instance An instance of the class enhanced by the custom_fields
+          # @param [ String ] name The name of the string custom field
+          #
+          # @return [ Hash ] field name => raw value
+          #
+          def integer_attribute_get(instance, name)
+            self.default_attribute_get(instance, name)
+          end
+
+          # Set the value for the instance and the string field specified by
+          # the 2 params.
+          #
+          # @param [ Object ] instance An instance of the class enhanced by the custom_fields
+          # @param [ String ] name The name of the string custom field
+          # @param [ Hash ] attributes The attributes used to fetch the values
+          #
+          def integer_attribute_set(instance, name, attributes)
+            self.default_attribute_set(instance, name, attributes)
+          end
+
+        end # ClassMethods
+
+      end # Target
+
+    end # Integer
+  end # Types
+end # CustomFields

data/lib/custom_fields/types/many_to_many.rb

@@ -34,9 +34,9 @@ module CustomFields
           # @param [ Hash ] rule It contains the name of the relation and if it is required or not
           #
           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
+            # 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'], :order => rule['order_by'] do
+            klass.has_and_belongs_to_many rule['name'], class_name: rule['class_name'], inverse_of: rule['inverse_of'], order: rule['order_by'] do
 
               def filtered(conditions = {}, order_by = nil)
                 list = conditions.empty? ? self : self.where(conditions)
@@ -56,7 +56,7 @@ module CustomFields
             end
 
             if rule['required']
-              klass.validates_length_of rule['name'], :minimum => 1
+              klass.validates_length_of rule['name'], minimum: 1
             end
           end
 

data/lib/custom_fields/types/money.rb

@@ -0,0 +1,146 @@
+module CustomFields
+  module Types
+    module Money
+
+      module Field
+        extend ActiveSupport::Concern
+
+        included do
+          # allow_currency_from_symbol means that the user is able
+          # 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
+
+          before_validation :set_default
+
+          protected
+
+          def set_default
+            self.default_currency ||= CustomFields.options[:default_currency]
+          end
+
+          def check_currency
+            ::Money::Currency.find( self.default_currency )
+          end
+
+        end # included
+
+        def money_to_recipe
+          { 'default_currency' => self.default_currency,
+            'allow_currency_from_symbol' => self.allow_currency_from_symbol }
+        end
+
+        def money_as_json(options = {})
+          money_to_recipe
+        end
+
+      end # module Field
+
+
+      module Target
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Adds a Money field
+          #
+          # uses the money gem (https://github.com/RubyMoney/money)
+          #
+          # @param [ Class ] klass The class to modify
+          # @param [ Hash ] rule It contains the name of the field and if it is required or not
+          #
+          # if allow_currency_from_symbol is set the formatted_name_field will return the amount
+          # 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,
+              allow_currency_from_symbol: "#{name}_allow_currency_from_symbol".to_sym,
+              default_currency:           "#{name}_default_currency".to_sym
+            }
+
+            # fields
+            klass.field names[:cents_field],    type: ::Integer, localize: false
+            klass.field names[:currency_field], type: ::String,  localize: false
+
+            # getters and setters
+            klass.send( :define_method, name ) { _get_money(names) }
+            klass.send( :define_method, :"#{name}=" ) { |value| _set_money(value, names) }
+
+            klass.send( :define_method, names[:formatted_name_field] ) { _get_formatted_money(names) }
+            klass.send( :define_method, :"#{names[:formatted_name_field]}=" ) { |value| _set_money(value, names) }
+
+            klass.send( :define_method, names[:allow_currency_from_symbol] ) { rule['allow_currency_from_symbol'] }
+            klass.send( :define_method, names[:default_currency] ) { rule['default_currency'] }
+
+            # validations
+            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)
+            if value = instance.send(:"formatted_#{name}")
+              { name => value, "formatted_#{name}" => value }
+            else
+              {}
+            end
+          end
+
+         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 )
+          ::Money.assume_from_symbol = self.send( names[:allow_currency_from_symbol] )
+          ::Money.default_currency = self.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 )
+        end
+
+        def _check_money( names )
+          if [nil, ''].include? self.read_attribute.names[:cents_field]
+            raise ArgumentError.new 'Unrecognized amount'
+          end
+          _get_money( names )
+        rescue
+          self.errors.add( names[:name], "#{$!}" )
+          false
+        end
+
+        def _set_money( _money, names )
+          return if _money.blank?
+          _set_money_defaults( names )
+          money = _money.kind_of?( Money ) ? _money : ::Money.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], "#{$!}" )
+        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
+        end
+
+      end
+    end
+  end
+end