has_custom_fields 0.0.5 → 0.1.1

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+gemspec
+
+group :development do
+  gem 'ruby-debug19'
+end

data/README.md

@@ -0,0 +1,114 @@
+HasCustomFields
+========================
+
+HasCustomFields provides you with a way to have multiple scoped dynamic key value,
+attribute stores persisted in the database for any given model.  These are also
+known as the Entity-Attribute-Value model (EAV).
+
+
+Installation
+------------------------
+
+In your Gemfile:
+
+    gem "has_custom_fields"
+
+Do a bundle install, then for each model you want to have custom fields (say User
+with an organization scope for the fields and attributes) do the following:
+
+    $ rails generate has_custom_fields:install User organization
+
+Then check and run the generated migrations
+
+    $ rake db:migrate
+
+Then add the has_custom_fields class method to your model:
+
+    class User < ActiveRecord::Base
+      has_custom_fields :scopes => [:organization]
+    end
+
+For Rails 2.x users please depend on the 0.0.5 version of the gem
+
+
+Description
+-------------------------  
+
+### 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
+-------------------------
+
+Say you have a contact management system, and each person in the database belongs
+to an organisation.  That organization may have a bunch of values that need to be
+stored in the database, such as, primary contact name, or hot prospect?
+
+Each of these could be stored as column values on the organization table, but
+you could have 10-20 of these, and adding a new one would require a database change.
+
+HasCustomFields allows you to define these key values simply with an attribute
+type.
+
+
+Example
+-------------------------
+
+Following on from the installation section above, we have a User with the following
+custom fields setting:
+
+    class User < ActiveRecord::Base
+      has_custom_fields :scopes => [:organization]
+    end
+
+We can now find the custom fields for the organization.
+
+    @organization = @user.organization
+    @organization_fields = User.custom_field_fields(:organization, @organization.id)
+
+This returns an array full of UserFields that will look something like:
+
+    UserField id: 104, name: "High Potential", style: "checkbox", select_options: nil
+
+Which could then be rendered out into a HTML page like so (logic in HTML for demonstration purposes, would be better to do this as a helper method)
+
+    <% @organization_fields.each do |field| %>
+      <p>
+      <% case field.style %>
+      <% when 'checkbox' %>
+        <%= f.check_box field.name %>
+      <% when 'text' %>
+        <%= f.text_field field.name, @user.custom_fields[:organization][@organization.id]['High Potential'] %>
+      <% end %>
+      </p>
+    <% end %>
+
+Running the Specs
+========================
+
+Ruby Environment
+------------------------
+
+You should run the unit tests under ruby-1.9.2, a sample .rvmrc would be:
+
+  $ cat .rvmrc
+  rvm ruby-1.9.2@has_custom_fields --create
+
+Once you have the right ruby, you should bundle install.  Running the specs then
+is done with:
+
+  $ rake spec
+
+Creating the test database
+------------------------
+
+The test databases will be created from the info specified in spec/db/database.yml.
+Either change that file to match your database or change your database to
+match that file.
+
+Copyright (c) 2008 Marcus Wyatt, released under the MIT license

data/Rakefile

@@ -1,121 +1,30 @@
-require 'rubygems'
-require 'rake'
-
+#!/usr/bin/env 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
+  require 'bundler/setup'
 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
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
 begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
+  require 'rdoc/task'
 rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
+  require 'rdoc/rdoc'
+  require 'rake/task'
+  RDoc::Task = Rake::RDocTask
 end
 
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
+RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "constantations #{version}"
-  rdoc.rdoc_files.include('README*')
+  rdoc.title    = 'CustomFields'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
+Bundler::GemHelper.install_tasks
 
+task :spec do
+  sh("bundle exec rspec spec") { |ok, res| }
+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
+task :default => :spec

data/has_custom_fields.gemspec

@@ -1,48 +1,41 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'has_custom_fields/version'
 
 Gem::Specification.new do |s|
   s.name = %q{has_custom_fields}
-  s.version = "0.0.5"
+  s.version = HasCustomFields::VERSION
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["kylejginavan"]
-  s.date = %q{2012-01-27}
+  s.date = %q{2012-02-21}
   s.description = %q{Uses a vertical schema to add custom fields.}
   s.email = %q{kylejginavan@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
+    "Gemfile",
+    "init.rb",
+    "Rakefile",
     "LICENSE",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
-    "SPECDOC",
-    "VERSION",
     "has_custom_fields.gemspec",
-    "has_custom_fields.tmproj",
-    "lib/custom_fields/custom_field_base.rb",
+    "lib/has_custom_fields/base.rb",
+    "lib/has_custom_fields/class_methods.rb",
+    "lib/has_custom_fields/instance_methods.rb",
+    "lib/has_custom_fields/railtie.rb",
+    "lib/has_custom_fields/version.rb",
     "lib/has_custom_fields.rb",
-    "spec/database.yml",
-    "spec/debug.log",
-    "spec/fixtures/document.rb",
-    "spec/fixtures/people.yml",
-    "spec/fixtures/person.rb",
-    "spec/fixtures/person_contact_infos.yml",
-    "spec/fixtures/post.rb",
-    "spec/fixtures/post_attributes.yml",
-    "spec/fixtures/posts.yml",
-    "spec/fixtures/preference.rb",
-    "spec/fixtures/preferences.yml",
-    "spec/models/eav_model_with_no_arguments_spec.rb",
-    "spec/models/eav_model_with_options_spec.rb",
-    "spec/models/eav_validation_spec.rb",
-    "spec/rcov.opts",
-    "spec/schema.rb",
-    "spec/spec.opts",
+    "spec/db/database.yml",
+    "spec/db/schema.rb",
+    "spec/test_models/user.rb",
+    "spec/test_models/organization.rb",
+    "spec/has_custom_fields_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/kylejginavan/has_custom_fields}
@@ -50,16 +43,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.5.2}
   s.summary = %q{The easy way to add custom fields to any Rails model.}
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<builder>, [">= 0"])
-    else
-      s.add_dependency(%q<builder>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<builder>, [">= 0"])
-  end
+  s.add_dependency('activerecord', ['>= 3.1.0'])
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('database_cleaner')
+  s.add_development_dependency('sqlite3')
 end
-

data/init.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), "lib", "has_custom_fields")
+require "has_custom_fields/railtie"
+
+HasCustomFields.insert

data/lib/has_custom_fields.rb

@@ -1,401 +1,50 @@
-require 'custom_fields/custom_field_base'
-include ::CustomFields
-
-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', 'checkbox', '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].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[: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}")
-
-          # 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
-
-              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
-            ::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, :limit => 63
-                t.string :style, :null => false, :limit => 15
-                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, 
-                :name => "#{options[:fields_table_name]}_unique_index"
-            
-              # 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].singularize.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].singularize.foreign_key
-              
-              self.connection.execute <<-FOO
-                alter table #{options[:values_table_name]} 
-                add foreign key (#{options[:fields_table_name].singularize.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].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)
-          ::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
+require 'has_custom_fields/class_methods'
+require 'has_custom_fields/instance_methods'
+require 'has_custom_fields/base'
+require 'has_custom_fields/railtie'
+
+##
+# 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 HasCustomFields
+
+  class InvalidScopeError < ActiveRecord::RecordNotFound; end
+
+  ALLOWABLE_TYPES = ['select', 'checkbox', '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
 
-      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
-end
 
-ActiveRecord::Base.send :include, ActiveRecord::Has::CustomFields
+end