gnuside-custom_fields 2.3.1

data/lib/custom_fields/types/many_to_many.rb

@@ -0,0 +1,75 @@
+module CustomFields
+
+  module Types
+
+    module ManyToMany
+
+      module Field
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          def many_to_many_to_recipe
+            { 'class_name' => self.class_name, 'inverse_of' => self.inverse_of, 'order_by' => self.order_by }
+          end
+
+          def many_to_many_is_relationship?
+            self.type == 'many_to_many'
+          end
+
+        end
+
+      end
+
+      module Target
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Adds a many_to_many relationship between 2 mongoid models
+          #
+          # @param [ Class ] klass The class to modify
+          # @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
+
+            klass.has_and_belongs_to_many rule['name'], class_name: rule['class_name'], inverse_of: rule['inverse_of'], order: rule['order_by'] do
+
+              # def at_least_one_element?
+              #   (base.send(metadata.key.to_sym).try(:size) || 0) > 0
+              # end
+
+              def filtered(conditions = {}, order_by = nil)
+                list = conditions.empty? ? self : self.where(conditions)
+
+                if order_by
+                  list.order_by(order_by)
+                else
+                  # 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(metadata.key.to_sym)
+                  list.entries.sort { |a, b| ids.index(a.id) <=> ids.index(b.id) }
+                end
+              end
+
+              alias :ordered :filtered # backward compatibility + semantic purpose
+
+            end
+
+            if rule['required']
+              klass.validates_collection_size_of rule['name'], minimum: 1, message: :at_least_one_element
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+  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

data/lib/custom_fields/types/relationship_default.rb

@@ -0,0 +1,44 @@
+module CustomFields
+
+  module Types
+
+    module RelationshipDefault
+
+      module Field
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          field :class_name
+          field :inverse_of
+          field :order_by
+
+          validates_presence_of :class_name,                  if: :is_relationship?
+          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)
+          end
+
+          protected
+
+          def ensure_class_name_security
+            true
+            # FIXME: to be overridden in the target application
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+
+
+

data/lib/custom_fields/types/select.rb

@@ -0,0 +1,217 @@
+module CustomFields
+
+  module Types
+
+    module Select
+
+      class Option
+
+        include Mongoid::Document
+
+        field :name,      localize: true
+        field :position,  type: ::Integer, default: 0
+
+        embedded_in :custom_field, inverse_of: :select_options
+
+        validates_presence_of :name
+
+        def as_json(options = nil)
+          super methods: %w(_id name position)
+        end
+
+      end
+
+      module Field
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          embeds_many :select_options, class_name: 'CustomFields::Types::Select::Option'
+
+          validates_associated :select_options
+
+          accepts_nested_attributes_for :select_options, allow_destroy: true
+
+        end
+
+        def ordered_select_options
+          self.select_options.sort { |a, b| (a.position || 0) <=> (b.position || 0) }.to_a
+        end
+
+        def select_to_recipe
+          {
+            'select_options' => self.ordered_select_options.map do |option|
+              { '_id' => option._id, 'name' => option.name_translations }
+            end
+          }
+        end
+
+        def select_as_json(options = {})
+          { 'select_options' => self.ordered_select_options.map(&:as_json) }
+        end
+
+      end
+
+      module Target
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Adds a select 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_select_custom_field(klass, rule)
+            name, base_collection_name = rule['name'], "#{rule['name']}_options".to_sym
+
+            klass.field :"#{name}_id", type: Moped::BSON::ObjectId, localize: rule['localized'] || false
+
+            klass.cattr_accessor "_raw_#{base_collection_name}"
+            klass.send :"_raw_#{base_collection_name}=", rule['select_options'].sort { |a, b| a['position'] <=> b['position'] }
+
+            # other methods
+            klass.send(:define_method, name.to_sym) { _get_select_option(name) }
+            klass.send(:define_method, :"#{name}=") { |value| _set_select_option(name, value) }
+
+            klass.class_eval <<-EOV
+
+              def self.#{base_collection_name}
+                self._select_options('#{name}')
+              end
+
+            EOV
+
+            if rule['required']
+              klass.validates_presence_of name
+            end
+          end
+
+          # Build a hash storing the values (id and option name) for
+          # a select 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 select custom field
+          #
+          # @return [ Hash ] fields: <name>: option name, <name>_id: id of the option
+          #
+          def select_attribute_get(instance, name)
+            if value = instance.send(name.to_sym)
+              {
+                name          => value,
+                "#{name}_id"  => instance.send(:"#{name}_id")
+              }
+            else
+              {}
+            end
+          end
+
+          # Set the value for the instance and the select 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 select custom field
+          # @param [ Hash ] attributes The attributes used to fetch the values
+          #
+          def select_attribute_set(instance, name, attributes)
+            id_or_name  = attributes[name] || attributes["#{name}_id"]
+
+            return if id_or_name.nil?
+
+            option = _select_options(name).detect do |option|
+              [option['_id'], option['name']].include?(id_or_name)
+            end
+
+            instance.send(:"#{name}_id=", option.try(:[], '_id'))
+          end
+
+          # Returns a list of documents groupes by select values defined in the custom fields recipe
+          #
+          # @param  [ Class ] klass The class to modify
+          # @return [ Array ] An array of hashes (keys: select option and related documents)
+          #
+          def group_by_select_option(name, order_by = nil)
+            name_id = "#{name}_id"
+            groups = self.each.group_by{|x| x.send(name_id)}.map do |(k, v)|
+              {name_id => k, "group" => v}
+            end
+
+            _select_options(name).map do |option|
+              group = groups.detect { |g| g[name_id].to_s == option['_id'].to_s }
+              list  = group ? group['group'] : []
+
+              groups.delete(group) if group
+
+              { name: option['name'], entries: self._order_select_entries(list, order_by) }.with_indifferent_access
+            end.tap do |array|
+              if not groups.empty? # orphan entries ?
+                empty = { name: nil, entries: [] }.with_indifferent_access
+                groups.each do |group|
+                  empty[:entries] += group['group']
+                end
+                empty[:entries] = self._order_select_entries(empty[:entries], order_by)
+                array << empty
+              end
+            end
+          end
+
+          def _select_options(name)
+            self.send(:"_raw_#{name}_options").map do |option|
+
+              locale = Mongoid::Fields::I18n.locale.to_s
+
+              name = if !option['name'].respond_to?(:merge)
+                option['name']
+              elsif Mongoid::Fields::I18n.fallbacks?
+                option['name'][Mongoid::Fields::I18n.fallbacks[locale.to_sym].map(&:to_s).find { |loc| !option['name'][loc].nil? }]
+              else
+                option['name'][locale.to_s]
+              end
+
+              { '_id' => option['_id'], 'name' => name }
+            end
+          end
+
+          def _order_select_entries(list, order_by = nil)
+            return list if order_by.nil?
+
+            column, direction = order_by.flatten
+
+            list = list.sort { |a, b| (a.send(column) && b.send(column)) ? (a.send(column) || 0) <=> (b.send(column) || 0) : 0 }
+
+            direction == 'asc' ? list : list.reverse
+
+            list
+          end
+
+        end
+
+        def _select_option_id(name)
+          self.send(:"#{name}_id")
+        end
+
+        def _find_select_option(name, id_or_name)
+          self.class._select_options(name).detect do |option|
+            option['name'] == id_or_name || option['_id'].to_s == id_or_name.to_s
+          end
+        end
+
+        def _get_select_option(name)
+          option = self._find_select_option(name, self._select_option_id(name))
+          option ? option['name'] : nil
+        end
+
+        def _set_select_option(name, value)
+          option = self._find_select_option(name, value)
+          self.send(:"#{name}_id=", option ? option['_id'] : nil)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/custom_fields/types/string.rb

@@ -0,0 +1,55 @@
+module CustomFields
+
+  module Types
+
+    module String
+
+      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_string_custom_field(klass, rule)
+            apply_custom_field(klass, rule)
+          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 string_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 string_attribute_set(instance, name, attributes)
+            self.default_attribute_set(instance, name, attributes)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/custom_fields/types/tags.rb

@@ -0,0 +1,35 @@
+module CustomFields
+  module Types
+    module Tags
+      module Field; end
+      
+      module Target
+        extend ActiveSupport::Concern
+        
+        module ClassMethods
+
+          def apply_tags_custom_field(klass, rule)
+            klass.field rule['name'], localize: rule['localized'] || false, type: Array
+            
+            klass.class_eval do
+              define_method("#{rule['name']}=") do |val|
+                #FIXME I would use is_a?(), but it doesn't work in my machine!
+                val = val.split(/ *, */) if val.class.to_s == "String" 
+                super(val)
+              end
+            end
+          end
+          
+          def tags_attribute_get(instance, name)
+            self.default_attribute_get(instance, name)
+          end
+
+          def tags_attribute_set(instance, name, attributes)
+            self.default_attribute_set(instance, name, attributes)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/custom_fields/types/text.rb

@@ -0,0 +1,65 @@
+module CustomFields
+
+  module Types
+
+    module Text
+
+      module Field
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          field :text_formatting, default: 'html'
+
+        end
+
+      end
+
+      module Target
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Adds a text field (simply 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_text_custom_field(klass, rule)
+            apply_custom_field(klass, rule)
+          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 text_attribute_get(instance, name)
+            default_attribute_get(instance, name)
+          end
+
+          # Set the value for the instance and the text 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 text custom field
+          # @param [ Hash ] attributes The attributes used to fetch the values
+          #
+          def text_attribute_set(instance, name, attributes)
+            self.default_attribute_set(instance, name, attributes)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/custom_fields/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+module CustomFields #:nodoc
+
+  VERSION = '2.3.1'
+
+end