has_custom_fields 0.0.5 → 0.1.1

data/lib/has_custom_fields/base.rb

@@ -0,0 +1,20 @@
+module HasCustomFields
+  class Base < ActiveRecord::Base
+    self.abstract_class = true
+    validates_presence_of :name,
+      :message => 'Please specify the field name.'
+    validates_presence_of :select_options_data,
+      :if => "self.style.to_sym == :select",
+      :message => "You must enter options for the selection"
+
+    def select_options_data
+      (self.related_select_options.collect{|o| o.option } || [])
+    end
+
+    def select_options_data=(data)
+      self.select_options = data.split(",").collect{|f| f.strip}
+    end
+
+    #scope :find_all_by_scope, lambda {|scope| {where("#{scope}_id = #{self.id}")}}
+  end
+end

data/lib/has_custom_fields/class_methods.rb

@@ -0,0 +1,212 @@
+module HasCustomFields
+  module ClassMethods
+
+    ##
+    # Will make the current class have eav behaviour.
+    #
+    # The following options are available on for has_custom_fields to modify
+    # the behavior. Reasonable defaults are provided:
+    #
+    # * <tt>value_class_name</tt>:
+    #   The class for the related model. This defaults to the
+    #   model name prepended to "Attribute". So for a "User" model the class
+    #   name would be "UserAttribute". The class can actually exist (in that
+    #   case the model file will be loaded through Rails dependency system) or
+    #   if it does not exist a basic model will be dynamically defined for you.
+    #   This allows you to implement custom methods on the related class by
+    #   simply defining the class manually.
+    # * <tt>table_name</tt>:
+    #   The table for the related model. This defaults to the
+    #   attribute model's table name.
+    # * <tt>relationship_name</tt>:
+    #   This is the name of the actual has_many
+    #   relationship. Most of the type this relationship will only be used
+    #   indirectly but it is there if the user wants more raw access. This
+    #   defaults to the class name underscored then pluralized finally turned
+    #   into a symbol.
+    # * <tt>foreign_key</tt>:
+    #   The key in the attribute table to relate back to the
+    #   model. This defaults to the model name underscored prepended to "_id"
+    # * <tt>name_field</tt>:
+    #   The field which stores the name of the attribute in the related object
+    # * <tt>value_field</tt>:
+    #   The field that stores the value in the related object
+    def has_custom_fields(options = {})
+
+      unless options[:scopes].respond_to?(:each)
+        raise ArgumentError, 'Must define :scope => [] on the has_custom_fields class method'
+      end
+
+      # Provide default options
+      options[:fields_class_name] ||= self.name + 'Field'
+      options[:fields_table_name] ||= options[:fields_class_name].tableize
+      options[:fields_relationship_name] ||= options[:fields_class_name].underscore.to_sym
+
+      options[:values_class_name] ||= self.name + 'Attribute'
+      options[:values_table_name] ||= options[:values_class_name].tableize
+      options[:relationship_name] ||= options[:values_class_name].tableize.to_sym
+      
+      options[:select_options_class_name] ||= self.name + "FieldSelectOption"
+      options[:select_options_table_name] ||= options[:select_options_class_name].tableize
+      options[:select_options_relationship_name] ||= options[:select_options_class_name].pluralize.underscore.to_sym
+      
+      options[:foreign_key] ||= self.name.foreign_key
+      options[:base_foreign_key] ||= self.name.underscore.foreign_key
+      options[:name_field] ||= 'name'
+      options[:value_field] ||= 'value'
+      options[:parent] = self.name
+
+      HasCustomFields.log(:debug, "OPTIONS: #{options.inspect}")
+
+      # Init option storage if necessary
+      cattr_accessor :custom_field_options
+      self.custom_field_options ||= Hash.new
+
+      # Return if already processed.
+      return if self.custom_field_options.keys.include? options[:values_class_name]
+
+      # Attempt to load ModelField related class. If not create it
+      begin
+        Object.const_get(options[:fields_class_name])
+      rescue
+        HasCustomFields.create_associated_fields_class(options)
+      end
+
+      # Attempt to load ModelAttribute related class. If not create it
+      begin
+        Object.const_get(options[:values_class_name])
+      rescue
+        HasCustomFields.create_associated_values_class(options)
+      end
+      
+      # Attempt to load ModelFieldSelectOption related class. If not create it
+      begin
+        Object.const_get(options[:select_options_class_name])
+      rescue
+        HasCustomFields.create_associated_select_options_class(options)
+      end
+
+      # Store options
+      self.custom_field_options[self.name] = options
+
+      # Modify attribute class
+      attribute_class = Object.const_get(options[:values_class_name])
+      base_class = self.name.underscore.to_sym
+
+      attribute_class.class_eval do
+        belongs_to base_class, :foreign_key => options[:base_foreign_key]
+        alias_method :base, base_class # For generic access
+      end
+
+      # Modify main class
+      class_eval do
+        attr_accessible :custom_fields
+        has_many options[:relationship_name],
+          :class_name => options[:values_class_name],
+          :table_name => options[:values_table_name],
+          :foreign_key => options[:foreign_key],
+          :dependent => :destroy
+
+        # The following is only setup once
+        unless method_defined? :read_attribute_without_custom_field_behavior
+
+          # Carry out delayed actions before save
+          after_validation :save_modified_custom_field_attributes, :on => :update
+
+          private
+
+          alias_method_chain :read_attribute, :custom_field_behavior
+          alias_method_chain :write_attribute, :custom_field_behavior
+        end
+      end
+    end
+
+    def custom_field_fields(scope, scope_id)
+      options = custom_field_options[self.name]
+      klass = Object.const_get(options[:fields_class_name])
+      begin
+        return klass.send("find_all_by_#{scope}_id", scope_id, :order => :id)
+      rescue NoMethodError
+        parent_class = klass.to_s.sub('Field', '')
+        raise InvalidScopeError, "Class #{parent_class} does not have scope :#{scope} defined for has_custom_fields"
+      end
+    end
+
+    private
+
+    def HasCustomFields.create_associated_values_class(options)
+      Object.const_set(options[:values_class_name],
+      Class.new(ActiveRecord::Base)).class_eval do
+        self.table_name = options[:values_table_name]
+
+        cattr_accessor :custom_field_options
+        belongs_to options[:fields_relationship_name],
+          :class_name => '::HasCustomFields::' + options[:fields_class_name].singularize
+        
+        alias_method :field, options[:fields_relationship_name]
+        
+
+        def self.reloadable? #:nodoc:
+          false
+        end
+
+        validates_uniqueness_of options[:foreign_key].to_sym, :scope => "#{options[:fields_relationship_name]}_id".to_sym
+
+        def validate
+          field = self.field
+          raise "Couldn't load field" if !field
+
+          if field.style == "select" && !self.value.blank?
+            # raise self.field.select_options.find{|f| f == self.value}.to_s
+            if field.select_options.find{|f| f == self.value}.nil?
+              raise "Invalid option: #{self.value}.  Should be one of #{field.select_options.join(", ")}"
+              self.errors.add_to_base("Invalid option: #{self.value}.  Should be one of #{field.select_options.join(", ")}")
+              return false
+            end
+          end
+        end
+      end
+      ::HasCustomFields.const_set(options[:values_class_name], Object.const_get(options[:values_class_name]))
+    end
+
+    def HasCustomFields.create_associated_fields_class(options)
+      Object.const_set(options[:fields_class_name],
+        Class.new(::HasCustomFields::Base)).class_eval do
+          self.table_name = options[:fields_table_name]
+          has_many options[:select_options_relationship_name]
+          alias_method :related_select_options, options[:select_options_relationship_name]
+          def self.reloadable? #:nodoc:
+            false
+          end
+          
+          scopes = options[:scopes].map { |f| f.to_s.foreign_key }
+          validates_uniqueness_of :name, :scope => scopes, :message => 'The field name is already taken.'
+
+          validates_inclusion_of :style, :in => ALLOWABLE_TYPES, :message => "Invalid style.  Should be #{ALLOWABLE_TYPES.join(', ')}."
+        end
+      ::HasCustomFields.const_set(options[:fields_class_name], Object.const_get(options[:fields_class_name]))
+    end
+    
+    def HasCustomFields.create_associated_select_options_class(options)
+      Object.const_set(options[:select_options_class_name],
+        Class.new(ActiveRecord::Base)).class_eval do
+          self.table_name = options[:select_options_table_name]
+          belongs_to options[:fields_relationship_name], :class_name => options[:fields_relationship_name].to_s
+
+          validates_presence_of :option, :message => 'The select option cannot be blank'
+
+        end
+      ::HasCustomFields.const_set(options[:select_options_class_name], Object.const_get(options[:select_options_class_name]))
+    end
+
+    def HasCustomFields.log(level, message)
+      if defined?(::Rails)
+        ::Rails.logger.send(level, message)
+      else
+        if ENV['debug'] == 'debug'
+          STDOUT.puts("HasCustomFields #{level}, #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/has_custom_fields/instance_methods.rb

@@ -0,0 +1,124 @@
+module HasCustomFields
+  module InstanceMethods
+
+    def get_custom_field_attribute(attribute_name, scope, scope_id)
+      read_attribute_with_custom_field_behavior(attribute_name, scope, scope_id)
+    end
+
+    def set_custom_field_attribute(attribute_name, value, scope, scope_id)
+      write_attribute_with_custom_field_behavior(attribute_name, value, scope, scope_id)
+    end
+
+    def custom_fields=(custom_fields_data)
+      custom_fields_data.each do |scope, scoped_ids|
+        scoped_ids.each do |scope_id, attrs|
+          attrs.each do |k, v|
+            if v.blank?
+              value_object = get_value_object(k, scope, scope_id)
+              value_object.delete
+            else
+              self.set_custom_field_attribute(k, v, scope, scope_id)
+            end
+          end
+        end
+      end
+    end
+
+    def custom_fields
+      return ScopeFacade.new(self)
+    end
+
+    private
+
+    ##
+    # Called after validation on update so that eav attributes behave
+    # like normal attributes in the fact that the database is not touched
+    # until save is called.
+    #
+    def save_modified_custom_field_attributes
+      return if @save_attrs.nil?
+      @save_attrs.each do |s|
+        if s.value.nil? || (s.respond_to?(:empty) && s.value.empty?)
+          s.destroy if !s.new_record?
+        else
+          s.save
+        end
+      end
+      @save_attrs = []
+    end
+
+    def get_value_object(attribute_name, scope, scope_id)
+      HasCustomFields.log(:debug, "scope/id is: #{scope}/#{scope_id}")
+      options = custom_field_options[self.class.name]
+      model_fkey = options[:foreign_key].singularize
+      fields_class = options[:fields_class_name]
+      values_class = options[:values_class_name]
+      value_field = options[:value_field]
+      fields_fkey = options[:fields_table_name].singularize.foreign_key
+      fields = Object.const_get(fields_class)
+      values = Object.const_get(values_class)
+      HasCustomFields.log(:debug, "fkey is: #{fields_fkey}")
+      HasCustomFields.log(:debug, "fields class: #{fields.to_s}")
+      HasCustomFields.log(:debug, "values class: #{values.to_s}")
+      HasCustomFields.log(:debug, "scope is: #{scope}")
+      HasCustomFields.log(:debug, "scope_id is: #{scope_id}")
+      HasCustomFields.log(:debug, "attribute_name is: #{attribute_name}")
+
+      f = fields.send("find_by_name_and_#{scope}_id", attribute_name, scope_id)
+      
+      raise(ActiveRecord::RecordNotFound, "No field #{attribute_name} for #{scope} #{scope_id}") if f.nil?
+
+      HasCustomFields.log(:debug, "field: #{f.inspect}")
+      field_id = f.id
+      model_id = self.id
+      value_object = values.send("find_by_#{model_fkey}_and_#{fields_fkey}", model_id, field_id)
+
+      if value_object.nil?
+        value_object = values.new model_fkey => self.id,
+          fields_fkey => f.id
+      end
+      return value_object
+    end
+
+    ##
+    # Overrides ActiveRecord::Base#read_attribute
+    #
+    def read_attribute_with_custom_field_behavior(attribute_name, scope = nil, scope_id = nil)
+      return read_attribute_without_custom_field_behavior(attribute_name) if scope.nil?
+      value_object = get_value_object(attribute_name, scope, scope_id)
+      case value_object.field.style
+      when "date"
+        HasCustomFields.log(:debug, "reading date object: #{value_object.value}")
+        return Date.parse(value_object.value) if value_object.value
+      end
+      return value_object.value
+    end
+
+    ##
+    # Overrides ActiveRecord::Base#write_attribute
+    #
+    def write_attribute_with_custom_field_behavior(attribute_name, value, scope = nil, scope_id = nil)
+      return write_attribute_without_custom_field_behavior(attribute_name, value) if scope.nil?
+
+      HasCustomFields.log(:debug, "attribute_name(#{attribute_name}) value(#{value.inspect}) scope(#{scope}) scope_id(#{scope_id})")
+      value_object = get_value_object(attribute_name, scope, scope_id)
+      case value_object.field.style
+      when "date"
+        HasCustomFields.log(:debug, "date object: #{value["date(1i)"].to_i}, #{value["date(2i)"].to_i}, #{value["date(3i)"].to_i}")
+        begin
+          new_date = !value["date(1i)"].empty? && !value["date(2i)"].empty? && !value["date(3i)"].empty? ?
+            Date.civil(value["date(1i)"].to_i, value["date(2i)"].to_i, value["date(3i)"].to_i) :
+            nil
+        rescue ArgumentError
+          new_date = nil
+        end
+        value_object.send("value=", new_date) if value_object
+      else
+        value_object.send("value=", value) if value_object
+      end
+      @save_attrs ||= []
+      @save_attrs << value_object
+    end
+
+  end
+end

data/lib/has_custom_fields/railtie.rb

@@ -0,0 +1,25 @@
+require 'has_custom_fields'
+
+module HasCustomFields
+  
+  def HasCustomFields.insert
+    unless ActiveRecord::Base.included_modules.include?(HasCustomFields::InstanceMethods)
+      ActiveRecord::Base.extend HasCustomFields::ClassMethods
+      ActiveRecord::Base.send :include, HasCustomFields::InstanceMethods
+    end
+  end
+
+  if defined?(::Rails::Railtie)
+    require "rails"
+    
+    class Railtie < Rails::Railtie
+      initializer "has_custom_fields.extend_active_record" do
+        ActiveSupport.on_load(:active_record) do
+          HasCustomFields.insert
+        end
+      end
+    end
+  else
+    HasCustomFields.insert
+  end
+end

data/lib/has_custom_fields/version.rb

@@ -0,0 +1,3 @@
+module HasCustomFields
+  VERSION = "0.1.1"
+end

data/spec/db/database.yml

@@ -0,0 +1,21 @@
+sqlite:
+  adapter: sqlite
+  database: spec/db/test.sqlite
+
+sqlite3:
+  adapter: sqlite3
+  database: spec/db/test.sqlite3
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: has_custom_fields_plugin_test
+  min_messages: ERROR
+
+mysql:
+  adapter: mysql
+  host: localhost
+  username: root
+  password:
+  database: has_custom_fields_plugin_test

data/spec/db/schema.rb

@@ -0,0 +1,43 @@
+# require File.join(File.dirname(__FILE__), 'fixtures/document')
+
+ActiveRecord::Schema.define(:version => 0) do
+
+  create_table "organizations", :force => true do |t|
+    t.string   "name", :null => false
+    t.string   "category"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "users", :force => true do |t|
+    t.string   "name"
+    t.string   "email"
+    t.integer  "organization_id"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+    
+  create_table "user_attributes", :force => true do |t|
+    t.integer  "user_id", :null => false
+    t.integer  "user_field_id", :null => false
+    t.string   "value", :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "user_fields", :force => true do |t|
+    t.string   "name", :null => false, :limit => 63
+    t.string   "style", :null => false, :limit => 15
+    t.integer  "organization_id"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+  
+  create_table "user_field_select_options", :force => true do |t|
+    t.integer "user_field_id"
+    t.string "option"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+    
+end