has_easy 0.9.0

data/lib/has_easy/configurator.rb

@@ -0,0 +1,87 @@
+module Izzle
+  module HasEasy
+    class Configurator
+      
+      attr_accessor :definitions, :aliases
+      
+      def initialize(klass, name, options)
+        @klass = klass
+        @name = name
+        @definitions = {}
+        
+        @aliases = []
+        if options.has_key?(:aliases)
+          @aliases = options[:aliases]
+        elsif options.has_key?(:alias)
+          @aliases = [options[:alias]]
+        end
+        @aliases = @aliases.collect{ |a| a.to_s }
+      end
+      
+      def define(name, options = {})
+        name = Helpers.normalize(name)
+        raise ArgumentError, "class #{@klass} has_easy('#{@name}') already defines '#{name}'" if @definitions.has_key?(name)
+        @definitions[name] = Definition.new(name, options)
+      end
+      
+      def do_metaprogramming_magic_aka_define_methods
+        
+        easy_accessors, object_accessors = [], []
+        @definitions.values.each do |definition|
+          
+          easy_accessors << <<-end_eval
+            def #{@name}_#{definition.name}=(value)
+              set_has_easy_thing('#{@name}', '#{definition.name}', value, true)
+            end
+            def #{@name}_#{definition.name}
+              get_has_easy_thing('#{@name}', '#{definition.name}', true)
+            end
+            def #{@name}_#{definition.name}?
+              !!get_has_easy_thing('#{@name}', '#{definition.name}', true)
+            end
+          end_eval
+          
+          object_accessors << <<-end_eval
+            def #{definition.name}=(value)
+              proxy_association.owner.set_has_easy_thing('#{@name}', '#{definition.name}', value)
+            end
+            def #{definition.name}
+              proxy_association.owner.get_has_easy_thing('#{@name}', '#{definition.name}')
+            end
+            def #{definition.name}?
+              !!proxy_association.owner.get_has_easy_thing('#{@name}', '#{definition.name}')
+            end
+          end_eval
+        end
+        
+        method_aliases = @aliases.inject([]) do |memo, alias_name|
+          memo << "alias_method :#{alias_name}, :#{@name}"
+          @definitions.values.each do |definition|
+            memo << "alias_method :#{alias_name}_#{definition.name}=, :#{@name}_#{definition.name}="
+            memo << "alias_method :#{alias_name}_#{definition.name},  :#{@name}_#{definition.name}"
+            memo << "alias_method :#{alias_name}_#{definition.name}?, :#{@name}_#{definition.name}?"
+          end
+          memo
+        end
+        
+        @klass.class_eval <<-end_eval
+          # first define the has many relationship
+          has_many :#{@name}, :class_name => 'HasEasyThing',
+                              :as => :model,
+                              :extend => AssocationExtension,
+                              :dependent => :destroy do
+            #{object_accessors.join("\n")}
+          end
+          
+          # now define the easy accessors
+          #{easy_accessors.join("\n")}
+          
+          # define the aliases
+          #{method_aliases.join("\n")}
+        end_eval
+        
+      end
+      
+    end
+  end
+end

data/lib/has_easy/definition.rb

@@ -0,0 +1,56 @@
+module Izzle
+  module HasEasy
+    class Definition
+      
+      attr_accessor :name
+      attr_accessor :has_type_check,      :type_check
+      attr_accessor :has_validate,        :validate
+      attr_accessor :has_default,         :default
+      attr_accessor :has_default_through, :default_through
+      attr_accessor :has_default_dynamic, :default_dynamic
+      attr_accessor :has_preprocess,      :preprocess
+      attr_accessor :has_postprocess,     :postprocess
+      
+      def initialize(name, options = {})
+        @name = name
+        
+        if options.has_key?(:type_check)
+          @has_type_check = true
+          @type_check = options[:type_check].instance_of?(Array) ? options[:type_check] : [options[:type_check]]
+        end
+        
+        if options.has_key?(:validate)
+          @has_validate = true
+          @validate = options[:validate]
+        end
+        
+        if options.has_key?(:default)
+          @has_default = true
+          @default = options[:default]
+        end
+        
+        if options.has_key?(:default_through)
+          @has_default_through = true
+          @default_through = options[:default_through]
+        end
+        
+        if options.has_key?(:default_dynamic)
+          @has_default_dynamic = true
+          @default_dynamic = options[:default_dynamic]
+        end
+        
+        if options.has_key?(:preprocess)
+          @has_preprocess = true
+          @preprocess = options[:preprocess]
+        end
+        
+        if options.has_key?(:postprocess)
+          @has_postprocess = true
+          @postprocess = options[:postprocess]
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/has_easy/errors.rb

@@ -0,0 +1,4 @@
+module HasEasy
+  class ValidationError < RuntimeError
+  end
+end

data/lib/has_easy/helpers.rb

@@ -0,0 +1,11 @@
+module Izzle
+  module HasEasy
+    module Helpers
+    
+      def self.normalize(s)
+        s.to_s.downcase
+      end
+    
+    end
+  end
+end

data/lib/has_easy.rb

@@ -0,0 +1,133 @@
+require 'has_easy/association_extension'
+require 'has_easy/configurator'
+require 'has_easy/definition'
+require 'has_easy/errors'
+require 'has_easy/helpers'
+require 'has_easy_thing'
+
+module Izzle
+  
+  module HasEasy
+    
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      
+      def has_easy(context = nil, options = {})
+        context = Helpers.normalize(context)
+        
+        # initialize the class instance var to hold our configuration info
+        class << self
+          attr_accessor :has_easy_configurators unless method_defined?(:has_easy_configurators)
+        end
+        self.has_easy_configurators = {} if self.has_easy_configurators.nil?
+        
+        # don't let the user redefine a context
+        raise ArgumentError, "class #{self} already has_easy('#{context}')" if self.has_easy_configurators.has_key?(context)
+        
+        
+        
+        configurator = Configurator.new(self, context, options)
+        yield configurator
+        configurator.do_metaprogramming_magic_aka_define_methods
+        has_easy_configurators[context] = configurator
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      def set_has_easy_thing(context, name, value, do_preprocess = false)
+        context = Helpers.normalize(context)
+        name = Helpers.normalize(name)
+        
+        # TODO dry this shit out, it's a copy/paste job with get_has_easy_thing
+        
+        # check to make sure the context exists
+        raise ArgumentError, "has_easy('#{context}') is not defined for class #{self.class}" \
+          unless self.class.has_easy_configurators.has_key?(context)
+        configurator = self.class.has_easy_configurators[context]
+        
+        # check to make sure the name of the thing exists
+        raise ArgumentError, "'#{name}' not defined for has_easy('#{context}') for class #{self.class}" \
+          unless configurator.definitions.has_key?(name)
+        definition = configurator.definitions[name]
+        
+        # do preprocess here, type_check and validate can be done as AR validation in HasEasyThing
+        value = definition.preprocess.call(value) if do_preprocess and definition.has_preprocess
+        
+        # invoke the assocation
+        things = send(context)
+        
+        # if thing already exists, update it, otherwise add a new one
+        thing = things.detect{ |thing| thing.name == name }
+        if thing.blank?
+          thing = HasEasyThing.new :context => context,
+                                   :name => name,
+                                   :value => value
+          thing.model = self
+          #thing.set_model_target(self) # for the bug regarding thing's validation trying to invoke the 'model' assocation when self is a new record
+          send("#{context}").send("<<", thing)
+        else
+          thing.value = value
+        end
+        
+        thing.value
+        
+      end
+      
+      def get_has_easy_thing(context, name, do_postprocess = false)
+        context = Helpers.normalize(context)
+        name = Helpers.normalize(name)
+        
+        # check to make sure the context exists
+        raise ArgumentError, "has_easy('#{context}') is not defined for class #{self.class}" \
+          unless self.class.has_easy_configurators.has_key?(context)
+        configurator = self.class.has_easy_configurators[context]
+        
+        # check to make sure the name of the thing exists
+        raise ArgumentError, "'#{name}' not defined for has_easy('#{context}') for class #{self.class}" \
+          unless configurator.definitions.has_key?(name)
+        definition = configurator.definitions[name]
+        
+        # invoke the association
+        things = send(context)
+        
+        # try to find what they are looking for
+        thing = things.detect{ |thing| thing.name == name }
+        
+        # if the thing isn't found, try to fallback on a default
+        if thing.blank?
+          # TODO break all these nested if statements out into helper methods, i like prettier code
+          # TODO raise an exception if we don't respond to default_through or the resulting object doesn't respond to the context
+          if definition.has_default_through and respond_to?(definition.default_through) and (through = send(definition.default_through)).blank? == false
+            value = through.send(context)[name]
+          elsif definition.has_default_dynamic
+            if definition.default_dynamic.instance_of?(Proc)
+              value = definition.default_dynamic.call(self)
+            else
+              # TODO raise an exception if we don't respond to default_dynamic
+              value = send(definition.default_dynamic)
+            end
+          elsif definition.has_default
+            value = Marshal::load(Marshal.dump(definition.default)) # BUGFIX deep cloning default values
+          else
+            value = nil
+          end
+        else
+          value = thing.value
+        end
+        
+        value = definition.postprocess.call(value) if do_postprocess and definition.has_postprocess
+        value
+      end
+      
+    end
+    
+  end
+  
+end
+ActiveRecord::Base.send(:include, Izzle::HasEasy)

data/lib/has_easy_thing.rb

@@ -0,0 +1,49 @@
+class HasEasyThing < ActiveRecord::Base
+  belongs_to :model, :polymorphic => true
+  attr_accessor :model_cache, :definition, :value_cache
+  before_validation :get_definition
+  validate :validate_type_check, :validate_validate
+  
+  def get_definition
+    self.model_cache = model if model_cache.blank?
+    self.definition = model_cache.class.has_easy_configurators[self.context].definitions[self.name] if self.definition.blank?
+  end
+  
+  def validate_type_check
+    return unless definition.has_type_check
+    self.errors.add(:value, "has_easy type check failed for '#{self.name}'") unless definition.type_check.include?(value.class)
+  end
+  
+  def validate_validate
+    return unless definition.has_validate
+    success = true
+    
+    if definition.validate.instance_of?(Array) and definition.validate.include?(value) == false
+      success = false
+    elsif definition.validate.instance_of?(Symbol)
+      success = model_cache.send(definition.validate, value)
+    elsif definition.validate.instance_of?(Proc)
+      begin
+        success = definition.validate.call(value)
+      rescue HasEasy::ValidationError
+        success = false
+      end
+    end
+    
+    if success == false
+      self.errors[:base] << "has_easy validation failed for '#{self.name}'"
+    elsif success.instance_of?(Array)
+      success.each{ |message| self.errors[:base] << message }
+    end
+  end
+  
+  def value=(v)
+    method_missing(:value=, v.to_yaml)
+    self.value_cache = v
+  end
+  
+  def value
+    self.value_cache ||= YAML.load(method_missing(:value))
+  end
+  
+end

data/lib/tasks/has_easy_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :has_easy do
+#   # Task goes here
+# end

data/test/test_has_easy.rb

@@ -0,0 +1,337 @@
+require 'test/unit'
+
+require 'rubygems'
+require 'active_record'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require File.dirname(__FILE__) + '/../init'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+# AR keeps printing annoying schema statements
+$stdout = StringIO.new
+
+def setup_db
+  ActiveRecord::Base.logger
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :has_easy_user_tests, :force => true do |t|
+      t.integer :client_id
+    end
+    create_table :has_easy_client_tests, :force => true do
+    end
+    create_table :has_easy_things do |t|
+      t.string  :model_type, :null => false
+      t.integer :model_id, :null => false
+      t.string  :context
+      t.string  :name, :null => false
+      t.string  :value
+      t.timestamps
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class HasEasyClientTest < ActiveRecord::Base
+  has_many :users, :class_name => 'HasEasyUserTest', :foreign_key => 'client_id'
+  has_easy :flags do |f|
+    f.define :default_through_test_1, :default => 'client default'
+  end
+  
+  
+  def self.default_array
+    [1,2,3]
+  end
+  
+end
+
+class HasEasyUserTest < ActiveRecord::Base
+  belongs_to :client, :class_name => 'HasEasyClientTest', :foreign_key => 'client_id'
+  cattr_accessor :count1, :count2
+  @@count1, @@count2 = 0, 0
+  has_easy :preferences, :alias => :prefs do |p|
+    p.define :color
+    p.define :theme, :type_check => String
+    p.define :validate_test_1, :validate => [true, 'true', 1, 't']
+    p.define :validate_test_2, :validate => Proc.new { |value|
+      [true, 'true', 1, 't'].include?(value)
+    }
+    p.define :validate_test_3, :validate => Proc.new { |value|
+      raise HasEasy::ValidationError unless [true, 'true', 1, 't'].include?(value)
+    }
+    p.define :validate_test_4, :validate => :validate_test_4
+    p.define :preprocess_test_1, :preprocess => Proc.new { |value| [true, 'true', 1, 't'].include?(value) ? true : false }
+    p.define :postprocess_test_1, :postprocess => Proc.new { |value| [true, 'true', 1, 't'].include?(value) ? true : false }
+    p.define :form_usage_test, :default => false,
+                               :type_check => [TrueClass, FalseClass],
+                               :preprocess => Proc.new{ |value| value == 'true' },
+                               :postprocess => Proc.new{ |value| value ? 'true' : 'false' }
+  end
+
+  has_easy :flags do |f|
+    f.define :admin
+    f.define :default_test_1, :default => 'funky town'
+    f.define :default_through_test_1, :default => 'user default', :default_through => :client
+    f.define :default_dynamic_test_1, :default_dynamic => :default_dynamic_test_1
+    f.define :default_dynamic_test_2, :default_dynamic => Proc.new{ |user| user.class.count2 += 1 }
+    f.define :default_reference, :default => HasEasyClientTest.default_array # demonstrates a bug found by swaltered
+  end
+  
+  def validate_test_4(value)
+    ["1one", "2two"]
+  end
+  
+  def default_dynamic_test_1
+    self.class.count1 += 1
+  end
+end
+
+class HasEasyTest < Test::Unit::TestCase
+  
+  def setup
+    setup_db
+    HasEasyThing.delete_all
+    @client = HasEasyClientTest.create
+    @user = @client.users.create!
+  end
+
+  def teardown
+    teardown_db
+  end
+  
+  def test_setter_getter
+    @user.set_has_easy_thing(:preferences, :color, 'red')
+    assert_equal 'red', @user.get_has_easy_thing(:preferences, :color)
+    assert_equal 1, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+    
+    @user.set_has_easy_thing(:flags, :admin, true)
+    assert_equal true, @user.get_has_easy_thing(:flags, :admin)
+    assert_equal 2, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+  end
+  
+  def test_array_access
+    @user.preferences[:color] = 'red'
+    assert_equal 'red', @user.preferences[:color]
+    assert_equal 1, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+    
+    @user.flags[:admin] = true
+    assert_equal true, @user.flags[:admin]
+    assert_equal 2, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+  end
+  
+  def test_object_access
+    @user.preferences.color = 'red'
+    assert_equal 'red', @user.preferences.color
+    assert_equal 1, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+    
+    @user.flags.admin = true
+    assert_equal true, @user.flags.admin
+    assert_equal 2, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+  end
+  
+  def test_easy_access
+    @user.preferences_color = 'red'
+    assert_equal 'red', @user.preferences_color
+    assert_equal true, @user.preferences_color?
+    assert_equal 1, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+    
+    @user.flags_admin = true
+    assert_equal true, @user.flags_admin
+    assert_equal true, @user.flags_admin?
+    assert_equal 2, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+  end
+  
+  def test_overwrite
+    @user.preferences[:color] = 'red'
+    assert_equal 'red', @user.preferences[:color]
+    assert_equal 1, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+    
+    @user.preferences[:color] = 'blue'
+    assert_equal 'blue', @user.preferences[:color]
+    assert_equal 1, HasEasyThing.count(:conditions => { :model_type => @user.class.name, :model_id => @user.id })
+  end
+  
+  def test_alias
+    @user.preferences.theme = "savage thunder"
+    assert_equal @user.preferences[:theme], @user.prefs[:theme]
+    assert_equal @user.preferences.theme, @user.prefs.theme
+    assert_equal @user.preferences_theme, @user.prefs_theme
+    assert_equal @user.preferences_theme?, @user.prefs_theme?
+  end
+  
+  def test_type_check
+    @user.preferences.theme = "savage thunder"
+    assert @user.preferences.save
+    
+    @user.preferences.theme = 1
+    assert_raise(ActiveRecord::RecordInvalid){ @user.preferences.save! }
+    
+    assert !@user.preferences.save
+    assert !@user.errors.empty?
+  end
+  
+  def test_validate_1
+    @user.preferences.validate_test_1 = 1
+    assert @user.preferences.save
+    @user.preferences.validate_test_1 = true
+    assert @user.preferences.save
+    @user.preferences.validate_test_1 = 'true'
+    assert @user.preferences.save
+    
+    @user.preferences.validate_test_1 = false
+    assert_raise(ActiveRecord::RecordInvalid){ @user.preferences.save! }
+    assert !@user.preferences.save
+    assert !@user.errors.empty?
+  end
+  
+  def test_validate_2
+    @user.preferences.validate_test_2 = 1
+    assert @user.preferences.save
+    @user.preferences.validate_test_2 = true
+    assert @user.preferences.save
+    @user.preferences.validate_test_2 = 'true'
+    assert @user.preferences.save
+    
+    @user.preferences.validate_test_2 = false
+    assert_raise(ActiveRecord::RecordInvalid){ @user.preferences.save! }
+    assert !@user.preferences.save
+    assert !@user.errors.empty?
+  end
+  
+  def test_validate_3
+    @user.preferences.validate_test_3 = 1
+    assert @user.preferences.save
+    @user.preferences.validate_test_3 = true
+    assert @user.preferences.save
+    @user.preferences.validate_test_3 = 'true'
+    assert @user.preferences.save
+    
+    @user.preferences.validate_test_3 = false
+    assert_raise(ActiveRecord::RecordInvalid){ @user.preferences.save! }
+    assert !@user.preferences.save
+    assert !@user.errors.empty?
+  end
+  
+  def test_validate_4
+    @user.preferences.validate_test_4 = "blah"
+    assert_raise(ActiveRecord::RecordInvalid){ @user.preferences.save! }
+    assert !@user.preferences.save
+    assert 2, @user.errors.get(:preferences).length
+    assert '1one', @user.errors.get(:preferences)[0]
+    assert '2two', @user.errors.get(:preferences)[1]
+    
+    # nasty bug when the parent is a new record
+    user = @user.class.new :preferences_validate_test_4 => "blah"
+    assert !user.save
+    assert 2, @user.errors.get(:preferences).length
+    assert '1one', @user.errors.get(:preferences)[0]
+    assert '2two', @user.errors.get(:preferences)[1]
+  end
+
+  def test_validate_4_has_easy_errors_added_to_base
+    @user.preferences.validate_test_4 = "blah"
+    @user.preferences.save
+    @preference = @user.preferences.detect { |pref|  !pref.errors.empty? }
+    assert_equal ['1one','2two'], @preference.errors.full_messages 
+  end
+  
+  def test_preprocess_1
+    @user.preferences.preprocess_test_1 = "blah"
+    assert_equal "blah", @user.preferences.preprocess_test_1
+    assert_equal "blah", @user.preferences_preprocess_test_1
+    @user.preferences_preprocess_test_1 = "blah"
+    assert_equal false, @user.preferences.preprocess_test_1
+    assert_equal false, @user.preferences_preprocess_test_1
+    
+    @user.preferences.preprocess_test_1 = "true"
+    assert_equal "true", @user.preferences.preprocess_test_1
+    assert_equal "true", @user.preferences_preprocess_test_1
+    @user.preferences_preprocess_test_1 = "true"
+    assert_equal true, @user.preferences.preprocess_test_1
+    assert_equal true, @user.preferences_preprocess_test_1
+  end
+  
+  def test_postprocess_1
+    @user.preferences.postprocess_test_1 = "blah"
+    assert_equal "blah", @user.preferences.postprocess_test_1
+    assert_equal false, @user.preferences_postprocess_test_1
+    
+    @user.preferences.postprocess_test_1 = "true"
+    assert_equal "true", @user.preferences.postprocess_test_1
+    assert_equal true, @user.preferences_postprocess_test_1
+  end
+  
+  def test_default_1
+    assert_equal 'funky town', HasEasyUserTest.new.flags.default_test_1
+    assert_equal 'funky town', @user.flags.default_test_1
+    @user.flags.default_test_1 = "stupid town"
+    assert_equal "stupid town", @user.flags.default_test_1
+    @user.flags.save
+    @user = HasEasyUserTest.find(@user.id)
+    assert_equal "stupid town", @user.flags.default_test_1
+  end
+  
+  def test_default_though_1
+    client = HasEasyClientTest.create
+    user = client.users.create
+    assert_equal 'client default', user.flags.default_through_test_1
+    
+    client.flags.default_through_test_1 = 'not client default'
+    client.flags.save
+    user.client(true)
+    assert_equal 'not client default', user.flags.default_through_test_1
+    
+    user.flags.default_through_test_1 = 'not user default'
+    assert_equal 'not user default', user.flags.default_through_test_1
+    
+    assert_equal 'user default', HasEasyUserTest.new.flags.default_through_test_1
+  end
+  
+  def test_default_dynamic_1
+    assert_equal 1, @user.flags.default_dynamic_test_1
+    assert_equal 2, @user.flags.default_dynamic_test_1
+  end
+  
+  def test_default_dynamic_2
+    assert_equal 1, @user.flags.default_dynamic_test_2
+    assert_equal 2, @user.flags.default_dynamic_test_2
+  end
+  
+  # This is from a bug that swalterd found that has to do with how has_easy assigns default values.
+  # Each thing shares the same default value, so changing it for one will change it for everyone.
+  # The fix is to clone (if possible) the default value when a new HasEasyThing is created.
+  def test_default_reference
+    v = @user.flags.default_reference[0]
+    @user.flags.default_reference[0] = rand(10) + 10
+    new_user = HasEasyUserTest.new
+    assert_equal v, new_user.flags_default_reference[0]
+  end
+  
+  def test_form_usage
+    assert_equal false, @user.prefs.form_usage_test
+    assert_equal 'false', @user.prefs_form_usage_test
+    
+    params = { :person => {:prefs_form_usage_test => 'true'} }
+    assert @user.update_attributes(params[:person])
+    assert_equal true, @user.prefs.form_usage_test
+    assert_equal 'true', @user.prefs_form_usage_test
+    @user.preferences.save!
+    @user = @user.class.find(@user.id)
+    assert_equal true, @user.prefs.form_usage_test
+    assert_equal 'true', @user.prefs_form_usage_test
+    
+    params = { :person => {:prefs_form_usage_test => 'false'} }
+    assert @user.update_attributes(params[:person])
+    assert_equal false, @user.prefs.form_usage_test
+    assert_equal 'false', @user.prefs_form_usage_test
+    @user.preferences.save!
+    @user = @user.class.find(@user.id)
+    assert_equal false, @user.prefs.form_usage_test
+    assert_equal 'false', @user.prefs_form_usage_test
+  end
+  
+end