hattr_accessor 1.1.0

data/CHANGELOG

@@ -0,0 +1,31 @@
+2009-03-05 - Sean Huber (shuber@huberry.com)
+  * Merge pixeltrix/master
+  * Include Huberry::HattrAccessor in Object instead of Class
+  * Update README
+  * Update gemspec
+
+2009-01-18 - Sean Huber (shuber@huberry.com)
+  * Boolean type casted empty strings should return false
+
+2009-01-12 - Sean Huber (shuber@huberry.com)
+  * Check for existing reader and writer methods separately before creating default ones for options[:attribute]
+  * Remove alias_method_chain - unnecessary
+
+2009-01-10 - Sean Huber (shuber@huberry.com)
+  * Object includes Huberry::AliasMethodChain instead of Module
+  * Remove init.rb
+
+2009-01-08 - Sean Huber (shuber@huberry.com)
+  * Update CHANGELOG email addresses
+  * Remove .gitignore
+  * Update README
+  * Move include logic into the main hattr_accessor file
+
+2008-10-17 - Sean Huber (shuber@huberry.com)
+	* Refactor #{attribute}_with_hattr_accessor method
+	* Rename doc/README.markdown to doc/README
+
+2008-10-14 - Sean Huber (shuber@huberry.com)
+	* Initial import
+	* Update README
+	* Add tests to ensure errors are raised when :attribute does not exist

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sean Huber (shuber@huberry.com)
+ 
+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.markdown

@@ -0,0 +1,115 @@
+hattr\_accessor
+===============
+
+Allows you to define attr\_accessors that reference members of a hash
+
+
+Installation
+------------
+
+	gem install shuber-hattr_accessor --source http://gems.github.com
+
+
+Usage
+-----
+
+The hattr\_accessor method requires an option named `:attribute` which should be name of an attribute which will store the hash. For example:
+
+	class DataSource
+	  hattr_accessor :adapter, :username, :password, :attribute => :credentials
+	end
+
+The reader and writer methods for `:attribute` (`:credentials` in the example above) would be automatically created unless they exist already. 
+You can then use those attributes like normal ones:
+
+	@data_source = DataSource.new
+	@data_source.adapter = 'mysql'
+	@data_source.username = 'root'
+	@data_source.credentials # { :adapter => 'mysql', :username => 'root' }
+	
+	@data_source.credentials = {}
+	@data_source.adapter # nil
+
+The reader method for `:attribute` is overwritten with logic to ensure that it returns a hash by default.
+
+	@data_source = DataSource.new
+	@data_source.credentials # {}
+
+You may optionally pass a `:type` option which will type cast the values when calling their getter methods. This is useful if you're using this 
+gem with rails which will pass values as strings if submitted from a form. For example:
+
+	class CustomField::Date < CustomField
+	  hattr_accessor :offset, :type => :integer, :attribute => :configuration
+	  hattr_accessor :unit, :reference, :type => :string, :attribute => :configuration
+	  
+	  def default_value
+	    self.offset.send(self.unit.to_sym).send(self.reference.to_sym)
+	  end
+	end
+	
+	@custom_field = CustomField::Date.new(:offset => '5', :unit => 'days', :reference => 'from_now')
+	@custom_field.offset # 5 (notice it's an integer, not a string)
+	@custom_field.default_value # evaluates 5.days.from_now 
+
+The current options (email me for suggestions for others) for `:type` are:
+
+	:string
+	:integer
+	:float
+	:boolean
+	:decimal
+	:array
+
+To specify a default value for a member use the `:default` option. For example:
+
+	class DataSource
+	  hattr_accessor :adapter, :default => 'mysql', :attribute => :credentials
+	  hattr_accessor :username, :default => 'root', :attribute => :credentials
+	  hattr_accessor :password, :attribute => :credentials
+	end
+	
+	@data_source = DataSource.new
+	@data_source.adapter # 'mysql'
+
+You can also specify a proc for the default value. For example:
+
+	class DataSource
+	  hattr_accessor :adapter, :default => 'mysql', :attribute => :credentials
+	  hattr_accessor :username, :attribute => :credentials,
+	                 :default => lambda { |datasource| Etc.getpwuid(Process.uid).name }
+	  hattr_accessor :password, :attribute => :credentials
+	end
+	
+	@data_source = DataSource.new
+	@data_source.username # 'process_username'
+
+If you want to take advantage of type casting but also want to return `nil` if a value has not been set then use the `:allow_nil` option. 
+By default `:allow_nil` is false for typed members but true for non-typed members. For example:
+
+	class DataSource
+	  hattr_accessor :adapter, :type => :string, :allow_nil => true, :attribute => :credentials
+	  hattr_accessor :username, :type => :string, :attribute => :credentials
+	  hattr_accessor :password, :attribute => :credentials
+	end
+	
+	@data_source = DataSource.new
+	@data_source.adapter # nil
+	@data_source.username # ''
+	@data_source.password # nil
+
+NOTE: Make sure your call `define_attribute_methods` before calling `hattr_accessor` when you're using ActiveRecord and your `:attribute` is a 
+database field. The call to `define_attribute_methods` must be after the `serialize` call so that `define_attribute_methods` knows about the 
+serialized field.
+
+	class CustomField < ActiveRecord::Base	  
+	  serialize :configuration, Hash
+	  define_attribute_methods
+	  
+	  hattr_accessor :testing, :attribute => :configuration
+	end
+
+
+Contact
+-------
+
+Problems, comments, and suggestions all welcome: [shuber@huberry.com](mailto:shuber@huberry.com)

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'hattr_accessor'
+    gem.summary = 'Allows you to define attr_accessors that reference members of a hash'
+    gem.description = 'Allows you to define attr_accessors that reference members of a hash'
+    gem.email = 'shuber@huberry.com'
+    gem.homepage = 'http://github.com/shuber/hattr_accessor'
+    gem.authors = ['Sean Huber']
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler'
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << '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 :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hattr_accessor #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/hattr_accessor.gemspec

@@ -0,0 +1,51 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hattr_accessor}
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sean Huber"]
+  s.date = %q{2010-01-06}
+  s.description = %q{Allows you to define attr_accessors that reference members of a hash}
+  s.email = %q{shuber@huberry.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "hattr_accessor.gemspec",
+     "lib/hattr_accessor.rb",
+     "test/active_record_test.rb",
+     "test/fixtures/manufacturers.yml",
+     "test/fixtures/products.yml",
+     "test/hattr_accessor_test.rb"
+  ]
+  s.homepage = %q{http://github.com/shuber/hattr_accessor}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Allows you to define attr_accessors that reference members of a hash}
+  s.test_files = [
+    "test/active_record_test.rb",
+     "test/hattr_accessor_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/hattr_accessor.rb

@@ -0,0 +1,115 @@
+require 'bigdecimal'
+
+module Huberry
+  module HattrAccessor
+    class MissingAttributeError < StandardError; self; end
+
+    def hattr_defined?(attribute)
+      hattr_attributes.include?(attribute.to_sym)
+    end
+
+    def hattr_attributes
+      @hattr_attributes ||= []
+    end
+
+    def hattr_accessor(*attrs)
+      options = attrs.last.is_a?(Hash) ? attrs.pop : {}
+
+      raise MissingAttributeError, 'Must specify the :attribute option with the name of an attribute which will store the hash' if options[:attribute].nil?
+
+      attrs.each do |name|
+        hattr_attributes << name
+
+        # Defines a type casting getter method for each attribute
+        #
+        define_method name do
+          value = send("#{name}_before_type_cast".to_sym)
+          return value if options[:allow_nil] && value.nil?
+          case options[:type]
+            when :string
+              value.to_s
+            when :symbol
+              value.to_s.to_sym
+            when :integer
+              value.to_i
+            when :float
+              value.to_f
+            when :boolean
+              ![false, nil, 0, '0', ''].include?(value)
+            when :decimal
+              BigDecimal.new(value.to_s)
+            when :array
+              Array(value)
+            else
+              value
+          end
+        end
+
+        # Defines a predicate method for each attribute
+        #
+        define_method "#{name}?" do
+          send(name) ? true : false
+        end
+
+        # Defines a setter method for each attribute
+        #
+        define_method "#{name}=" do |value|
+          send(options[:attribute])[name] = value
+        end
+
+        # Define a *_before_type_cast method so that we can validate
+        #
+        define_method "#{name}_before_type_cast" do
+          send(options[:attribute]).key?(name) ? send(options[:attribute])[name] : (options[:default].respond_to?(:call) ? options[:default].call(self) : options[:default])
+        end
+      end
+
+      # Create the reader for #{options[:attribute]} unless it exists already
+      #
+      attr_reader options[:attribute] unless instance_methods.include?(options[:attribute].to_s)
+
+      # Create the writer for #{options[:attribute]} unless it exists already
+      #
+      attr_writer options[:attribute] unless instance_methods.include?("#{options[:attribute]}=")
+
+      # Overwrites the method passed as the :attribute option to ensure that it is a hash by default
+      #
+      unless instance_methods.include?("#{options[:attribute]}_with_hattr_accessor")
+        class_eval <<-EOF
+          def #{options[:attribute]}_with_hattr_accessor
+            self.#{options[:attribute]} = {} if #{options[:attribute]}_without_hattr_accessor.nil?
+            #{options[:attribute]}_without_hattr_accessor
+          end
+          alias_method :#{options[:attribute]}_without_hattr_accessor, :#{options[:attribute]}
+          alias_method :#{options[:attribute]}, :#{options[:attribute]}_with_hattr_accessor
+        EOF
+      end
+    end
+
+    module ActiveRecordExtensions
+      def self.included(base)
+        base.class_eval do
+
+          def read_attribute_with_hattr_accessor(attribute)
+            self.class.hattr_defined?(attribute) ? send(attribute) : read_attribute_without_hattr_accessor(attribute)
+          end
+          alias_method_chain :read_attribute, :hattr_accessor
+
+          def write_attribute_with_hattr_accessor(attribute, value)
+            self.class.hattr_defined?(attribute) ? send("#{attribute}=".to_sym, value) : write_attribute_without_hattr_accessor(attribute, value)
+          end
+          alias_method_chain :write_attribute, :hattr_accessor
+
+          def query_attribute_with_hattr_accessor(attribute)
+            self.class.hattr_defined?(attribute) ? send("#{attribute}?".to_sym) : query_attribute_without_hattr_accessor(attribute)
+          end
+          alias_method_chain :query_attribute, :hattr_accessor
+
+        end
+      end
+    end
+  end
+end
+
+Object.send :include, Huberry::HattrAccessor
+ActiveRecord::Base.send :include, Huberry::HattrAccessor::ActiveRecordExtensions if Object.const_defined?(:ActiveRecord)

data/test/active_record_test.rb

@@ -0,0 +1,98 @@
+require 'test/unit'
+require 'rubygems'
+require 'active_record'
+require 'active_record/fixtures'
+require File.dirname(__FILE__) + '/../lib/hattr_accessor'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+ActiveRecord::Migration.suppress_messages do
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :manufacturers do |t|
+      t.string :name, :limit => 30, :null => false
+    end
+
+    create_table :products do |t|
+      t.string :properties, :limit => 255, :null => false
+    end
+  end
+end
+
+class Manufacturer < ActiveRecord::Base
+end
+
+class Product < ActiveRecord::Base
+  serialize :properties, Hash
+  define_attribute_methods
+
+  hattr_accessor :name, :type => :string, :attribute => :properties
+  hattr_accessor :manufacturer_id, :type => :integer, :attribute => :properties, :allow_nil => true
+  hattr_accessor :colour, :type => :string, :attribute => :properties
+  hattr_accessor :weight, :type => :decimal, :attribute => :properties
+
+  belongs_to :manufacturer
+
+  validates_presence_of :name, :manufacturer_id, :colour, :weight
+  validates_length_of :name, :maximum => 30
+  validates_inclusion_of :colour, :in => %(Red Green Blue)
+  validates_numericality_of :weight
+end
+
+class ActiveRecordTest < Test::Unit::TestCase
+
+  def setup
+    Fixtures.create_fixtures(File.dirname(__FILE__) + '/fixtures', ActiveRecord::Base.connection.tables)
+  end
+
+  def teardown
+    Fixtures.reset_cache
+  end
+
+  def test_should_fetch_belongs_to_assocation
+    assert_equal Manufacturer.find(1), Product.find(1).manufacturer
+  end
+
+  def test_should_assign_belongs_to_assocation
+    product = Product.find(1)
+    manufacturer_1 = Manufacturer.find(1)
+    manufacturer_2 = Manufacturer.find(2)
+    assert_equal product.manufacturer, manufacturer_1
+    product.manufacturer = manufacturer_2
+    assert product.save
+    product.reload
+    assert_equal product.manufacturer, manufacturer_2
+  end
+
+  def test_should_pass_validations
+    product = Product.find(1)
+    manufacturer_3 = Manufacturer.find(3)
+    assert product.valid?
+    product.name = "Widget D"
+    product.manufacturer = manufacturer_3
+    product.colour = "Blue"
+    product.weight = 10.0
+    assert product.valid?
+  end
+
+  def test_should_fail_validations
+    product = Product.find(1)
+    assert product.valid?
+    product.name = "This is a very long name that needs to be over 30 characters"
+    assert !product.valid?
+    assert product.errors.on(:name).include?("too long")
+    product.reload
+    product.manufacturer_id = nil
+    assert !product.valid?
+    assert product.errors.on(:manufacturer_id).include?("can't be blank")
+    product.reload
+    product.colour = "Black"
+    assert !product.valid?
+    assert product.errors.on(:colour).include?("is not included in the list")
+    product.reload
+    product.weight = "Not a number"
+    assert !product.valid?
+    assert product.errors.on(:weight).include?("is not a number")
+    product.reload
+  end
+
+end

data/test/fixtures/manufacturers.yml

@@ -0,0 +1,11 @@
+acme:
+  id: 1
+  name: Acme
+
+bodgit:
+  id: 2
+  name: Bodgit
+
+scarper:
+  id: 3
+  name: Scarper

data/test/fixtures/products.yml

@@ -0,0 +1,11 @@
+widget_a:
+  id: 1
+  properties: "---\n  :name: \"Widget A\"\n  :manufacturer_id: 1\n  :colour: Red\n  :weight: 1.0\n"
+
+widget_b:
+  id: 2
+  properties: "---\n  :name: \"Widget B\"\n  :manufacturer_id: 2\n  :colour: Green\n  :weight: 2.0\n"
+
+widget_c:
+  id: 3
+  properties: "---\n  :name: \"Widget C\"\n  :manufacturer_id: 3\n  :colour: Blue\n  :weight: 3.0\n"

data/test/hattr_accessor_test.rb

@@ -0,0 +1,286 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/hattr_accessor'
+
+class CustomField
+  hattr_accessor :name, :type => :string, :attribute => :configuration
+  hattr_accessor :type, :type => :symbol, :attribute => :configuration
+  hattr_accessor :unit, :reference, :attribute => :configuration
+  hattr_accessor :offset, :type => :integer, :attribute => :configuration
+  hattr_accessor :amount, :type => :float, :allow_nil => true, :attribute => :configuration
+  hattr_accessor :price, :type => :decimal, :default => '5.0', :attribute => :configuration
+  hattr_accessor :sale_price, :type => :decimal, :attribute => :configuration,
+                 :default => lambda { |custom_field| custom_field.price / 2 }
+  hattr_accessor :required, :type => :boolean, :attribute => :configuration2
+  hattr_accessor :sizes, :type => :array, :attribute => :configuration
+
+  def configuration2
+    @configuration2 ||= { :some_default_reader_value => true }
+  end
+
+  def configuration2=(value)
+    @configuration2 = value.merge(:some_default_writer_value => true)
+  end
+end
+
+class HattrAccessorTest < Test::Unit::TestCase
+
+  def setup
+    @custom_field = CustomField.new
+  end
+
+  def test_should_alias_method_chain_configuration
+    assert CustomField.method_defined?(:configuration_with_hattr_accessor)
+    assert CustomField.method_defined?(:configuration_without_hattr_accessor)
+  end
+
+  def test_configuration_should_be_a_hash_by_default
+    assert_equal({}, @custom_field.configuration)
+  end
+
+  def test_should_set_name
+    @custom_field.name = 'Date'
+    assert_equal({ :name => 'Date' }, @custom_field.configuration)
+  end
+
+  def test_should_get_name
+    @custom_field.name = 'Date'
+    assert_equal 'Date', @custom_field.name
+  end
+
+  def test_should_get_name_predicate
+    @custom_field.name = 'Date'
+    assert_equal true, @custom_field.name?
+  end
+
+  def test_should_type_cast_name_as_string
+    assert_equal '', @custom_field.name
+  end
+
+  def test_should_set_type
+    @custom_field.type = :date
+    assert_equal({ :type => :date }, @custom_field.configuration)
+  end
+
+  def test_should_get_type
+    @custom_field.type = :date
+    assert_equal :date, @custom_field.type
+  end
+
+  def test_should_get_type_predicate
+    @custom_field.type = :date
+    assert_equal true, @custom_field.type?
+  end
+
+  def test_should_type_cast_type_as_symbol
+    @custom_field.type = 'date'
+    assert_equal :date, @custom_field.type
+  end
+
+  def test_should_set_unit
+    @custom_field.unit = 'days'
+    assert_equal({ :unit => 'days' }, @custom_field.configuration)
+  end
+
+  def test_should_get_unit
+    @custom_field.unit = 'days'
+    assert_equal 'days', @custom_field.unit
+  end
+
+  def test_should_get_unit_predicate
+    @custom_field.unit = 'days'
+    assert_equal true, @custom_field.unit?
+  end
+
+  def test_should_set_reference
+    @custom_field.reference = 'from_now'
+    assert_equal({ :reference => 'from_now' }, @custom_field.configuration)
+  end
+
+  def test_should_get_reference
+    @custom_field.reference = 'from_now'
+    assert_equal 'from_now', @custom_field.reference
+  end
+
+  def test_should_get_reference_predicate
+    @custom_field.reference = 'from_now'
+    assert_equal true, @custom_field.reference?
+  end
+
+  def test_should_set_offset
+    @custom_field.offset = 1
+    assert_equal({ :offset => 1 }, @custom_field.configuration)
+  end
+
+  def test_should_get_offset
+    @custom_field.offset = 1
+    assert_equal 1, @custom_field.offset
+  end
+
+  def test_should_get_offset_predicate
+    @custom_field.offset = 1
+    assert_equal true, @custom_field.offset?
+  end
+
+  def test_should_type_cast_offset_as_integer
+    @custom_field.offset = '1'
+    assert_equal 1, @custom_field.offset
+  end
+
+  def test_should_set_amount
+    @custom_field.amount = 1.0
+    assert_equal({ :amount => 1.0 }, @custom_field.configuration)
+  end
+
+  def test_should_get_amount
+    @custom_field.amount = 1.0
+    assert_equal 1.0, @custom_field.amount
+  end
+
+  def test_should_get_amount_predicate
+    @custom_field.amount = 1.0
+    assert_equal true, @custom_field.amount?
+  end
+
+  def test_should_get_nil_amount
+    assert_equal nil, @custom_field.amount
+  end
+
+  def test_should_type_cast_amount_as_float
+    @custom_field.amount = '1'
+    assert_equal 1.0, @custom_field.amount
+    
+    @custom_field.amount = 1
+    assert_equal 1.0, @custom_field.amount
+  end
+
+  def test_should_set_required_in_configuration2
+    @custom_field.required = true
+    assert_equal true, @custom_field.configuration2[:required]
+  end
+
+  def test_should_get_required
+    @custom_field.required = true
+    assert_equal true, @custom_field.required
+  end
+
+  def test_should_get_required_predicate
+    @custom_field.required = false
+    assert_equal false, @custom_field.required?
+  end
+
+  def test_should_type_cast_required_as_boolean
+    assert_equal false, @custom_field.required
+
+    @custom_field.required = false
+    assert_equal false, @custom_field.required
+
+    @custom_field.required = 0
+    assert_equal false, @custom_field.required
+
+    @custom_field.required = '0'
+    assert_equal false, @custom_field.required
+
+    @custom_field.required = true
+    assert_equal true, @custom_field.required
+
+    @custom_field.required = 1
+    assert_equal true, @custom_field.required
+
+    @custom_field.required = '1'
+    assert_equal true, @custom_field.required
+
+    @custom_field.required = ''
+    assert_equal false, @custom_field.required
+  end
+
+  def test_should_set_price
+    @custom_field.price = BigDecimal.new('1.0')
+    assert_equal({ :price => BigDecimal.new('1.0') }, @custom_field.configuration)
+  end
+
+  def test_should_get_price
+    @custom_field.price = BigDecimal.new('1.0')
+    assert_equal BigDecimal.new('1.0'), @custom_field.price
+  end
+
+  def test_should_get_price_predicate
+    @custom_field.price = BigDecimal.new('1.0')
+    assert_equal true, @custom_field.price?
+  end
+
+  def test_should_type_cast_price_as_decimal
+    @custom_field.price = '1.0'
+    assert_equal BigDecimal.new('1.0'), @custom_field.price
+  end
+
+  def test_should_get_default_price
+    assert_equal BigDecimal.new('5.0'), @custom_field.price
+    @custom_field.price = '1.0'
+    assert_equal BigDecimal.new('1.0'), @custom_field.price
+  end
+
+  def test_should_get_sale_price
+    assert_equal BigDecimal.new('2.5'), @custom_field.sale_price
+    @custom_field.price = '1.0'
+    assert_equal BigDecimal.new('0.5'), @custom_field.sale_price
+    @custom_field.sale_price = '0.8'
+    assert_equal BigDecimal.new('0.8'), @custom_field.sale_price
+  end
+
+  def test_should_get_sale_price_predicate
+    assert_equal true, @custom_field.sale_price?
+  end
+
+  def test_should_set_sizes
+    @custom_field.sizes = %w(XS S M L XL XXL)
+    assert_equal({ :sizes => %w(XS S M L XL XXL) }, @custom_field.configuration)
+  end
+
+  def test_should_get_sizes
+    @custom_field.sizes = %w(XS S M L XL XXL)
+    assert_equal %w(XS S M L XL XXL), @custom_field.sizes
+  end
+
+  def test_should_get_sizes_predicate?
+    @custom_field.sizes = %w(XS S M L XL XXL)
+    assert_equal true, @custom_field.sizes?
+  end
+
+  def test_should_type_cast_sizes_as_array
+    @custom_field.sizes = 'XXL'
+    assert_equal %w(XXL), @custom_field.sizes
+  end
+
+  def test_should_edit_sizes_in_place
+    @custom_field.sizes = %w(XS S M L XL XXL)
+    @custom_field.sizes.delete("XXL")
+    assert_equal %w(XS S M L XL), @custom_field.sizes
+    @custom_field.sizes << "XXL"
+    assert_equal %w(XS S M L XL XXL), @custom_field.sizes
+  end
+
+  def test_should_raise_exception_if_attribute_option_is_not_passed
+    assert_raises Huberry::HattrAccessor::MissingAttributeError do
+      CustomField.hattr_accessor :test
+    end
+  end
+
+  def test_should_not_overwrite_existing_reader
+    assert_equal true, @custom_field.configuration2[:some_default_reader_value]
+  end
+
+  def test_should_not_overwrite_existing_writer
+    @custom_field.configuration2 = {}
+    assert_equal true, @custom_field.configuration2[:some_default_writer_value]
+  end
+
+  def test_should_add_before_type_cast_reader
+    assert CustomField.method_defined?(:name_before_type_cast)
+    assert CustomField.method_defined?(:unit_before_type_cast)
+    assert CustomField.method_defined?(:offset_before_type_cast)
+    assert CustomField.method_defined?(:amount_before_type_cast)
+    assert CustomField.method_defined?(:price_before_type_cast)
+    assert CustomField.method_defined?(:required_before_type_cast)
+  end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: hattr_accessor
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+platform: ruby
+authors: 
+- Sean Huber
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-06 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Allows you to define attr_accessors that reference members of a hash
+email: shuber@huberry.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- hattr_accessor.gemspec
+- lib/hattr_accessor.rb
+- test/active_record_test.rb
+- test/fixtures/manufacturers.yml
+- test/fixtures/products.yml
+- test/hattr_accessor_test.rb
+has_rdoc: true
+homepage: http://github.com/shuber/hattr_accessor
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Allows you to define attr_accessors that reference members of a hash
+test_files: 
+- test/active_record_test.rb
+- test/hattr_accessor_test.rb