extended_has_enumeration 0.0.1 → 0.0.2

data/Gemfile

@@ -0,0 +1,41 @@
+source :rubygems
+
+version = ENV['AR_VERSION'] || '3.2.x'
+
+if version.end_with? 'x'
+  # fuzzy version support
+  version = version.gsub /x$/, '0'
+  gem 'activerecord', '~> ' +version, :require => 'active_record'
+elsif version == '3'
+  version = '3.0.0'
+  gem 'activerecord', '~> 3.0', :require => 'active_record'
+else
+  gem 'activerecord', version, :require => 'active_record'
+end
+
+gem 'builder'
+
+#if version >= '3.0.0'
+#  group :meta_where do
+#    gem 'squeel'
+#  end
+#end
+
+group :development do
+  gem 'jeweler'
+end
+
+group :test do
+  gem 'rspec', '~> 2.13.0'
+  gem 'cucumber'
+
+  gem 'ruby-debug19'
+  platforms :ruby do
+    gem 'sqlite3-ruby', :require => 'sqlite3'
+  end
+
+  platforms :jruby do
+    gem 'jdbc-sqlite3'
+    gem 'activerecord-jdbcsqlite3-adapter', '~> 0.9.7'
+  end
+end

data/HISTORY.txt

@@ -0,0 +1,44 @@
+Version 1.0.2:
+- No code changes
+- Fixed problem with gem dependencies
+
+Version 1.0.1:
+- Added support for Arel 2, which is required by ActiveRecord >= 3.0.3
+
+Version 1.0.0:
+- Added #to_sym for generated enumeration class.  #value is deprecated.
+- Raises ArgumentError when assigning, or querying, with a symbol that is
+  not part of the enumeration
+- A value of nil in underlying attribute results in a nil value for the
+  enumeration
+- Assigning nil to the enumeration results in a value of nil for the underlying
+  attribute
+
+Version 0.5.0:
+- Default name of underlying attribute can be overridden with the :attribute
+  option
+- Internal cleanup: removed some unnecessary code and patching for Rails 3
+
+Version 0.4.0:
+- MetaWhere interoperability
+- Tested with Rails 3.0.0
+
+Version 0.3.1:
+- Re-release of 0.3.0 to pick up missed files
+
+Version 0.3.0:
+- Support for Rails 3.0.0.rc2
+- NOTE: no longer compatible with Rails 3.0.0.rc
+
+Version 0.2.2:
+- Cosmetic change: simply gemfile description
+
+Version 0.2.1:
+- Support for JRuby 1.5.1
+- Support for ActiveRecord 2.3.8
+
+Version 0.2.0:
+- Support for Arel predicates
+
+Version 0.1.0:
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2010 Greg Spurrier
+
+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.md

@@ -0,0 +1,126 @@
+# has_enumeration
+## Overview
+`has_enumeration` adds support for enumerated types to ActiveRecord. The values
+of an enumerated attribute are represented as symbols regardless of the
+attribute's underlying representation in the database. Predicates
+(e.g. `car.color.red?`) are provided for each value of the enumerated type.
+
+## Defining Enumerated Attributes
+Enumerated attributes are declared in the model's class definition with the
+`has_enumeration` class method.  For example:
+
+    class Car < ActiveRecord::Base
+      has_enumeration :color, [:red, :green, :blue]
+    end
+
+The above definition assumes that the `color` attribute is stored as a string
+and that its values in the database match those obtained by calling `to_s` on
+their corresponding symbols. I.e., :red is stored as 'red'.
+
+If the underlying column is not a string or its values do not match the string
+version of the enumeration's symbols, then the mapping between symbols and their
+underlying values may be provided as a hash:
+
+    class Car < ActiveRecord::Base
+      has_enumeration :color, :red => 1, :green => 2, :blue => 3
+    end
+
+By default, the underlying attribute is assumed to have the same name as the
+enumeration. If this is not the case, the name of the underlying attibute may
+be provided with the `:attribute` option:
+
+    class Car < ActiveRecord::Base
+      has_enumeration :color, {:red => 1, :green => 2, :blue => 3},
+        :attribute => :hue
+    end
+
+## Using Enumerated Attributes
+### Assignment
+Enumerated attributes are assigned using symbols:
+
+    car = Car.new(:color => :red)
+    car.color = :blue
+
+The symbols are coerced into an instance of a nested class (`Car::Color` in
+this example) that is created by `has_enumeration`. If for some reason you
+need to avoid the type coercion, you can assign a value of that class directly:
+
+    car.color = Car::Color.from_sym(:green)
+
+### Querying
+When constructing queries referencing the enumerated attribute, use the symbol
+as its value:
+
+    Car.find(:all, :conditions => {:color => :red})
+
+`has_enumeration` supports Rails 3 and is aware of the model's underlying Arel
+representation:
+
+    Car.where(:color => :red)
+    Car.where(Car.arel_table[:color].not_in([:red, :green]))
+
+If you are using MetaWhere, `has_enumeration` plays nicely with it:
+
+    # This example requires the meta_where:
+    Car.where(:color.not_in => [:red, :green])
+
+### Testing Values
+The primary means of interacting with enumerated attributes is through the
+predicate methods that are automatically generated for each value in the
+enumeration:
+
+    car = Car.new(:color => :red)
+    car.color.red?
+    # => true
+    car.color.green?
+    # => false
+
+If the value of the attribute is needed as a symbol, e.g., for direct
+comparison, it can be retrieved with `to_sym`:
+
+    car.color.to_sym
+    # => :red
+
+## Installation
+`has_enumeration` is packaged as a gem:
+
+    gem install has_enumeration
+
+### Rails 3
+To use `has_enumeration` with Rails 3, simply add it to your application's
+Gemfile:
+
+    gem 'has_enumeration'
+
+### Rails 2.x
+To use `has_enumeration` with Rails 2, add it to your application's
+environment.rb file:
+
+    config.gem 'has_enumeration'
+
+## Supported Configurations
+`has_enumeration` has been tested with the following versions of ActiveRecord:
+
+* 2.3.10
+* 3.0.1
+* 3.0.3
+
+and the following Ruby implementations:
+
+* 1.8.7-p302
+* 1.9.2-p0
+* JRuby 1.5.5
+* Rubinius 1.1.0
+
+
+## Getting the Latest
+`has_enumeration` is hosted on github at
+[http://github.com/gregspurrier/has_enumeration](http://github.com/gregspurrier/has_enumeration).
+
+You can make a local clone of the repository with the following command:
+
+    git clone git://github.com/gregspurrier/has_enumeration.git
+
+## License
+`has_enumeration` is Copyright 2010 by Greg Spurrier. It is released under
+the MIT License. Please see LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "extended_has_enumeration"
+    gemspec.summary = "Support for symbol-based enumerations in ActiveRecord"
+    gemspec.description = <<-EOF
+Extends ActiveRecord with the has_enumeration method allowing a symbolic
+enumeration to be stored in an ActiveRecord attribute.  The enumeration is
+specified as a mapping between symbols and their underlying representation
+in the database.  Predicates are provided for each symbol in the enumeration
+and the symbols may be used in finder methods.  When using ActiveRecord 3,
+the symbols may also be used when interacting with the underlying Arel attribute
+for the enumeration.  has_enumeration has been tested with Ruby 1.8.7,
+Ruby 1.9.2, JRuby 1.5.5, Rubinius 1.1.0, ActiveRecord 2.3.10, and ActiveRecord
+3.0.3.
+EOF
+    gemspec.email = "maxtsap@gmail.com"
+    gemspec.homepage = "http://github.com/maxtsap/has_enumeration"
+    gemspec.author = "Greg Spurrier and Maxim Tsaplin"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+task :features => 'features:all'
+namespace :features do
+  task :all => [:common, :rails3]
+
+  Cucumber::Rake::Task.new(:common) do |t|
+    features = %w(explicitly_mapped_enumeration implicitly_mapped_enumeration
+        nonstandard_attribute_enumeration)
+    feature_files = features.map {|f| "features/#{f}.feature"}.join(' ')
+    t.cucumber_opts = feature_files
+  end
+
+  Cucumber::Rake::Task.new(:rails3) do |t|
+    # the ../ hack is because of a gherkin bug encountered when the file paths
+    # have exactly two / characters in some interpreters (coughjrubycough)
+    features = %w(../features/arel_attributes meta_where_queries)
+    feature_files = features.map {|f| "features/#{f}.feature"}.join(' ')
+
+    # With the ../ hack we have to specify the features directory via -r
+    t.cucumber_opts = '-r features ' +feature_files
+  end
+end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec')

data/TODO.md

@@ -0,0 +1,8 @@
+# Release 1.1
+* Support string assignment
+  * Intended for bulk assignment from form posts
+  * Unlike symbol assignment, will not raise an exception when a value
+    is invalid
+  * Invalid values will fail validation and add an error on the attribute
+* Expose the accepted values for an enumeration via something like
+  `Car::Color.values`

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/all_tests.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+AR_VERSION=3.0.x rvm 1.8.7@ar_3.0.x,1.9.2@ar_3.0.x,jruby@ar_3.0.x,rbx@ar_3.0.x --yaml do rake features spec
+AR_VERSION=2.3.10 rvm 1.8.7@ar_2.3.10,1.9.2@ar_2.3.10,jruby@ar_2.3.10,rbx@ar_2.3.10 --yaml do rake features:common spec
+

data/features/arel_attributes.feature

@@ -0,0 +1,20 @@
+Feature:
+
+  As a programmer using has_enumeration in Rails 3
+  I want to be able to refer to the enumeration symbolically when working with
+  the underlying arel attributes for a model
+  So that I can write pretty, concise code.
+
+
+  Scenario Outline: find objects with a specific enumerated value via arel
+    Given a model with an explicitly-mapped enumeration of red, green, and blue
+    And a set of objects with a variety of values for the enumeration
+    When I query for objects with the value <value> via arel
+    Then I should get all of the objects having that value
+    And I should not get any objects having other values
+
+    Scenarios: querying various values
+      | value  |
+      | :red   |
+      | :green |
+      | :blue  |

data/features/explicitly_mapped_enumeration.feature

@@ -0,0 +1,51 @@
+Feature:
+
+  As a programmer using an ActiveRecord model with an integer column
+  representing an enumerated value
+  I want to be able to refer to the enumeration symbolically and have
+  predicates to test its value
+  So that I can write pretty, concise code.
+
+  Scenario Outline: set an enumerated value on an unsaved object
+    Given a model with an explicitly-mapped enumeration of red, green, and blue
+    And an unsaved instance of that model
+    When I assign a symbolic value <assigned> to the enumeration
+    Then it should have the assigned value as its value
+    And the red? predicate should be <red?>
+    And the green? predicate should be <green?>
+    And the blue? predicate should be <blue?>
+
+    Scenarios: setting various values
+      | assigned | red?  | green? | blue? |
+      | :red     | true  | false  | false |
+      | :green   | false | true   | false |
+      | :blue    | false | false  | true  |
+
+  Scenario Outline: set an enumerated value then save and reload
+    Given a model with an explicitly-mapped enumeration of red, green, and blue
+    And an unsaved instance of that model
+    When I assign a symbolic value <assigned> to the enumeration
+    And I save and reload the object
+    Then it should have the assigned value as its value
+    And the red? predicate should be <red?>
+    And the green? predicate should be <green?>
+    And the blue? predicate should be <blue?>
+
+    Scenarios: setting various values
+      | assigned | red?  | green? | blue? |
+      | :red     | true  | false  | false |
+      | :green   | false | true   | false |
+      | :blue    | false | false  | true  |
+
+  Scenario Outline: find objects with a specific enumerated value
+    Given a model with an explicitly-mapped enumeration of red, green, and blue
+    And a set of objects with a variety of values for the enumeration
+    When I query for objects with the value <value>
+    Then I should get all of the objects having that value
+    And I should not get any objects having other values
+
+    Scenarios: querying various values
+      | value  |
+      | :red   |
+      | :green |
+      | :blue  |

data/features/implicitly_mapped_enumeration.feature

@@ -0,0 +1,51 @@
+Feature:
+
+  As a programmer using an ActiveRecord model with a string column
+  representing an enumerated value
+  I want to be able to refer to the enumeration symbolically and have
+  predicates to test its value
+  So that I can write pretty, concise code.
+
+  Scenario Outline: set an enumerated value on an unsaved object
+    Given a model with an implicitly-mapped enumeration of red, green, and blue
+    And an unsaved instance of that model
+    When I assign a symbolic value <assigned> to the enumeration
+    Then it should have the assigned value as its value
+    And the red? predicate should be <red?>
+    And the green? predicate should be <green?>
+    And the blue? predicate should be <blue?>
+
+    Scenarios: setting various values
+      | assigned | red?  | green? | blue? |
+      | :red     | true  | false  | false |
+      | :green   | false | true   | false |
+      | :blue    | false | false  | true  |
+
+  Scenario Outline: set an enumerated value then save and reload
+    Given a model with an implicitly-mapped enumeration of red, green, and blue
+    And an unsaved instance of that model
+    When I assign a symbolic value <assigned> to the enumeration
+    And I save and reload the object
+    Then it should have the assigned value as its value
+    And the red? predicate should be <red?>
+    And the green? predicate should be <green?>
+    And the blue? predicate should be <blue?>
+
+    Scenarios: setting various values
+      | assigned | red?  | green? | blue? |
+      | :red     | true  | false  | false |
+      | :green   | false | true   | false |
+      | :blue    | false | false  | true  |
+
+  Scenario Outline: find objects with a specific enumerated value
+    Given a model with an implicitly-mapped enumeration of red, green, and blue
+    And a set of objects with a variety of values for the enumeration
+    When I query for objects with the value <value>
+    Then I should get all of the objects having that value
+    And I should not get any objects having other values
+
+    Scenarios: querying various values
+      | value  |
+      | :red   |
+      | :green |
+      | :blue  |

data/features/meta_where_queries.feature

@@ -0,0 +1,20 @@
+Feature:
+
+  As a programmer using has_enumeration in Rails 3
+  I want to be able to refer to the enumeration symbolically when working with
+  the MetaWhere queries for a model
+  So that I can write pretty, concise code.
+
+
+  Scenario Outline: find objects with a specific enumerated value via MetaWhere
+    Given a model with an explicitly-mapped enumeration of red, green, and blue
+    And a set of objects with a variety of values for the enumeration
+    When I query for objects with the value <value> via MetaWhere
+    Then I should get all of the objects having that value
+    And I should not get any objects having other values
+
+    Scenarios: querying various values
+      | value  |
+      | :red   |
+      | :green |
+      | :blue  |

data/features/nonstandard_attribute_enumeration.feature

@@ -0,0 +1,51 @@
+Feature:
+
+  As a programmer using an ActiveRecord model with an integer column
+  representing an enumerated value
+  I want to be able to refer to the enumeration symbolically and have
+  predicates to test its value
+  So that I can write pretty, concise code.
+
+  Scenario Outline: set an enumerated value on an unsaved object
+    Given a model with an nonstandard-attribute enumeration of red, green, and blue
+    And an unsaved instance of that model
+    When I assign a symbolic value <assigned> to the enumeration
+    Then it should have the assigned value as its value
+    And the red? predicate should be <red?>
+    And the green? predicate should be <green?>
+    And the blue? predicate should be <blue?>
+
+    Scenarios: setting various values
+      | assigned | red?  | green? | blue? |
+      | :red     | true  | false  | false |
+      | :green   | false | true   | false |
+      | :blue    | false | false  | true  |
+
+  Scenario Outline: set an enumerated value then save and reload
+    Given a model with an nonstandard-attribute enumeration of red, green, and blue
+    And an unsaved instance of that model
+    When I assign a symbolic value <assigned> to the enumeration
+    And I save and reload the object
+    Then it should have the assigned value as its value
+    And the red? predicate should be <red?>
+    And the green? predicate should be <green?>
+    And the blue? predicate should be <blue?>
+
+    Scenarios: setting various values
+      | assigned | red?  | green? | blue? |
+      | :red     | true  | false  | false |
+      | :green   | false | true   | false |
+      | :blue    | false | false  | true  |
+
+  Scenario Outline: find objects with a specific enumerated value
+    Given a model with an nonstandard-attribute enumeration of red, green, and blue
+    And a set of objects with a variety of values for the enumeration
+    When I query for objects with the value <value>
+    Then I should get all of the objects having that value
+    And I should not get any objects having other values
+
+    Scenarios: querying various values
+      | value  |
+      | :red   |
+      | :green |
+      | :blue  |

data/features/step_definitions/has_enumeration_steps.rb

@@ -0,0 +1,77 @@
+Given /^a model with an explicitly-mapped enumeration of red, green, and blue$/ do
+  @model_class = ExplicitlyMappedModel
+end
+
+Given /^a model with an implicitly-mapped enumeration of red, green, and blue$/ do
+  @model_class = ImplicitlyMappedModel
+end
+
+Given /^a model with an nonstandard-attribute enumeration of red, green, and blue$/ do
+  @model_class = NonstandardAttributeModel
+end
+
+Given /^an unsaved instance of that model$/ do
+  @object = @model_class.new
+end
+
+When /^I assign a symbolic value :([a-z_]+) to the enumeration$/ do |value|
+  @assigned = value.to_sym
+  @object.color = @assigned
+end
+
+When /^I save and reload the object$/ do
+  @object.save!
+  @object = @model_class.find(@object.id)
+end
+
+Then /^it should have the assigned value as its value$/ do
+  @object.color.to_sym.should == @assigned
+end
+
+Then /^the ([a-z_]+\?) predicate should be (true|false)$/ do |predicate, value|
+  if value == 'true'
+    expected_value = true
+  else
+    expected_value = false
+  end
+  @object.color.send(predicate).should == expected_value  
+end
+
+
+Given /^a set of objects with a variety of values for the enumeration$/ do
+  a = ExplicitlyMappedModel.new(:color => :red)
+  a.color = :red
+  p a
+  @model_class.delete_all
+  
+  2.times do
+    [:red, :green, :blue].each do |color|
+      @model_class.create!(:color => color)
+    end
+  end
+  @all_objects = @model_class.all(:order => :id)
+end
+
+When /^I query for objects with the value :([a-z_]+)$/ do |value|
+  @desired_color = value.to_sym
+  @results = @model_class.all(:conditions => {:color => @desired_color}, :order => :id)
+end
+
+When /^I query for objects with the value :([a-z_]+) via arel$/ do |value|
+  @desired_color = value.to_sym
+  arel_attr = @model_class.arel_table[:color]
+  @results = @model_class.where(arel_attr.eq(@desired_color)).order(:id)
+end
+
+When /^I query for objects with the value :([a-z_]+) via MetaWhere$/ do |value|
+  @desired_color = value.to_sym
+  @results = @model_class.where(:color.eq => @desired_color).order(:id)
+end
+
+Then /^I should get all of the objects having that value$/ do
+  @results.should == @all_objects.select {|x| x.color.raw_value == @desired_color}
+end
+
+Then /^I should not get any objects having other values$/ do
+  @results.reject {|x| x.color.to_sym == @desired_color}.should be_empty
+end

data/features/support/env.rb

@@ -0,0 +1,30 @@
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :test)
+
+require 'extended_has_enumeration'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => defined?(JRUBY_VERSION) ? 'jdbcsqlite3': 'sqlite3',
+  :database => File.expand_path('../database', __FILE__)
+)
+
+if ActiveRecord::VERSION::MAJOR >= 3
+  Bundler.require(:meta_where)
+end
+
+class CreateTables < ActiveRecord::Migration
+  create_table :explicitly_mapped_models, :force => true do |t|
+    t.integer :color
+  end
+
+  create_table :implicitly_mapped_models, :force => true do |t|
+    t.string :color
+  end
+
+  create_table :nonstandard_attribute_models, :force => true do |t|
+    t.integer :hue
+  end
+end

data/features/support/explicitly_mapped_model.rb

@@ -0,0 +1,3 @@
+class ExplicitlyMappedModel < ActiveRecord::Base
+  has_enumeration :color, :red => 'Red color', :green => 2, :blue => 3
+end

data/features/support/implicitly_mapped_model.rb

@@ -0,0 +1,3 @@
+class ImplicitlyMappedModel < ActiveRecord::Base
+  has_enumeration :color, [:red, :green, :blue]
+end

data/features/support/nonstandard_attribute_model.rb

@@ -0,0 +1,4 @@
+class NonstandardAttributeModel < ActiveRecord::Base
+  has_enumeration :color, {:red => 1, :green => 2, :blue => 3},
+      :attribute => :hue
+end

data/install_gemsets.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+source ~/.rvm/scripts/rvm
+for ruby in 1.8.7 1.9.2 jruby rbx
+do
+  rvm use $ruby
+  for ar_rev in 2.3.10 3.0.x
+  do
+    gemset=ar_$ar_rev
+    echo yes | rvm gemset delete $gemset
+    rvm gemset create $gemset
+    rvm gemset use $gemset
+    AR_VERSION=$ar_rev bundle install
+  done
+done

data/lib/extended_has_enumeration/aggregate_conditions_override.rb

@@ -0,0 +1,16 @@
+module ExtendedHasEnumeration
+  module AggregateConditionsOverride
+    # Override the aggregate hash conditions behavior to coerce has_enumeration
+    # attributes that show up in finder options as symbols into instances of
+    # the aggregate class before hash expansion.
+    def expand_hash_conditions_for_aggregates(attrs)
+      expanded_attrs = attrs.dup
+      attr_enumeration_mapping_classes.each do |attr, klass|
+        if expanded_attrs[attr].is_a?(Symbol)
+          expanded_attrs[attr] = klass.from_sym(expanded_attrs[attr])
+        end
+      end
+      super(expanded_attrs)
+    end
+  end
+end

data/lib/extended_has_enumeration/arel/table_extensions.rb

@@ -0,0 +1,66 @@
+module ExtendedHasEnumeration
+  module Arel
+    module TableExtensions
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :columns, :has_enumeration
+
+          def self.has_enumeration_mappings
+            @has_enumeration_mappings ||= Hash.new {|h,k| h[k] = Hash.new}
+          end
+        end
+      end
+
+      def columns_with_has_enumeration
+        return @columns if @columns
+        columns = columns_without_has_enumeration
+        mappings = self.class.has_enumeration_mappings[name]
+        if mappings
+          mappings.each do |attr_name, mapping|
+            attr = columns.detect {|c| c.name.to_s == attr_name.to_s}
+            install_has_enumeration_attribute_mapping(attr, mapping)
+          end
+        end
+        columns
+      end
+
+    private
+      def install_has_enumeration_attribute_mapping(arel_attr, mapping)
+        # For this attribute only, override all of the methods defined
+        # in Arel::Attribute::PREDICATES so that they will perform the
+        # symbol-to-underlying-value mapping before proceeding with their work.
+        (class <<arel_attr;self;end).class_eval do
+          define_method :map_enumeration_arg do |arg|
+            if arg.is_a?(Symbol)
+              unless mapping.has_key?(arg)
+                raise ArgumentError.new(
+                  "#{arg.inspect} is not one of {#{mapping.keys.map(&:inspect).sort.join(', ')}}"
+                )
+              end
+              mapping[arg]
+            elsif arg.is_a?(Array)
+              arg.map {|a| map_enumeration_arg(a)}
+            else
+              arg
+            end
+          end
+
+          predicates = ::Arel::Predications.instance_methods.map &:to_sym
+          predicates.each do |method_name|
+            arity = ::Arel::Attribute.instance_method(method_name).arity
+            case arity
+            when 1
+              define_method method_name do |arg|
+                super(map_enumeration_arg(arg))
+              end
+            when 0
+              # No-op
+            else
+              raise "Unexpected arity #{arity} for #{method_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/extended_has_enumeration/arel/table_extensions_arel_one.rb

@@ -0,0 +1,70 @@
+# Support for Arel 1.  Will eventually be removed once most people are on
+# Arel 2.
+module ExtendedHasEnumeration
+  module Arel
+    module TableExtensionsArelOne
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :attributes, :has_enumeration
+
+          def self.has_enumeration_mappings
+            @has_enumeration_mappings ||= Hash.new {|h,k| h[k] = Hash.new}
+          end
+        end
+      end
+
+      def attributes_with_has_enumeration
+        return @attributes if @attributes
+        attrs = attributes_without_has_enumeration
+        mappings = self.class.has_enumeration_mappings[name]
+        if mappings
+          mappings.each do |attr_name, mapping|
+            attr = attrs[attr_name]
+            install_has_enumeration_attribute_mapping(attr, mapping)
+          end
+        end
+        attrs
+      end
+
+    private
+      def install_has_enumeration_attribute_mapping(arel_attr, mapping)
+        # For this attribute only, override all of the methods defined
+        # in Arel::Attribute::PREDICATES so that they will perform the
+        # symbol-to-underlying-value mapping before proceeding with their work.
+        (class <<arel_attr;self;end).class_eval do
+          define_method :map_enumeration_arg do |arg|
+            if arg.is_a?(Symbol)
+              unless mapping.has_key?(arg)
+                raise ArgumentError.new(
+                  "#{arg.inspect} is not one of {#{mapping.keys.map(&:inspect).sort.join(', ')}}"
+                )
+              end
+              mapping[arg]
+            elsif arg.is_a?(Array)
+              arg.map {|a| map_enumeration_arg(a)}
+            else
+              arg
+            end
+          end
+
+          ::Arel::Attribute::PREDICATES.each do |method_name|
+            # Preserve the arity of the method we are overriding
+            arity = ::Arel::Attribute.instance_method(method_name).arity
+            case arity
+            when 1
+              define_method method_name do |arg|
+                super(map_enumeration_arg(arg))
+              end
+            when -1
+              define_method method_name do |*args|
+                super(map_enumeration_arg(args))
+              end
+            else
+              raise "Unexpected arity #{arity} for #{method_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/extended_has_enumeration/class_methods.rb

@@ -0,0 +1,122 @@
+module ExtendedHasEnumeration
+  module ClassMethods
+    # Declares an enumerated attribute called +enumeration+ consisting of
+    # the symbols defined in +mapping+.
+    #
+    # When the database representation of the attribute is a string, +mapping+
+    # can be an array of symbols. The string representation of the symbol
+    # will be stored in the databased.  E.g.:
+    #
+    #   has_enumeration :color, [:red, :green, :blue]
+    #
+    # When the database representation of the attribute is not a string, or
+    # if its values do not match up with the string versions of its symbols,
+    # an hash mapping symbols to their underlying values may be used:
+    #
+    #   has_enumeration :color, :red => 1, :green => 2, :blue => 3
+    #
+    # By default, has_enumeration assumes that the column in the database
+    # has the same name as the enumeration.  If this is not the case, the
+    # column can be specified with the :attribute option:
+    #
+    #   has_enumeration :color, [:red, :green, :blue], :attribute => :hue
+    #
+    def has_enumeration(enumeration, mapping, options = {})
+      unless mapping.is_a?(Hash)
+        # Recast the mapping as a symbol -> string hash
+        mapping_hash = {}
+        mapping.each {|m| mapping_hash[m] = m.to_s}
+        mapping = mapping_hash
+      end
+
+      # The underlying attribute
+      attribute = options[:attribute] || enumeration
+
+      # ActiveRecord's composed_of method will do most of the work for us.
+      # All we have to do is cons up a class that implements the bidirectional
+      # mapping described by the provided hash.
+      klass = create_enumeration_mapping_class(mapping)
+      attr_enumeration_mapping_classes[enumeration] = klass
+
+      # Bind the class to a name within the scope of this class
+      mapping_class_name = enumeration.to_s.camelize
+      const_set(mapping_class_name, klass)
+      scoped_class_name = [self.name, mapping_class_name].join('::')
+
+      composed_of(enumeration,
+        :class_name => scoped_class_name,
+        :mapping => [attribute.to_s, 'raw_value'],
+        :converter => :from_sym,
+        :allow_nil => true
+      )
+
+      if ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR == 0
+        # Install this attributes mapping for use later when extending
+        # Arel attributes on the fly.
+        ::Arel::Table.has_enumeration_mappings[table_name][attribute] = mapping
+      else
+        # Install our aggregate condition handling override, but only once
+        unless @aggregate_conditions_override_installed
+          extend ExtendedHasEnumeration::AggregateConditionsOverride
+          @aggregate_conditions_override_installed = true
+        end
+      end
+    end
+
+  private
+    def attr_enumeration_mapping_classes
+      @attr_enumeration_mapping_classes ||= {}
+    end
+
+    def create_enumeration_mapping_class(mapping)
+      mapping = mapping.with_indifferent_access
+      Class.new do
+        attr_reader :raw_value
+        alias_method :humanize, :raw_value
+
+        define_method :initialize do |raw_value|
+          @raw_value = raw_value
+          @value = mapping[raw_value]
+        end
+
+        define_method :to_sym do
+          @value
+        end
+
+        define_method :value do
+          @values
+        end
+
+        define_method :to_s do
+          @value.to_s
+        end
+
+        define_method :humanize do
+          @raw_value.to_s.humanize
+        end
+
+        mapping.keys.each do |sym|
+          predicate = "#{sym}?".to_sym
+          value = mapping[sym]
+          define_method predicate do
+            @raw_value.to_sym == sym.to_sym
+          end
+        end
+
+        (class <<self;self;end).class_eval do
+          define_method :source do
+            mapping
+          end
+          define_method :from_sym do |sym|
+            unless mapping.has_key?(sym)
+              raise ArgumentError.new(
+                "#{sym.inspect} is not one of {#{mapping.keys.map(&:inspect).sort.join(', ')}}"
+              )
+            end
+            new(sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{has_enumeration.rb → extended_has_enumeration.rb}

@@ -1,8 +1,8 @@
 require 'active_record'
 
 # Install our common ActiveRecord extentions
-require 'has_enumeration/class_methods'
-ActiveRecord::Base.extend(HasEnumeration::ClassMethods)
+require 'extended_has_enumeration/class_methods'
+ActiveRecord::Base.extend(ExtendedHasEnumeration::ClassMethods)
 
 # We have two primary use cases, versions of ActiveRecord which define the column mapping in Arel,
 # and those which do not.  For ActiveRecord 2.x.x and versions ActiveRecord which rely on
@@ -12,14 +12,14 @@ ActiveRecord::Base.extend(HasEnumeration::ClassMethods)
 # whereas older versions of Arel need the code in HasEnumeration::Arel::TableExtensionsArelOne.
 if ActiveRecord::VERSION::MAJOR >= 3
   if Arel::VERSION >= "3.0.0"
-    require 'has_enumeration/aggregate_conditions_override'
+    require 'extended_has_enumeration/aggregate_conditions_override'
   elsif Arel::VERSION >= '2.0.0'
-    require 'has_enumeration/arel/table_extensions'
+    require 'extended_has_enumeration/arel/table_extensions'
     Arel::Table.send(:include, HasEnumeration::Arel::TableExtensions)
   else
-    require 'has_enumeration/arel/table_extensions_arel_one'
+    require 'extended_has_enumeration/arel/table_extensions_arel_one'
     Arel::Table.send(:include, HasEnumeration::Arel::TableExtensionsArelOne)
   end
 else
-  require 'has_enumeration/aggregate_conditions_override'
+  require 'extended_has_enumeration/aggregate_conditions_override'
 end

data/spec/extended_has_enumeration/extended_has_enumeration_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe ExtendedHasEnumeration, 'with invalid values' do
+  before(:each) do
+    @model = ExplicitlyMappedModel.new
+  end
+
+  it 'raises an exception when assigned an invalid value' do
+    lambda do
+      @model.color = :beige
+    end.should raise_error(ArgumentError, ':beige is not one of {"blue", "green", "red"}')
+  end
+
+  if ActiveRecord::VERSION::MAJOR >= 3
+    context 'with ActiveRecord 3.x' do
+      it 'raises an exception when finding with an invalid value' do
+        lambda do
+          ExplicitlyMappedModel.where(:color => :beige).all
+        end.should raise_error(ArgumentError, ':beige is not one of {"blue", "green", "red"}')
+      end
+
+      #TODO: handle porting to some other meta_where equivalent that is forward compatible with ActiveRecord 3.1.x+
+      #it 'raises an exception when finding with an invalid value via meta_where' do
+      #  lambda do
+      #    ExplicitlyMappedModel.where(:color.not_eq => :beige).all
+      #  end.should raise_error(ArgumentError, ':beige is not one of {:blue, :green, :red}')
+      #end
+    end
+  else
+    context 'With ActiveRecord 2.x' do
+      it 'raises an exception when finding with an invalid value' do
+        lambda do
+          ExplicitlyMappedModel.find(:all, :conditions => {:color => :beige})
+        end.should raise_error(ArgumentError, ':beige is not one of {"blue", "green", "red"}')
+      end
+    end
+  end
+end
+
+describe ExtendedHasEnumeration, 'with an uninitialied value' do
+  context 'in a newly-created object' do
+    it 'returns nil for the value of the enumeration' do
+      ExplicitlyMappedModel.new.color.should be_nil
+    end
+  end
+
+  context 'in an existing object' do
+    it 'returns nil for the value of the enumeration' do
+      object = ExplicitlyMappedModel.find(ExplicitlyMappedModel.create!.id)
+      object.color.should be_nil
+    end
+  end
+end
+
+describe ExtendedHasEnumeration, 'assignment of nil' do
+  it 'sets the enumeration to nil' do
+    object = ExplicitlyMappedModel.new(:color => :red)
+    object.color = nil
+    object.color.should be_nil
+  end
+
+  it 'persists across a trip to the database' do
+    object = ExplicitlyMappedModel.create!(:color => :red)
+    object.color = nil
+    object.save!
+    ExplicitlyMappedModel.find(object.id).color.should be_nil
+  end
+end
+
+describe ExtendedHasEnumeration, 'string formatting' do
+  it 'returns the value as a string if to_s is called on it'  do
+    object = ExplicitlyMappedModel.new(:color => :red)
+    object.color.to_s.should == 'Red color'
+  end
+end
+
+describe ExtendedHasEnumeration, 'hash value' do
+  it 'returns the raw value as a string if raw_value is called on it'  do
+    object = ExplicitlyMappedModel.new(:color => :red)
+    object.color.raw_value.should == :red
+  end
+
+  it 'returns the raw value as a string if humanize is called on it'  do
+    object = ExplicitlyMappedModel.new(:color => :red)
+    object.color.humanize.should == 'Red'
+  end
+end
+
+describe ExtendedHasEnumeration, 'source' do
+  it 'returns the passed hash'  do
+    ExplicitlyMappedModel::Color.source.should == {'red'=>'Red color', 'green'=>2, 'blue'=>3}    
+  end
+end
+
+describe ExtendedHasEnumeration, 'has hash with with_indifferent_access' do
+  it 'it allows assign string'  do
+    object = ExplicitlyMappedModel.create!(:color => 'red')
+    object.color.raw_value.should == 'red'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :test)
+
+require 'rspec'
+
+require File.expand_path('../lib/extended_has_enumeration', File.dirname(__FILE__))
+require File.expand_path('../features/support/explicitly_mapped_model', File.dirname(__FILE__))
+
+ActiveRecord::Base.establish_connection(
+  :adapter => defined?(JRUBY_VERSION) ? 'jdbcsqlite3': 'sqlite3',
+  :database => File.expand_path('../database', __FILE__)
+)
+
+if ActiveRecord::VERSION::MAJOR >= 3
+  Bundler.require(:meta_where)
+end
+
+class CreateTables < ActiveRecord::Migration
+  create_table :explicitly_mapped_models, :force => true do |t|
+    t.integer :color
+  end
+end

metadata

@@ -1,32 +1,101 @@
 --- !ruby/object:Gem::Specification
 name: extended_has_enumeration
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
-- Evan Dowling
-- Maxim Tsaplin
+- Greg Spurrier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-16 00:00:00.000000000 Z
-dependencies: []
-description: Extends ActiveRecord with the has_enumeration method allowing a symbolic
-  enumeration to be stored in an ActiveRecord attribute. The enumeration is specified
-  as a mapping between symbols and their underlying representation in the database.
-  Predicates are provided for each symbol in the enumeration and the symbols may be
-  used in finder methods. When using ActiveRecord 3, the symbols may also be used
-  when interacting with the underlying Arel attribute for the enumeration. has_enumeration
-  has been tested with Ruby 1.8.7, Ruby 1.9.2, JRuby 1.5.5, Rubinius 1.1.0, ActiveRecord
-  2.3.10, and ActiveRecord 3.0.3.
-email: maxtsap@gamil.com
+date: 2012-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.10
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Extends ActiveRecord with the has_enumeration method allowing a symbolic
+
+  enumeration to be stored in an ActiveRecord attribute.  The enumeration is
+
+  specified as a mapping between symbols and their underlying representation
+
+  in the database.  Predicates are provided for each symbol in the enumeration
+
+  and the symbols may be used in finder methods.  When using ActiveRecord 3,
+
+  the symbols may also be used when interacting with the underlying Arel attribute
+
+  for the enumeration.  has_enumeration has been tested with Ruby 1.8.7,
+
+  Ruby 1.9.2, JRuby 1.5.5, Rubinius 1.1.0, ActiveRecord 2.3.10, and ActiveRecord
+
+  3.0.3.
+
+'
+email: greg@rujubu.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
 files:
-- lib/has_enumeration.rb
-homepage: http://rubygems.org/gems/extended_has_enumeration
+- Gemfile
+- HISTORY.txt
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- VERSION
+- all_tests.sh
+- features/arel_attributes.feature
+- features/explicitly_mapped_enumeration.feature
+- features/implicitly_mapped_enumeration.feature
+- features/meta_where_queries.feature
+- features/nonstandard_attribute_enumeration.feature
+- features/step_definitions/has_enumeration_steps.rb
+- features/support/env.rb
+- features/support/explicitly_mapped_model.rb
+- features/support/implicitly_mapped_model.rb
+- features/support/nonstandard_attribute_model.rb
+- install_gemsets.sh
+- lib/extended_has_enumeration.rb
+- lib/extended_has_enumeration/aggregate_conditions_override.rb
+- lib/extended_has_enumeration/arel/table_extensions.rb
+- lib/extended_has_enumeration/arel/table_extensions_arel_one.rb
+- lib/extended_has_enumeration/class_methods.rb
+- spec/extended_has_enumeration/extended_has_enumeration_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/maxtsap/has_enumeration
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -49,5 +118,5 @@ rubyforge_project:
 rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Extended has_enumeration
+summary: Support for symbol-based enumerations in ActiveRecord
 test_files: []