gnuside-custom_fields 2.3.1

data/lib/custom_fields/source.rb

@@ -0,0 +1,347 @@
+module CustomFields
+
+  module Source
+
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :_custom_fields_for
+      self._custom_fields_for = []
+
+      attr_accessor :_custom_fields_diff
+      attr_accessor :_custom_field_localize_diff
+    end
+
+    # Determines if the relation is enhanced by the custom fields
+    #
+    # @example the Person class has somewhere in its code this: "custom_fields_for :addresses"
+    #   person.custom_fields_for?(:addresses)
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    # @return [ true, false ] True if enhanced, false if not.
+    #
+    def custom_fields_for?(name)
+      self.class.custom_fields_for?(name)
+    end
+
+    # Returns the class enhanced by the custom fields.
+    # Be careful, call this method only if the source class
+    # has been saved with success.
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    # @return [ Class ] The modified class.
+    #
+    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).metadata
+      target    = _metadata[:original_klass] || _metadata.klass # avoid to use an already enhanced klass
+      target.klass_with_custom_fields(recipe)
+    end
+
+    # Returns the ordered list of custom fields for a relation
+    #
+    # @example the Person class has somewhere in its code this: "custom_fields_for :addresses"
+    #   person.ordered_custom_fields(:addresses)
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    # @return [ Collection ] The ordered list.
+    #
+    def ordered_custom_fields(name)
+      self.send(:"#{name}_custom_fields").sort { |a, b| (a.position || 0) <=> (b.position || 0) }
+    end
+
+    # Returns the recipe (meaning all the rules) needed to
+    # build the custom klass
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    # @return [ Array ] An array of hashes
+    #
+    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
+      }
+    end
+
+    # Returns the number of the version for relation with custom fields
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    # @return [ Integer ] The version number
+    #
+    def custom_fields_version(name)
+      self.send(:"#{name}_custom_fields_version") || 0
+    end
+
+    # When the fields have been modified and before the object is saved,
+    # we bump the version.
+    #
+    # @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)
+    end
+
+    # Change the metadata of a relation enhanced by the custom fields.
+    # In Mongoid, all the instances of a same document share the same metadata objects.
+    #
+    # @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
+
+      old_metadata = self.send(name).metadata
+
+      # 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|
+        # 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(:@klass, self.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
+    end
+
+    def set_attribute_localization(name)
+      klass_name = name.singularize.to_sym
+      self.send(:"#{name}_custom_fields").each do |cf|
+        I18n.backend.store_translations ::I18n.locale,
+                          {mongoid: { attributes: {klass_name => {cf.name.to_sym => cf.label}}}}
+      end
+    end
+
+    # Initializes the object tracking the modifications
+    # of the custom fields
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    def initialize_custom_fields_diff(name)
+      self._custom_field_localize_diff ||= Hash.new([])
+
+      self._custom_fields_diff ||= {}
+      self._custom_fields_diff[name] = { '$set' => {}, '$unset' => {}, '$rename' => {} }
+    end
+
+    # Collects all the modifications of the custom fields
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    # @return [ Array ] An array of hashes storing the modifications
+    #
+    def collect_custom_fields_diff(name, fields)
+      # puts "==> collect_custom_fields_diff for #{name}, #{fields.size}" # DEBUG
+
+      memo = self.initialize_custom_fields_diff(name)
+
+      fields.map do |field|
+        field.collect_diff(memo)
+      end
+
+      # collect fields with a modified localized field
+      fields.each do |field|
+        if field.localized_changed? && field.persisted?
+          self._custom_field_localize_diff[name] << { field: field.name, localized: field.localized? }
+        end
+      end
+    end
+
+    # Apply the modifications collected from the custom fields by
+    # updating all the documents of the relation.
+    # The update uses the power of mongodb to make it fully optimized.
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    def apply_custom_fields_diff(name)
+      # 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
+
+      # puts "selector = #{selector.inspect}, memo = #{attributes.inspect}" # DEBUG
+
+      collection.find(selector).update operations, multi: true
+    end
+
+    # If the localized attribute has been changed in at least one of the custom fields,
+    # we have to upgrade all the records enhanced by custom_fields in order to make
+    # the values consistent with the mongoid localize option.
+    #
+    # Ex: post.attributes[:name] = 'Hello world' => post.attributes[:name] = { en: 'Hello world' }
+    #
+    # @param [ String, Symbol ] name The name of the relation.
+    #
+    def apply_custom_fields_localize_diff(name)
+      return if self._custom_field_localize_diff[name].empty?
+
+      self.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|
+          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.find(record.atomic_selector).update({ '$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"
+      #   Person.custom_fields_for?(:addresses)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      #
+      # @return [ true, false ] True if enhanced, false if not.
+      #
+      def custom_fields_for?(name)
+        self._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.
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      #
+      # @example
+      #   class Company
+      #     embeds_many :employees
+      #     custom_fields_for :employees
+      #   end
+      #
+      #   class Employee
+      #     embedded_in :company, inverse_of: :employees
+      #     field :name, String
+      #   end
+      #
+      #   company.employees_custom_fields.build label: 'His/her position', name: 'position', kind: 'string'
+      #   company.save
+      #   company.employees.build name: 'Michael Scott', position: 'Regional manager'
+      #
+      def custom_fields_for(name)
+        self.declare_embedded_in_definition_in_custom_field(name)
+
+        # stores the relation name
+        self._custom_fields_for << name.to_s
+
+        self.extend_for_custom_fields(name)
+      end
+
+      protected
+
+      # Extends / Decorates the current class in order to be fully custom_fields compliant.
+      # it declares news fields, adds new callbacks, ...etc
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      #
+      def extend_for_custom_fields(name)
+        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 ?????
+
+          accepts_nested_attributes_for :"#{name}_custom_fields", allow_destroy: true
+        end
+
+        class_eval <<-EOV
+          after_initialize  :refresh_#{name}_metadata
+          before_update     :bump_#{name}_custom_fields_version
+          before_update     :collect_#{name}_custom_fields_diff
+          after_update      :apply_#{name}_custom_fields_diff
+          after_update      :apply_#{name}_custom_fields_localize_diff
+
+          def ordered_#{name}_custom_fields
+            self.ordered_custom_fields('#{name}')
+          end
+
+          protected
+
+          def refresh_#{name}_metadata
+            self.refresh_metadata_with_custom_fields('#{name}')
+          end
+
+          def bump_#{name}_custom_fields_version
+            self.bump_custom_fields_version('#{name}')
+          end
+
+          def collect_#{name}_custom_fields_diff
+            self.collect_custom_fields_diff(:#{name}, self.#{name}_custom_fields)
+          end
+
+          def apply_#{name}_custom_fields_diff
+            self.apply_custom_fields_diff(:#{name})
+          end
+
+          def apply_#{name}_custom_fields_localize_diff
+            self.apply_custom_fields_localize_diff(:#{name})
+          end
+
+        EOV
+      end
+
+      # Returns the class name of the custom field which is based both on the parent class name
+      # and the name of the relation in order to avoid name conflicts (with other classes)
+      #
+      # @param [ Metadata ] metadata The relation's old metadata.
+      #
+      # @return [ String ] The class name
+      #
+      def dynamic_custom_field_class_name(name)
+        "#{self.name}#{name.to_s.singularize.camelize}Field"
+      end
+
+      # An embedded relationship has to be defined on both side in order for it
+      # to work properly. But because custom_field can be embedded in different
+      # models that it's not aware of, we have to declare manually the definition
+      # once we know the target class.
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      #
+      # @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
+
+        source = self.parents.size > 1 ? self.parents.first : Object
+
+        unless source.const_defined?(klass_name)
+          (klass = Class.new(::CustomFields::Field)).class_eval <<-EOF
+            embedded_in :#{self.name.demodulize.underscore}, inverse_of: :#{name}_custom_fields, class_name: '#{self.name}'
+          EOF
+
+          source.const_set(klass_name, klass)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/custom_fields/target.rb

@@ -0,0 +1,99 @@
+module CustomFields
+
+  module Target
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      ## types ##
+      %w(default string text email date date_time 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
+    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)
+        name = recipe['name']
+        # puts "CREATING #{name}, #{recipe.inspect}" # DEBUG
+        parent.const_set(name, 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)
+          # FIXME (Did): not needed anymore ?
+          # klass.write_inheritable_attribute(:scopes, self.scopes)
+
+          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
+
+      # 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)
+        return self if recipe.blank? # no recipe provided
+
+        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)
+        end
+
+        klass
+      end
+
+    end
+
+  end
+
+end

data/lib/custom_fields/target_helpers.rb

@@ -0,0 +1,192 @@
+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.
+    # If a block is passed, then the list will be filtered accordingly with
+    # the following logic. If the block is evaluated as true, then the method
+    # will be kept in the list, otherwise it will be removed.
+    #
+    # @example
+    #   # keep all the methods except for the field named 'foo'
+    #   project.custom_fields_methods do |rule|
+    #     rule['name] != 'foo'
+    #   end
+    #
+    # @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']
+        if block_given?
+          filter.call(rule) ? method : nil
+        else
+          method
+        end
+      end.compact.flatten
+    end
+
+    # List all the setters that are used by the custom_fields
+    # in order to get updated thru a html form for instance.
+    #
+    # @return [ List ] a list of method names (string)
+    #
+    def custom_fields_safe_setters
+      self.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']}"]
+        when :select, :belongs_to       then ["#{rule['name']}_id", "position_in_#{rule['name']}"]
+        when :has_many, :many_to_many   then nil
+        else
+          rule['name']
+        end
+      end.compact.flatten
+    end
+
+    # Build a hash for all the non-relationship fields
+    # meaning string, text, date, boolean, select, file types.
+    # This hash stores their name and their value.
+    #
+    # @return [ Hash ] Field name / formatted value
+    #
+    def custom_fields_basic_attributes
+      {}.tap do |hash|
+        self.non_relationship_custom_fields.each do |rule|
+          name, type = rule['name'], rule['type'].to_sym
+
+          # method of the custom getter
+          method_name = "#{type}_attribute_get"
+
+          hash.merge!(self.class.send(method_name, self, name))
+        end
+      end
+    end
+
+    # Set the values (and their related fields) for all the non-relationship fields
+    # meaning string, text, date, boolean, select, file types.
+    #
+    # @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
+
+        # method of the custom getter
+        method_name = "#{type}_attribute_set"
+
+        self.class.send(method_name, self, name, attributes)
+      end
+    end
+
+    # Check if the rule defined by the name is a "many" relationship kind.
+    # A "many" relationship includes "has_many" and "many_to_many"
+    #
+    # @param [ String ] name The name of the rule
+    #
+    # @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['name'] == name && _custom_field_many_relationship?(rule['type'])
+      end
+    end
+
+    # Return the rules of the custom fields which do not describe a relationship.
+    #
+    # @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'])
+      end
+    end
+
+    # Return the rules of the custom fields which describe a relationship.
+    #
+    # @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'])
+      end
+    end
+
+    # Return the names of all the select fields of this object
+    def select_custom_fields
+      group_custom_fields 'select'
+    end
+
+    # Return the names of all the file custom_fields of this object
+    #
+    # @return [ Array ] List of names
+    #
+    def file_custom_fields
+      group_custom_fields 'file'
+    end
+
+    # Return the names of all the belongs_to custom_fields of this object
+    #
+    # @return [ Array ] List of names
+    #
+    def belongs_to_custom_fields
+      group_custom_fields 'belongs_to'
+    end
+
+    # Return the names of all the has_many custom_fields of this object
+    #
+    # @return [ Array ] Array of array [name, inverse_of]
+    #
+    def has_many_custom_fields
+      group_custom_fields('has_many') { |rule| [rule['name'], rule['inverse_of']] }
+    end
+
+    # Return the names of all the many_to_many custom_fields of this object.
+    # It also adds the property used to set/get the target ids.
+    #
+    # @return [ Array ] Array of array [name, <name in singular>_ids]
+    #
+    def many_to_many_custom_fields
+      group_custom_fields('many_to_many') { |rule| [rule['name'], "#{rule['name'].singularize}_ids"] }
+    end
+
+    protected
+
+    # Get the names of the getter methods for a field.
+    # The names depend on the field type.
+    #
+    # @param [ String ] name Name of the field
+    # @param [ String ] type Type of the field
+    #
+    # @return [ Object ] A string or an array of names
+    #
+    def custom_fields_getters_for(name, type)
+      case type.to_sym
+      when :select                    then [name, "#{name}_id"]
+      when :date, :date_time, :money  then "formatted_#{name}"
+      when :file                      then "#{name}_url"
+      when :belongs_to                then "#{name}_id"
+      else
+        name
+      end
+    end
+
+    #:nodoc:
+    def _custom_field_many_relationship?(type)
+      %w(has_many many_to_many).include?(type)
+    end
+
+    #:nodoc:
+    def group_custom_fields(type, &block)
+      unless block_given?
+        block = lambda { |rule| rule['name'] }
+      end
+
+      self.custom_fields_recipe['rules'].find_all { |rule| rule['type'] == type }.map(&block)
+    end
+
+  end
+
+end

data/lib/custom_fields/types/belongs_to.rb

@@ -0,0 +1,65 @@
+module CustomFields
+
+  module Types
+
+    module BelongsTo
+
+      module Field
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          def belongs_to_to_recipe
+            { 'class_name' => self.class_name }
+          end
+
+          def belongs_to_is_relationship?
+            self.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
+          # @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
+
+            position_name = "position_in_#{rule['name'].underscore}"
+
+            # puts "#{klass.inspect}.field :#{position_name}" # DEBUG
+
+            klass.field position_name, type: ::Integer, default: 0
+
+            klass.belongs_to rule['name'].to_sym, class_name: rule['class_name']
+
+            if rule['required']
+              klass.validates_presence_of rule['name'].to_sym
+            end
+
+            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