custom_fields 1.1.0.rc1 → 2.0.0.rc1

data/lib/custom_fields/field.rb

@@ -1,228 +1,97 @@
 module CustomFields
 
   class Field
+
     include ::Mongoid::Document
     include ::Mongoid::Timestamps
 
-    # types ##
-    include Types::Default
-    include Types::String
-    include Types::Text
-    include Types::Category
-    include Types::Boolean
-    include Types::Date
-    include Types::File
-    include Types::HasOne
-    include Types::HasMany
+    ## types ##
+    %w(default string text date boolean file select).each do |type|
+      include "CustomFields::Types::#{type.classify}::Field".constantize
+    end
 
     ## fields ##
     field :label
-    field :_alias
-    field :_name
-    field :kind
+    field :name
+    field :type
     field :hint
-    field :position, :type => Integer, :default => 0
-    field :required, :type => Boolean, :default => false
+    field :position,  :type => Integer, :default => 0
+    field :required,  :type => Boolean, :default => false
+    field :localized, :type => Boolean, :default => false
 
     ## validations ##
-    validates_presence_of   :label, :kind
-    validates_exclusion_of  :_alias, :in => lambda { |f| CustomFields.options[:reserved_aliases].map(&:to_s) }
-    validates_format_of     :_alias, :with => /^[a-z]([A-Za-z0-9_]+)?$/
-    validate                :uniqueness_of_label_and_alias
-
-    ## other accessors ##
-    attr_accessor :parentized_done # for performance purpose
+    validates_presence_of   :label, :type
+    validates_exclusion_of  :name, :in => lambda { |f| CustomFields.options[:reserved_names].map(&:to_s) }
+    validates_format_of     :name, :with => /^[a-z]([A-Za-z0-9_]+)?$/
+    validate                :uniqueness_of_label_and_name
 
     ## callbacks ##
-    before_validation :set_alias
-    before_save       :invalidate_proxy_klass
+    before_validation :set_name
 
     ## methods ##
 
-    # Returns the type class related to this field
+    # Builds the mongodb updates based on
+    # the new state of the field.
+    # Call a different method if the field has a different behaviour.
     #
-    # @return [ Class ] The class defining the field type
+    # @param [ Hash ] memo Store the updates
     #
-    def field_type
-      self.class.field_types[self.safe_kind.to_sym]
-    end
-
-    # Enhance a document class by applying to it the information stored
-    # in the type related to this field
-    #
-    # @param [ Class ] klass The document class
+    # @return [ Hash ] The memo object upgraded
     #
-    def apply(klass)
-      klass.field self._name, :type => self.field_type if self.field_type
-
-      apply_method_name = :"apply_#{self.safe_kind}_type"
+    def collect_diff(memo)
+      method_name = :"collect_#{self.type}_diff"
 
-      if self.respond_to?(apply_method_name)
-        self.send(apply_method_name, klass)
+      if self.respond_to?(method_name)
+        self.send(method_name, memo)
       else
-        apply_default_type(klass)
-      end
-
-      validation_method_name = :"add_#{self.safe_kind}_validation"
-
-      if self.respond_to?(validation_method_name)
-        self.send(validation_method_name, klass)
-      else
-        add_default_validation(klass)
+        collect_default_diff(memo)
       end
     end
 
-    # Make sure it returns a valid alias
+    # Returns the information (name, type, required, ...etc) needed to build
+    # the custom class.
+    # That will be stored into the target instance.
     #
-    # @return [ String ] the alias
+    # @return [ Hash ] The hash
     #
-    def safe_alias
-      self.set_alias
-      self._alias
-    end
-
-    # Returns the kind (or type) of the current field.
-    # Because of compatibility purpose, prior version of CustomFields used to have the value of kind in uppercase.
-    #
-    # @return [ String ] the kind
-    #
-    def safe_kind
-      self.kind.downcase
-    end
-
-    # Returns the name of the relation binding this field and the custom_fields in the parent class
-    #
-    # @example:
-    #   class Company
-    #     embeds_many :employees
-    #     custom_fields_for :employees
-    #   end
-    #
-    #   field = company.employees_custom_fields.build :label => 'His/her position', :_alias => 'position', :kind => 'string'
-    #   field.custom_fields_relation_name == 'employees'
-    #
-    # @return [ String ] the relation's name
-    #
-    def custom_fields_relation_name
-      self.metadata.name.to_s.gsub('_custom_fields', '')
-    end
-
-    # Checks if the field is valid without running the callback which marks
-    # the proxy class as invalidated
-    #
-    # @return [ Boolean ] true if the field has no errors, false otherwise
-    def quick_valid?
-      # true
-      # CustomFields::Field.without_callback(:validation, :after, :invalidate_proxy_klass) do
-      CustomFields::Field.without_callback(:save, :before, :invalidate_proxy_klass) do
-        self.valid?
-      end
-    end
+    def to_recipe
+      method_name       = :"#{self.type}_to_recipe"
+      custom_to_recipe  = self.send(method_name) rescue {}
 
-    # Destroys a field and saves the parent too in order to keep track of the changes
-    # for the parent (for instance, the version has to be bumped).
-    #
-    # @param [ Hash ] options Options to pass to destroy.
-    #
-    # @return [ true, false ] True if successful, false if not.
-    #
-    def destroy(options = {})
-      super.tap do
-        self.mark_proxy_klass_flag_as_invalidated
-        self._parent.save
-      end
+      { 'name' => self.name, 'type' => self.type, 'required' => self.required?, 'localized' => self.localized? }.merge(custom_to_recipe)
     end
 
-    # Collects all the important attributes of this field.
-    # It also accepts an extra hash which will be merged with
-    # the one built by this method (by default, this is an empty hash)
-    #
-    # @param [ Hash ] more The extra hash
-    #
-    # @return [ Hash ] the hash
-    #
-    def to_hash(more = {})
-      self.fields.keys.inject({}) do |memo, meth|
-        memo[meth] = self.send(meth.to_sym); memo
-      end.tap do |hash|
-        self.class.field_types.keys.each do |type|
-          if self.respond_to?(:"#{type}_to_hash")
-            hash.merge!(self.send(:"#{type}_to_hash"))
-          end
-        end
-      end.merge({
-        'id'          => self._id,
-        'new_record'  => self.new_record?,
-        'errors'      => self.errors,
-        'kind_name'   => I18n.t("custom_fields.kind.#{self.safe_kind}")
-      }).merge(more)
-    end
+    def as_json(options = {})
+      method_name     = :"#{self.type}_as_json"
+      custom_as_json  = self.send(method_name) rescue {}
 
-    # Overides the default behaviour of the to_json method by using the to_hash method
-    #
-    # @return [ String ] the json object
-    #
-    def to_json
-      ActiveSupport::JSON.encode(self.to_hash)
+      super(options).merge(custom_as_json)
     end
 
     protected
 
-    def uniqueness_of_label_and_alias
+    def uniqueness_of_label_and_name
       if self.siblings.any? { |f| f.label == self.label && f._id != self._id }
         self.errors.add(:label, :taken)
       end
 
-      if self.siblings.any? { |f| f._alias == self._alias && f._id != self._id }
-        self.errors.add(:_alias, :taken)
+      if self.siblings.any? { |f| f.name == self.name && f._id != self._id }
+        self.errors.add(:name, :taken)
       end
     end
 
-    def set_unique_name!
-      self._name ||= "custom_field_#{self.increment_counter!}"
-    end
-
-    def set_alias
-      return if self.label.blank? && self._alias.blank?
+    def set_name
+      return if self.label.blank? && self.name.blank?
 
-      if self._alias.blank?
-        self._alias = self.label.parameterize('_').gsub('-', '_').downcase
+      if self.name.blank?
+        self.name = self.label.parameterize('_').gsub('-', '_').downcase
       end
     end
 
-    def increment_counter!
-      name = self.custom_fields_relation_name
-      self._parent.bump_custom_fields_counter(name)
-    end
-
     def siblings
       self._parent.send(self.metadata.name)
     end
 
-    def parentize_with_custom_fields(object)
-      return if self.parentized_done
-
-      parentize_without_custom_fields(object)
-
-      self.send(:set_unique_name!)
-
-      self.parentized_done = true
-    end
-    alias_method_chain :parentize, :custom_fields
-
-    def invalidate_proxy_klass
-      # puts "#{self._name} / #{self._alias} _ invalidate_proxy_klass !!! #{self.flagged_for_destroy?} / #{self.destroyed?}"
-      if self.changed? || self.flagged_for_destroy?
-        self.mark_proxy_klass_flag_as_invalidated
-      end
-    end
-
-    def mark_proxy_klass_flag_as_invalidated
-      # puts "\t*** [mark_proxy_klass_flag_as_invalidated] called for '#{self._name}'"
-      name = self.custom_fields_relation_name
-      self._parent.mark_klass_with_custom_fields_as_invalidated(name)
-    end
-
   end
 
 end

data/lib/custom_fields/source.rb

@@ -0,0 +1,333 @@
+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
+
+    module InstanceMethods
+
+      # 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)
+        recipe = self.custom_fields_recipe_for(name)
+        target = self.send(name).metadata.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'     => "#{name.to_s.classify}#{self._id}",
+          'rules'    => self.ordered_custom_fields(name).map(&:to_recipe),
+          'version'  => self.custom_fields_version(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
+
+        self.send(name).metadata = old_metadata.clone.tap do |metadata|
+          metadata.instance_variable_set(:@klass, self.klass_with_custom_fields(name))
+        end
+
+        # puts "new_metadata = #{self.send(name).metadata.klass.inspect} / #{self.send(name).metadata.object_id.inspect}" # DEBUG
+      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.update selector, 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]] = { 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[I18n.locale.to_s]
+            end
+          end
+
+          next if updates.empty?
+
+          collection = self.send(name).collection
+          collection.update record.atomic_selector, { '$set' => updates }
+        end
+      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