has_custom_fields 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Marcus Wyatt
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,117 @@
+HasCustomFields
+==============
+
+HasCustomFields allow for the Entity-attribute-value model (EAV), also 
+known as object-attribute-value model and open schema on any of your ActiveRecord
+models. 
+
+= What is Entity-attribute-value model?
+Entity-attribute-value model (EAV) is a data model that is used in circumstances 
+where the number of attributes (properties, parameters) that can be used to describe 
+a thing (an "entity" or "object") is potentially very vast, but the number that will 
+actually apply to a given entity is relatively modest.
+
+= Typical Problem
+A good example of this is where you need to store
+lots (possible hundreds) of optional attributes on an object. My typical
+reference example is when you have a User object. You want to store the
+user's preferences between sessions. Every search, sort, etc in your
+application you want to keep track of so when the user visits that section
+of the application again you can simply restore the display to how it was.
+
+So your controller might have:
+
+  Project.find :all, :conditions => current_user.project_search,
+    :order => current_user.project_order
+
+But there could be hundreds of these little attributes that you really don't
+want to store directly on the user object. It would make your table have too
+many columns so it would be too much of a pain to deal with. Also there might
+be performance problems. So instead you might do something like
+this:
+
+  class User < ActiveRecord::Base
+    has_many :preferences
+  end
+
+  class Preferences < ActiveRecord::Base
+    belongs_to :user
+  end
+
+Now simply give the Preference model a "name" and "value" column and you are
+set..... except this is now too complicated. To retrieve a attribute you will
+need to do something like:
+
+  Project.find :all,
+    :conditions => current_user.preferences.find_by_name('project_search').value,
+    :order => current_user.preferences.find_by_name('project_order').value
+
+Sure you could fix this through a few methods on your model. But what about
+saving?
+
+  current_user.preferences.create :name => 'project_search',
+    :value => "lastname LIKE 'jones%'"
+  current_user.preferences.create :name => 'project_order',
+    :value => "name"
+
+Again this seems to much. Again we could add some methods to our model to
+make this simpler but do we want to do this on every model. NO! So instead
+we use this plugin which does everything for us.
+
+= Capabilities
+
+The HasCustomFields plugin is capable of modeling this problem in a intuitive
+way. Instead of having to deal with a related model you treat all attributes
+(both on the model and related) as if they are all on the model. The plugin
+will try to save all attributes to the model (normal ActiveRecord behavior)
+but if there is no column for an attribute it will try to save it to a
+related model whose purpose is to store these many sparsely populated
+attributes.
+
+The main design goals are:
+
+* Have the eav attributes feel like normal attributes. Simple gets and sets
+  will add and remove records from the related model.
+* Allow for more than one related model. So for example on my User model I might
+  have some eav behavior going into a contact_info table while others are
+  going in a user_preferences table.
+* Allow a model to determine what a valid eav attribute is for a given
+  related model so our model still can generate a NoMethodError.
+
+Example
+=======
+
+Will make the current class have eav behaviour.
+
+  class Post < ActiveRecord::Base
+    has_custom_field_behavior
+  end
+  post = Post.find_by_title 'hello world'
+  puts "My post intro is: #{post.intro}"
+  post.teaser = 'An awesome introduction to the blog'
+  post.save
+
+The above example should work even though "intro" and "teaser" are not
+attributes on the Post model.
+
+= Installation
+
+    ./script/plugin install acts_as_custom_field_model
+
+= RUNNING UNIT TESTS
+
+== Creating the test database
+
+The test databases will be created from the info specified in test/database.yml.
+Either change that file to match your database or change your database to
+match that file.
+
+== Running with Rake
+
+The easiest way to run the unit tests is through Rake. By default sqlite3
+will be the database run. Just change your env variable DB to be the database
+adaptor (specified in database.yml) that you want to use. The database and
+permissions must already be setup but the tables will be created for you
+from schema.rb.
+
+Copyright (c) 2008 Marcus Wyatt, released under the MIT license

data/Rakefile

@@ -0,0 +1,121 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "has_custom_fields"
+    gem.summary = %Q{The easy way to add custom fields to any Rails model.}
+    gem.description = %Q{Uses a vertical schema to add custom fields.}
+    gem.email = "kylejginavan@gmail.com"
+    gem.homepage = "http://github.com/kylejginavan/has_custom_fields"
+    gem.add_dependency('builder')
+    gem.authors = ["kylejginavan"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "has_custom_fields (or a dependency) not available. Install it with: gem install has_custom_fields"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "constantations #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+# require 'rake'
+# require 'rake/testtask'
+# require 'rake/rdoctask'
+# require 'spec/rake/spectask'
+# require 'spec/rake/verify_rcov'
+# 
+# plugin_name = 'acts_as_custom_field_model'
+# 
+# desc 'Default: run specs.'
+# task :default => :spec
+# 
+# desc "Run the specs for #{plugin_name}"
+# Spec::Rake::SpecTask.new(:spec) do |t|
+#   t.spec_files = FileList['spec/**/*_spec.rb']
+#   t.spec_opts  = ["--colour"]
+# end
+# 
+# namespace :spec do
+#   desc "Generate RCov report for #{plugin_name}"
+#   Spec::Rake::SpecTask.new(:rcov) do |t|
+#     t.spec_files  = FileList['spec/**/*_spec.rb']
+#     t.rcov        = true
+#     t.rcov_dir    = 'doc/coverage'
+#     t.rcov_opts   = ['--text-report', '--exclude', "spec/,rcov.rb,#{File.expand_path(File.join(File.dirname(__FILE__),'../../..'))}"] 
+#   end
+# 
+#   namespace :rcov do
+#     desc "Verify RCov threshold for #{plugin_name}"
+#     RCov::VerifyTask.new(:verify => "spec:rcov") do |t|
+#       t.threshold = 100.0
+#       t.index_html = File.join(File.dirname(__FILE__), 'doc/coverage/index.html')
+#     end
+#   end
+#   
+#   desc "Generate specdoc for #{plugin_name}"
+#   Spec::Rake::SpecTask.new(:doc) do |t|
+#     t.spec_files  = FileList['spec/**/*_spec.rb']
+#     t.spec_opts   = ["--format", "specdoc:SPECDOC"]
+#    end
+# 
+#   namespace :doc do
+#     desc "Generate html specdoc for #{plugin_name}"
+#     Spec::Rake::SpecTask.new(:html => :rdoc) do |t|
+#       t.spec_files    = FileList['spec/**/*_spec.rb']
+#       t.spec_opts     = ["--format", "html:doc/rspec_report.html", "--diff"]
+#     end
+#   end
+# end
+# 
+# task :rdoc => :doc
+# task "SPECDOC" => "spec:doc"
+# 
+# desc "Generate rdoc for #{plugin_name}"
+# Rake::RDocTask.new(:doc) do |t|
+#   t.rdoc_dir = 'doc'
+#   t.main     = 'README.rdoc'
+#   t.title    = "#{plugin_name}"
+#   t.template = ENV['RDOC_TEMPLATE']
+#   t.options  = ['--line-numbers', '--inline-source', '--all']
+#   t.rdoc_files.include('README.rdoc', 'SPECDOC', 'MIT-LICENSE', 'CHANGELOG')
+#   t.rdoc_files.include('lib/**/*.rb')
+# end
+# 
+# namespace :doc do 
+#   desc "Generate all documentation (rdoc, specdoc, specdoc html and rcov) for #{plugin_name}"
+#   task :all => ["spec:doc:html", "spec:doc", "spec:rcov", "doc"]
+# end

data/SPECDOC

@@ -0,0 +1,23 @@
+
+ActiveRecord Model annotated with 'has_custom_field_behavior' with no options in declaration
+- should have many attributes
+- should create new attribute on save
+- should delete attribute
+- should write eav attributes to attributes table
+- should return nil when attribute does not exist
+- should use method missing to make attribute seem as native property
+- should read attributes using subscript notation
+- should read the attribute when invoking 'read_attribute'
+
+ActiveRecord Model annotated with 'has_custom_field_behavior' with options in declaration
+- should be 'has_many' association on both sides
+- should only allow restricted fields when specified (:fields => %w(phone aim icq))
+- should raise 'NoMethodError' when attribute not in 'custom_field_attributes' method array
+- should raise 'NoMethodError' when attribute does not satisfy 'is_custom_field_attribute?' method
+
+Validations on ActiveRecord Model annotated with 'has_custom_field_behavior'
+- should execute as normal (validates_presence_of)
+
+Finished in 0.239663 seconds
+
+13 examples, 0 failures

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/has_custom_fields.tmproj

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>documents</key>
+	<array>
+		<dict>
+			<key>name</key>
+			<string>has_custom_fields</string>
+			<key>regexFolderFilter</key>
+			<string>!.*/(\.[^/]*|CVS|log|_darcs|_MTN|\{arch\}|blib|.*~\.nib|.*\.(framework|app|pbproj|pbxproj|xcode(proj)?|bundle))$</string>
+			<key>selected</key>
+			<true/>
+			<key>sourceDirectory</key>
+			<string></string>
+		</dict>
+	</array>
+	<key>fileHierarchyDrawerWidth</key>
+	<integer>200</integer>
+	<key>metaData</key>
+	<dict/>
+	<key>showFileHierarchyDrawer</key>
+	<true/>
+	<key>windowFrame</key>
+	<string>{{2049, 108}, {1203, 1047}}</string>
+</dict>
+</plist>

data/lib/custom_fields/custom_field_base.rb

@@ -0,0 +1,28 @@
+module CustomFields
+  class CustomFieldBase < ActiveRecord::Base
+
+    serialize :select_options
+    validates_presence_of :name,
+      :message => 'Please specify the field name.'
+    validates_presence_of :select_options_csv,
+      :if => "self.style.to_sym == :select",
+      :message => "You must enter options for the selection, separated by commas."
+
+    def self.inherited(chld)
+      super(chld)
+      chld.class_eval <<-FOO
+        validates_uniqueness_of :name, :scope => [:user_id, :organization_id], :message => 'The field name is already taken.'
+        validates_inclusion_of :style, :in => ALLOWABLE_TYPES, :message => "Invalid style.  Should be #{ALLOWABLE_TYPES.join(', ')}."
+      FOO
+    end
+  
+    def select_options_csv
+      (self.select_options || []).join(",")
+    end
+
+    def select_options_csv=(csv)
+      self.select_options = csv.split(",").collect{|f| f.strip}
+    end
+
+  end
+end

data/lib/has_custom_fields.rb

@@ -0,0 +1,398 @@
+module ActiveRecord # :nodoc:
+  module Has # :nodoc:
+    ##
+    # HasCustomFields allow for the Entity-attribute-value model (EAV), also 
+    # known as object-attribute-value model and open schema on any of your ActiveRecord
+    # models. 
+    #
+    module CustomFields
+
+      ALLOWABLE_TYPES = ['select', 'boolean', 'text', 'date']
+
+      Object.const_set('TagFacade', Class.new(Object)).class_eval do
+        def initialize(object_with_custom_fields, scope, scope_id)
+          @object = object_with_custom_fields
+          @scope = scope
+          @scope_id = scope_id
+        end
+        def [](tag)
+          # puts "** Calling get_custom_field_attribute for #{@object.class},#{tag},#{@scope},#{@scope_id}"
+          return @object.get_custom_field_attribute(tag, @scope, @scope_id)
+        end
+      end
+
+      Object.const_set('ScopeIdFacade', Class.new(Object)).class_eval do
+        def initialize(object_with_custom_fields, scope)
+          @object = object_with_custom_fields
+          @scope = scope
+        end
+        def [](scope_id)
+          # puts "** Returning a TagFacade for #{@object.class},#{@scope},#{scope_id}"
+          return TagFacade.new(@object, @scope, scope_id)
+        end
+      end
+
+      Object.const_set('ScopeFacade', Class.new(Object)).class_eval do
+        def initialize(object_with_custom_fields)
+          @object = object_with_custom_fields
+        end
+        def [](scope)
+          # puts "** Returning a ScopeIdFacade for #{@object.class},#{scope}"
+          return ScopeIdFacade.new(@object, scope)
+        end
+      end
+
+      def self.included(base) # :nodoc:
+        base.extend ClassMethods
+      end
+
+      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 = {})
+
+          # 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].tableize.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[: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
+
+          ::Rails.logger.debug("OPTIONS: #{options.inspect}")
+          puts("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 related class. If not create it
+          begin
+            Object.const_get(options[:values_class_name])
+          rescue
+            Object.const_set(options[:fields_class_name],
+              Class.new(::CustomFields::CustomFieldBase)).class_eval do
+                set_table_name options[:fields_table_name]
+                def self.reloadable? #:nodoc:
+                  false
+                end
+              end
+            ::CustomFields.const_set(options[:fields_class_name], Object.const_get(options[:fields_class_name]))
+
+            Object.const_set(options[:values_class_name],
+            Class.new(ActiveRecord::Base)).class_eval do
+              cattr_accessor :custom_field_options
+              belongs_to options[:fields_relationship_name],
+                :class_name => '::CustomFields::' + options[:fields_class_name].singularize
+              alias_method :field, options[:fields_relationship_name]
+              
+              def self.reloadable? #:nodoc:
+                false
+              end
+              
+              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
+            ::CustomFields.const_set(options[:values_class_name], Object.const_get(options[:values_class_name]))
+          end
+
+          # Store options
+          self.custom_field_options[self.name] = options
+
+          # Only mix instance methods once
+          unless self.included_modules.include?(ActiveRecord::Has::CustomFields::InstanceMethods)
+            send :include, ActiveRecord::Has::CustomFields::InstanceMethods
+          end
+
+          # 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
+            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
+          
+          create_attribute_table
+          
+        end
+
+        def custom_field_fields(scope, scope_id)
+          options = custom_field_options[self.name]
+          klass = Object.const_get(options[:fields_class_name])
+          return klass.send("find_all_by_#{scope}_id", scope_id, :order => :id)
+        end
+        
+      end
+
+      module InstanceMethods
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+
+          ##
+          # Rake migration task to create the versioned table using options passed to has_custom_fields
+          #
+          def create_attribute_table(options = {})
+            options = custom_field_options[self.name]
+            klass = Object.const_get(options[:fields_class_name])
+            return if connection.tables.include?(options[:values_table_name])
+
+            # todo: get the real pkey type and name
+            scope_fkeys = options[:scopes].collect{|s| "#{s.to_s}_id"}
+            
+            ActiveRecord::Base.transaction do
+            
+              self.connection.create_table(options[:fields_table_name], options) do |t|
+                t.string options[:name_field], :null => false
+                t.string :style, :null => false
+                t.string :select_options
+                scope_fkeys.each do |s|
+                  t.integer s
+                end
+                t.timestamps
+              end
+              self.connection.add_index options[:fields_table_name], scope_fkeys + [options[:name_field]], :unique => true
+            
+              # add foreign keys for scoping tables
+              options[:scopes].each do |s|
+                self.connection.execute <<-FOO
+                  alter table #{options[:fields_table_name]}
+                    add foreign key (#{s.to_s}_id)
+                    references
+                    #{eval(s.to_s.classify).table_name}(#{eval(s.to_s.classify).primary_key})
+                FOO
+              end
+              
+              # add xor constraint
+              if !options[:scopes].empty? 
+                self.connection.execute <<-FOO
+                  alter table #{options[:fields_table_name]} add constraint scopes_xor check
+                    (1 = #{options[:scopes].collect{|s| "(#{s.to_s}_id is not null)::integer"}.join(" + ")})
+                FOO
+              end
+              
+              self.connection.create_table(options[:values_table_name], options) do |t|
+                t.integer options[:foreign_key], :null => false
+                t.integer options[:fields_table_name].foreign_key, :null => false
+                t.string options[:value_field], :null => false
+
+                t.timestamps
+              end
+              
+              self.connection.add_index options[:values_table_name], options[:foreign_key]
+              self.connection.add_index options[:values_table_name], options[:fields_table_name].foreign_key
+              
+              self.connection.execute <<-FOO
+                alter table #{options[:values_table_name]} 
+                add foreign key (#{options[:fields_table_name].foreign_key})
+                references #{options[:fields_table_name]}(#{eval(options[:fields_class_name]).primary_key})
+              FOO
+            end
+          end
+
+          ##
+          # Rake migration task to drop the attribute table
+          #
+          def drop_attribute_table(options = {})
+            options = custom_field_options[self.name]
+            self.connection.drop_table options[:values_table_name]
+          end
+
+          def drop_field_table(options = {})
+            options = custom_field_options[self.name]
+            self.connection.drop_table options[:fields_table_name]
+          end
+
+        end
+
+        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|
+                self.set_custom_field_attribute(k, v, scope, scope_id)
+              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)
+          ::Rails.logger.debug("scope/id is: #{scope}/#{scope_id}")
+          options = custom_field_options[self.class.name]
+          model_fkey = options[:foreign_key]
+          fields_class = options[:fields_class_name]
+          values_class = options[:values_class_name]
+          value_field = options[:value_field]
+          fields_fkey = options[:fields_table_name].foreign_key
+          fields = Object.const_get(fields_class)
+          values = Object.const_get(values_class)
+          ::Rails.logger.debug("fkey is: #{fields_fkey}")
+          ::Rails.logger.debug("fields class: #{fields.to_s}")
+          ::Rails.logger.debug("values class: #{values.to_s}")
+          f = fields.send("find_by_name_and_#{scope}_id", attribute_name, scope_id)
+          raise "No field #{attribute_name} for #{scope} #{scope_id}" if f.nil?
+          ::Rails.logger.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"
+            ::Rails.logger.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?
+
+          ::Rails.logger.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"
+            ::Rails.logger.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
+  end
+end
+
+ActiveRecord::Base.send :include, ActiveRecord::Has::CustomFields