custom_fields 0.0.0.1

data/README

@@ -0,0 +1,18 @@
+CustomFields
+===========
+
+Manage custom fields to a mongoid document or a collection. This module is one of the core features we implemented in our custom cms named Locomotive.
+
+Requirements
+=======
+
+MongoDB 1.6 and mongoid 2.0.0.beta16
+
+
+Example
+=======
+
+Coming soon but take a look of the tests to see what CustomFields is capable of.
+
+
+Copyright (c) 2010 [Didier Lafforgue], released under the MIT license

data/init.rb

@@ -0,0 +1,2 @@
+# Include hook code here
+require File.dirname(__FILE__) + '/lib/custom_fields'

data/lib/custom_fields.rb

@@ -0,0 +1,28 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'active_support'
+require 'carrierwave/orm/mongoid'
+
+require 'custom_fields/extensions/mongoid/hierarchy'
+require 'custom_fields/extensions/mongoid/associations/proxy'
+require 'custom_fields/extensions/mongoid/associations/references_many'
+require 'custom_fields/extensions/mongoid/associations/embeds_many'
+require 'custom_fields/types/default'
+require 'custom_fields/types/string'
+require 'custom_fields/types/text'
+require 'custom_fields/types/category'
+require 'custom_fields/types/boolean'
+require 'custom_fields/types/date'
+require 'custom_fields/types/file'
+require 'custom_fields/proxy_class_enabler'
+require 'custom_fields/field'
+require 'custom_fields/custom_fields_for'
+
+module Mongoid
+  module CustomFields  
+    extend ActiveSupport::Concern
+    included do
+      include ::CustomFields::CustomFieldsFor
+    end  
+  end
+end

data/lib/custom_fields/custom_fields_for.rb

@@ -0,0 +1,50 @@
+module CustomFields
+  
+  module CustomFieldsFor
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    # Enhance an embedded collection by providing methods to manage custom fields
+    #
+    # class Company
+    #   embeds_many :employees
+    #   custom_fields_for :employees
+    # end
+    #
+    # class Employee
+    #    embedded_in :company, :inverse_of => :employees
+    #    field :name, String
+    # end
+    #
+    # company.employee_custom_fields.build :label => 'His/her position', :_alias => 'position', :kind => 'String'
+    #
+    # company.employees.build :name => 'Michael Scott', :position => 'Regional manager'
+    #
+    module ClassMethods
+      
+      def custom_fields_for(collection_name)
+        singular_name = collection_name.to_s.singularize
+        
+        class_eval <<-EOV
+          field :#{singular_name}_custom_fields_counter, :type => Integer, :default => 0
+          
+          embeds_many :#{singular_name}_custom_fields, :class_name => "::CustomFields::Field"
+          
+          validates_associated :#{singular_name}_custom_fields
+          
+          accepts_nested_attributes_for :#{singular_name}_custom_fields, :allow_destroy => true
+          
+          def ordered_#{singular_name}_custom_fields
+            self.#{singular_name}_custom_fields.sort { |a, b| (a.position || 0) <=> (b.position || 0) }
+          end
+          
+        EOV
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/custom_fields/extensions/mongoid/associations/embeds_many.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class EmbedsMany < Proxy
+      
+      def initialize_with_custom_fields(parent, options, target_array = nil)
+        if custom_fields?(parent, options.name)
+          options = options.clone # 2 parent instances should not share the exact same option instance
+          
+          custom_fields = parent.send(:"ordered_#{custom_fields_association_name(options.name)}")
+        
+          klass = options.klass.to_klass_with_custom_fields(custom_fields)
+          klass._parent = parent
+          klass.association_name = options.name
+        
+          options.instance_eval <<-EOF
+            def klass=(klass); @klass = klass; end
+            def klass; @klass || class_name.constantize; end
+          EOF
+        
+          options.klass = klass
+        end
+        
+        initialize_without_custom_fields(parent, options, target_array)
+      end
+      
+      alias_method_chain :initialize, :custom_fields
+      
+    end
+  end
+end

data/lib/custom_fields/extensions/mongoid/associations/proxy.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Associations #:nodoc
+    class Proxy #:nodoc
+      
+      def custom_fields_association_name(association_name)
+        "#{association_name.to_s.singularize}_custom_fields".to_sym
+      end
+      
+      def custom_fields?(object, association_name)
+        object.respond_to?(custom_fields_association_name(association_name))
+      end
+      
+      def klass
+        @klass
+      end
+      
+    end
+  end
+end

data/lib/custom_fields/extensions/mongoid/associations/references_many.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    # Represents an relational one-to-many association with an object in a
+    # separate collection or database.
+    class ReferencesMany < Proxy
+      
+      def initialize_with_custom_fields(parent, options, target_array = nil)
+        if custom_fields?(parent, options.name)
+          options = options.clone # 2 parent instances should not share the exact same option instance
+          
+          custom_fields = parent.send(:"ordered_#{custom_fields_association_name(options.name)}")
+          
+          klass = options.klass.to_klass_with_custom_fields(custom_fields)
+          klass._parent = parent
+          klass.association_name = options.name
+          
+          options.instance_eval <<-EOF
+            def klass=(klass); @klass = klass; end
+            def klass; @klass || class_name.constantize; end
+          EOF
+          
+          options.klass = klass
+        end
+        
+        initialize_without_custom_fields(parent, options, target_array)
+      end
+      
+      alias_method_chain :initialize, :custom_fields
+      
+    end
+  end
+end

data/lib/custom_fields/extensions/mongoid/hierarchy.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Hierarchy #:nodoc
+    module InstanceMethods
+      
+      def parentize_with_custom_fields(object, association_name)
+        if association_name.to_s.ends_with?('_custom_fields')
+          self.singleton_class.associations = {}
+          self.singleton_class.embedded_in object.class.to_s.underscore.to_sym, :inverse_of => association_name
+        end
+            
+        parentize_without_custom_fields(object, association_name)
+        
+        if self.embedded? && self.instance_variable_get(:"@association_name").nil?
+          self.instance_variable_set(:"@association_name", association_name) # weird bug with proxy class
+        end
+        
+        if association_name.to_s.ends_with?('_custom_fields')
+          self.send(:set_unique_name!)
+          self.send(:set_alias)
+        end
+      end
+      
+      alias_method_chain :parentize, :custom_fields
+      
+    end
+  end
+end

data/lib/custom_fields/field.rb

@@ -0,0 +1,82 @@
+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
+  
+    ## fields ##
+    field :label
+    field :_alias
+    field :_name
+    field :kind
+    field :hint
+    field :position, :type => Integer, :default => 0
+      
+    ## validations ##
+    validates_presence_of :label, :kind
+    validate :uniqueness_of_label
+      
+    ## methods ##
+    
+    def field_type
+      self.class.field_types[self.kind.downcase.to_sym]
+    end
+    
+    def apply(klass)
+      return unless self.valid?
+      
+      klass.field self._name, :type => self.field_type if self.field_type
+      
+      apply_method_name = :"apply_#{self.kind.downcase}_type"
+      
+      if self.respond_to?(apply_method_name)
+        self.send(apply_method_name, klass)
+      else
+        apply_default_type(klass)
+      end
+    end
+    
+    def safe_alias
+      self.set_alias
+      self._alias 
+    end
+  
+    protected
+    
+    def uniqueness_of_label
+      duplicate = self.siblings.detect { |f| f.label == self.label && f._id != self._id }
+      if not duplicate.nil?
+        self.errors.add(:label, :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?
+      self._alias = (self._alias.blank? ? self.label : self._alias).parameterize('_').downcase
+    end
+  
+    def increment_counter!
+      next_value = (self._parent.send(:"#{self.association_name}_counter") || 0) + 1
+      self._parent.send(:"#{self.association_name}_counter=", next_value)
+      next_value
+    end
+  
+    def siblings
+      self._parent.send(self.association_name)
+    end
+  end
+  
+end

data/lib/custom_fields/proxy_class_enabler.rb

@@ -0,0 +1,40 @@
+module CustomFields
+  module ProxyClassEnabler
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      cattr_accessor :klass_with_custom_fields
+
+      def self.to_klass_with_custom_fields(fields)
+        return klass_with_custom_fields unless klass_with_custom_fields.nil?
+
+        klass = Class.new(self)
+        klass.class_eval <<-EOF
+          cattr_accessor :custom_fields, :_parent, :association_name
+
+          def self.model_name
+            @_model_name ||= ActiveModel::Name.new(self.superclass)
+          end
+
+          def custom_fields
+            self.class.custom_fields
+          end
+
+          def self.hereditary?
+            false
+          end
+        EOF
+
+        klass.custom_fields = fields
+
+        [*fields].each { |field| field.apply(klass) }
+
+        klass_with_custom_fields = klass
+      end
+
+    end
+
+  end
+end

data/lib/custom_fields/types/boolean.rb

@@ -0,0 +1,29 @@
+module CustomFields
+  module Types
+    module Boolean
+        
+      extend ActiveSupport::Concern
+      
+      included do
+        register_type :boolean
+      end
+    
+      module InstanceMethods
+        
+        def apply_boolean_type(klass)
+          
+          klass.class_eval <<-EOF
+            alias :#{self.safe_alias}= :#{self._name}=
+            
+            def #{self.safe_alias}
+              ::Boolean.set(read_attribute(:#{self._name}))
+            end            
+          EOF
+          
+        end
+          
+      end
+    
+    end
+  end
+end

data/lib/custom_fields/types/category.rb

@@ -0,0 +1,88 @@
+module CustomFields
+  module Types
+    module Category
+
+      extend ActiveSupport::Concern
+
+      included do
+        embeds_many :category_items, :class_name => 'CustomFields::Types::Category::Item'
+
+        validates_associated :category_items
+
+        accepts_nested_attributes_for :category_items, :allow_destroy => true
+
+        register_type :category, BSON::ObjectID
+      end
+
+      module InstanceMethods
+
+        def ordered_category_items
+          self.category_items.sort { |a, b| (a.position || 0) <=> (b.position || 0) }
+        end
+
+        def category_names
+          self.category_items.collect(&:name)
+        end
+
+        def category_ids
+          self.category_items.collect(&:_id)
+        end
+
+        def apply_category_type(klass)
+          klass.cattr_accessor :"#{self.safe_alias}_items"
+
+          klass.send("#{self.safe_alias}_items=", self.ordered_category_items)
+
+          klass.class_eval <<-EOF
+            def self.#{self.safe_alias}_names
+              self.#{self.safe_alias}_items.collect(&:name)
+            end
+
+            def self.group_by_#{self.safe_alias}(list_method = nil)
+              groups = (if self.embedded?
+                list_method ||= self.association_name
+                self._parent.send(list_method)
+              else
+                list_method ||= :all
+                self.send(list_method)
+              end).to_a.group_by(&:#{self._name})
+
+              self.#{self.safe_alias}_items.collect do |category|
+                {
+                  :name   => category.name,
+                  :items  => groups[category._id] || []
+                }.with_indifferent_access
+              end
+            end
+
+            def #{self.safe_alias}=(id)
+              category = self.class.#{self.safe_alias}_items.find { |item| item.name == id || item._id.to_s == id.to_s }
+              category_id = category ? category._id : nil
+
+              write_attribute(:#{self._name}, category_id)
+            end
+
+            def #{self.safe_alias}
+              category_id = read_attribute(:#{self._name})
+              category = self.class.#{self.safe_alias}_items.find { |item| item._id == category_id }
+              category ? category.name : nil
+            end
+          EOF
+        end
+
+      end
+
+      class Item
+
+        include Mongoid::Document
+
+        field :name
+        field :position, :type => Integer, :default => 0
+
+        embedded_in :custom_field, :inverse_of => :category_items
+
+        validates_presence_of :name
+      end
+    end
+  end
+end