custom_fields 1.1.0.rc1 → 2.0.0.rc1

data/lib/custom_fields/target.rb

@@ -0,0 +1,90 @@
+module CustomFields
+
+  module Target
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      ## types ##
+      %w(default string text date boolean file select).each do |type|
+        include "CustomFields::Types::#{type.classify}::Target".constantize
+      end
+
+      ## fields ##
+      field :custom_fields_recipe, :type => Hash
+
+    end
+
+    module InstanceMethods
+
+    end
+
+    module ClassMethods
+
+      # A document with custom fields always returns true.
+      #
+      # @return [ Boolean ] True
+      #
+      def with_custom_fields?
+        true
+      end
+
+      # Builds the custom klass by sub-classing it
+      # from its parent and by applying a recipe
+      #
+      # @param [ Hash ] recipe The recipe describing the fields to add
+      #
+      # @return [ Class] the anonymous custom klass
+      #
+      def build_klass_with_custom_fields(recipe)
+        # puts "CREATING new '#{name}' / #{recipe.inspect}" # DEBUG
+        Class.new(self).tap do |klass|
+          klass.cattr_accessor :version
+
+          klass.version = recipe['version']
+
+          # copy scopes from the parent class (scopes does not inherit automatically from the parents in mongoid)
+          klass.write_inheritable_attribute(:scopes, self.scopes)
+
+          recipe['rules'].each do |rule|
+            self.send(:"apply_#{rule['type']}_custom_field", klass, rule)
+          end
+        end
+      end
+
+      # Returns a custom klass always up-to-date. If it does not
+      # exist or if the version is out-dates then build a new custom klass.
+      # The recipe also contains the name which will be assigned to the
+      # custom klass.
+      #
+      # @param [ Hash ] recipe The recipe describing the fields to add
+      #
+      # @return [ Class ] the custom klass
+      #
+      def klass_with_custom_fields(recipe)
+        name = recipe['name']
+
+        (modules = self.name.split('::')).pop
+
+        parent = modules.empty? ? Object : modules.join('::').constantize
+
+        klass = parent.const_defined?(name) ? parent.const_get(name) : nil
+
+        if klass.nil? || klass.version != recipe['version'] # no klass or out-dated klass
+          parent.send(:remove_const, name) if klass
+
+          klass = build_klass_with_custom_fields(recipe)
+
+          parent.const_set(name, klass)
+        end
+
+        klass
+      end
+
+    end
+
+
+  end
+
+end

data/lib/custom_fields/types/boolean.rb

@@ -1,13 +1,36 @@
 module CustomFields
+
   module Types
+
     module Boolean
 
-      extend ActiveSupport::Concern
+      module Field; end
+
+      module Target
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Adds a boolean 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_boolean_custom_field(klass, rule)
+            klass.field rule['name'], :type => ::Boolean, :localize => rule['localized'] || false
+
+            if rule['required']
+              klass.validates_presence_of rule['name']
+            end
+          end
+
+        end
 
-      included do
-        register_type :boolean, ::Boolean
       end
 
     end
+
   end
+
 end

data/lib/custom_fields/types/date.rb

@@ -1,43 +1,53 @@
 module CustomFields
+
   module Types
+
     module Date
 
-      extend ActiveSupport::Concern
+      module Field; end
 
-      included do
-        register_type :date, ::Date
-      end
+      module Target
 
-      module InstanceMethods
+        extend ActiveSupport::Concern
 
-        def apply_date_type(klass)
+        module ClassMethods
 
-          klass.class_eval <<-EOF
+          # Adds a date 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_date_custom_field(klass, rule)
+            name = rule['name']
 
-            def #{self.safe_alias}
-              self.#{self._name}
-            end
+            klass.field name, :type => ::Date, :localize => rule['localized'] || false
 
-            def #{self.safe_alias}=(value)
-              if value.is_a?(::String) && !value.blank?
-                date = ::Date._strptime(value, I18n.t('date.formats.default'))
-                value = ::Date.new(date[:year], date[:mon], date[:mday])
-              end
+            # other methods
+            klass.send(:define_method, :"formatted_#{name}") { _get_formatted_date(name) }
+            klass.send(:define_method, :"formatted_#{name}=") { |value| _set_formatted_date(name, value) }
 
-              self.#{self._name} = value
+            if rule['required']
+              klass.validates_presence_of name, :"formatted_#{name}"
             end
+          end
 
-            def formatted_#{self.safe_alias}
-              self.#{self._name}.strftime(I18n.t('date.formats.default')) rescue nil
-            end
+        end
 
-            alias formatted_#{self.safe_alias}= #{self.safe_alias}=
-          EOF
+        module InstanceMethods
 
-          def add_date_validation(klass)
-            if self.required?
-              klass.validates_presence_of self.safe_alias.to_sym, :"formatted_#{self.safe_alias}"
+          protected
+
+          def _set_formatted_date(name, value)
+            if value.is_a?(::String) && !value.blank?
+              date  = ::Date._strptime(value, I18n.t('date.formats.default'))
+              value = ::Date.new(date[:year], date[:mon], date[:mday])
             end
+
+            self.send(:"#{name}=", value)
+          end
+
+          def _get_formatted_date(name)
+            self.send(name.to_sym).strftime(I18n.t('date.formats.default')) rescue nil
           end
 
         end
@@ -45,5 +55,7 @@ module CustomFields
       end
 
     end
+
   end
+
 end

data/lib/custom_fields/types/default.rb

@@ -1,44 +1,64 @@
 module CustomFields
+
   module Types
+
     module Default
-      extend ActiveSupport::Concern
 
-      included do
-        cattr_accessor :field_types
-      end
+      module Field
 
-      module InstanceMethods
+        # Build the mongodb updates based on
+        # the new state of the field
+        #
+        # @param [ Hash ] memo Store the updates
+        #
+        # @return [ Hash ] The memo object upgraded
+        #
+        def collect_default_diff(memo)
+          if self.persisted?
+            if self.destroyed?
+              memo['$unset'][self.name] = 1
+            elsif self.changed?
+              if self.changes.key?(:name)
+                old_name, new_name = self.changes[:name]
+                memo['$rename'][old_name] = new_name
+              end
+            end
+          end
 
-        def apply_default_type(klass)
-          klass.class_eval <<-EOF
-            alias :#{self.safe_alias} :#{self._name}
-            alias :#{self.safe_alias}= :#{self._name}=
-          EOF
-        end
+          (memo['$set']['custom_fields_recipe.rules'] ||= []) << self.to_recipe
 
-        def add_default_validation(klass)
-          # add validation if required field
-          if self.required?
-            klass.validates_presence_of self.safe_alias.to_sym
-          end
+          memo
         end
 
       end
 
-      module ClassMethods
+      module Target
 
-        def register_type(kind, klass = ::String)
-          self.field_types ||= {}
-          self.field_types[kind.to_sym] = klass unless klass.nil?
+        extend ActiveSupport::Concern
 
-          self.class_eval <<-EOF
-            def #{kind.to_s}?
-              self.kind.downcase == '#{kind}' rescue false
+        module ClassMethods
+
+          # Modify the target class according to the rule.
+          # By default, it declares the field and a validator
+          # if specified by the rule
+          #
+          # @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_custom_field(klass, rule)
+            klass.field rule['name'], :localize => rule['localized'] || false
+
+            if rule['required']
+              klass.validates_presence_of rule['name']
             end
-          EOF
+          end
+
         end
 
       end
+
     end
+
   end
+
 end

data/lib/custom_fields/types/file.rb

@@ -1,27 +1,45 @@
 module CustomFields
+
   module Types
+
     module File
-        
-      extend ActiveSupport::Concern
-      
-      included do
-        register_type :file, nil # do not create the default field
-      end
-    
-      module InstanceMethods
-        
-        def apply_file_type(klass)
-          
-          klass.mount_uploader self._name, FileUploader
-
-          self.apply_default_type(klass)
+
+      module Field; end
+
+      module Target
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Adds a file field (using carrierwave)
+          #
+          # @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_file_custom_field(klass, rule)
+            name = rule['name']
+
+            klass.mount_uploader name, FileUploader
+
+            if rule['localized'] == true
+              klass.replace_field name, ::String, true
+            end
+
+            if rule['required']
+              klass.validates_presence_of name
+            end
+          end
+
         end
-          
+
       end
-      
+
       class FileUploader < ::CarrierWave::Uploader::Base
       end
-    
+
     end
+
   end
+
 end

data/lib/custom_fields/types/select.rb

@@ -0,0 +1,184 @@
+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
+
+        module InstanceMethods
+
+          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
+
+      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 => BSON::ObjectId, :localize => rule['localized'] || false
+
+            klass.cattr_accessor "_raw_#{base_collection_name}"
+            klass.send :"_raw_#{base_collection_name}=", rule['select_options']
+
+            # 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
+
+          # 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)
+            groups = self.only(:"#{name}_id").group
+
+            _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
+
+        module InstanceMethods
+
+          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
+
+end