simple_enum 1.6.9 → 2.3.2

data/README.rdoc

@@ -1,293 +0,0 @@
-= SimpleEnum - unobtrusive enum-like fields for ActiveRecord {<img src="https://secure.travis-ci.org/lwe/simple_enum.png" />}[http://travis-ci.org/lwe/simple_enum]
-
-A Rails plugin which brings easy-to-use enum-like functionality to
-ActiveRecord and Mongoid models (now compatible with rails 3.1, ruby 1.9 and jruby).
-
-Since version 1.4, simple_enum is no longer compatible with activerecord 2.x, use
-version 1.3.2 instead: <https://github.com/lwe/simple_enum/tree/v1.3.2>.
-
-*Note*: a recent search on github for `enum` turned out, that there are many, many similar solutions.
-
-== ActiveRecord Quick start
-
-Add this to a model:
-
-    class User < ActiveRecord::Base
-      as_enum :gender, :female => 1, :male => 0
-    end
-
-Then create the required `gender_cd` column using migrations:
-
-    class AddGenderColumnToUser < ActiveRecord::Migration
-      def self.up
-        add_column :users, :gender_cd, :integer
-      end
-
-      def self.down
-        remove_column :users, :gender_cd
-      end
-    end
-
-== Mongoid Quick start
-
-Add this to an initializer
-
-     # load mongoid support
-     require 'simple_enum/mongoid'
-
-Add this to a model:
-
-    class User
-      include Mongoid::Document
-      include SimpleEnum::Mongoid
-
-      as_enum :gender, :female => 1, :male => 0
-    end
-
-== Working with enums
-
-*Done*. Now it's possible to pull some neat tricks on the new column, yet
-the original db column (+gender_cd+) is still intact and not touched by
-any fancy metaclass or similar.
-
-    jane = User.new
-    jane.gender = :female
-    jane.female?   # => true
-    jane.male?     # => false
-    jane.gender    # => :female
-    jane.gender_cd # => 1
-
-Easily switch to another value using the bang methods.
-
-    joe = User.new
-    joe.male!     # => :male
-    joe.gender    # => :male
-    joe.gender_cd # => 0
-
-There are even some neat tricks at class level, which might be
-useful when creating queries, displaying option elements or similar:
-
-    User.genders            # => { :male => 0, :female => 1 }
-    User.genders(:male)     # => 0, same as User.male
-    User.female             # => 1
-    User.genders.female     # => 1, same as User.female or User.genders(:female)
-
-== Wait, there's more!
-* Too tired of always adding the integer values? Try:
-
-        class User < ActiveRecord::Base
-          as_enum :status, [:deleted, :active, :disabled] # translates to :deleted => 0, :active => 1, :disabled => 2
-        end
-
-  *Disclaimer*: if you _ever_ decide to reorder this array, beaware that any previous mapping is lost. So it's recommended
-  to create mappings (that might change) using hashes instead of arrays. For stuff like gender it might be probably perfectly
-  fine to use arrays though.
-* You can use string values instead of integer values if your database column has the type +string+ or +text+:
-
-       class User < ActiveRecord::Base
-         as_enum :status, [:deleted, :active, :disabled], :strings => true
-       end
-
-       User.create!(status: :active) #=> #<User id: 1, status_cd: "active">
-* Want to use `SimpleEnum` in an ActiveModel, or other class, just do:
-
-        class MyModel
-          include SimpleEnum
-          attr_accessor :gender_cd
-          as_enum :gender, [:male, :female]
-        end
-
-* Maybe you've columns named differently than the proposed <tt>{column}_cd</tt> naming scheme, feel free to use any column name
-  by providing an option:
-
-        class User < ActiveRecord::Base
-          as_enum :gender, [:male, :female], :column => 'sex'
-        end
-
-  It's not allowed to use the same column name as the enum name, this has been deprecated since 1.4.x and will be
-  removed in 1.6.x.
-* Want support for ActiveRecords dirty attributes, provide <tt>:dirty => true</tt> as option, which automatically adds both
-  the <tt>{enum}_changed?</tt> and <tt>{enum}_was</tt> methods, which delegate to ActiveRecord.
-
-        class User < ActiveRecord::Base
-            as_enum :gender, [:male, :female], :dirty => true
-        end
-
-        @user = User.where(:gender_cd => User.male).first
-        @user.gender = :female
-        @user.gender_was
-        # => :male
-
-* Need to provide custom options for the mongoid field, or skip the automatically generated field?
-
-        # skip field generation
-        field :gender_cd # <- create field manually (!)
-        as_enum :gender, [:male, :female], :field => false
-
-        # custom field options (directly passed to Mongoid::Document#field)
-        as_enum :gender, [:male, :female], :field => { :type => Integer, :default => 1 }
-
-* It's possible to validate the internal enum values, just like any other ActiveRecord validation:
-
-        class User < ActiveRecord::Base
-          as_enum :gender, [:male, :female]
-          validates :gender, :as_enum => true
-          # OR validates_as_enum :gender
-        end
-
-  All common options like <tt>:if</tt>, <tt>:unless</tt>, <tt>:allow_nil</tt> and <tt>:message</tt> are supported, because it just works within
-  the standard <tt>validates_each</tt>-loop. This validation method does not check the value of <tt>user.gender</tt>, but
-  instead the value of <tt>@user.gender_cd</tt>.
-* If the shortcut methods (like <tt><symbol>?</tt>, <tt><symbol>!</tt> or <tt>Klass.<symbol></tt>) conflict with something in your class, it's possible to
-  define a prefix:
-
-        class User < ActiveRecord::Base
-          as_enum :gender, [:male, :female], :prefix => true
-        end
-
-        jane = User.new :gender => :female
-        jane.gender_female? # => true
-        User.gender_female  # => 1, this also works on the class methods
-
-  The <tt>:prefix</tt> option not only takes a boolean value as an argument, but instead can also be supplied a custom
-  prefix (i.e. any string or symbol), so with <tt>:prefix => 'foo'</tt> all shortcut methods would look like: <tt>foo_<symbol>...</tt>
-  *Note*: if the <tt>:slim => true</tt> is defined, this option has no effect whatsoever (because no shortcut methods are generated).
-* Sometimes it might be useful to disable the generation of the shortcut methods (<tt><symbol>?</tt>, <tt><symbol>!</tt> and <tt>Klass.<symbol></tt>),
-  to do so just add the option <tt>:slim => true</tt>:
-
-        class User < ActiveRecord::Base
-          as_enum :gender, [:male, :female], :slim => true
-        end
-
-        jane = User.new :gender => :female
-        jane.female? # => throws NoMethodError: undefined method `female?'
-        User.male    # => throws NoMethodError: undefined method `male'
-
-  Yet the setter and getter for <tt>gender</tt>, as well as the <tt>User.genders</tt> methods are still available, only all shortcut
-  methods for each of the enumeration values are not generated.
-
-  It's also possible to set <tt>:slim => :class</tt> which only disables the generation of any class-level shortcut method, because those
-  are also available via the enhanced enumeration hash:
-
-        class Message < ActiveRecord::Base
-          as_enum :status, { :unread => 0, :read => 1, :archived => 99 }, :slim => :class
-        end
-
-        msg = Message.new :body => 'Hello World!', status_cd => 0
-        msg.read?                      # => false; shortuct methods on instance are still enabled
-        msg.status                     # => :unread
-        Message.unread                 # => throws NoMethodError: undefined method `unread`
-        Message.statuses.unread        # => 0
-        Message.statuses.unread(true)  # => :unread
-
-        # or useful for IN queries
-        Messages.statuses(:unread, :read) # => [0, 1]
-
-* As a default an <tt>ArgumentError</tt> is raised if the user tries to set the field to an invalid enumeration value, to change this
-  behaviour use the <tt>:whiny</tt> option:
-
-        class User < ActiveRecord::Base
-          as_enum :gender, [:male, :female], :whiny => false
-        end
-
-* To make it easier to create dropdowns with values use:
-
-        <%= select(:user, :gender, User.genders.keys) %>
-
-* Need translated keys et al in your forms? SimpleEnum provides a <tt><enum>_for_select</tt> method:
-
-       # on the gender field
-       <%= select("user", "gender", User.genders_for_select) %>
-
-       # or on the '_cd' field
-       <%= select("user", "gender_cd", User.genders_for_select(:value))
-
-  Translations need to be stored like:
-
-       de:
-         activerecord:
-           enums:
-             user:              # the Model, as User.class.name.underscore
-               genders:         # pluralized version of :gender
-                 male: männlich
-                 female: weiblich
-
-* To define any option globally, like setting <tt>:whiny</tt> to +false+, or globally enable <tt>:prefix</tt>; all default options
-  are stored in <tt>SimpleEnum.default_options</tt>, this hash can be easily changed in your initializers or wherever:
-
-        # e.g. setting :prefix => true (globally)
-        SimpleEnum.default_options[:prefix] = true
-
-== Best practices
-
-Do not use the same name for the enum as for the column, note that this mode of use is
-deprecated since version 1.4.1 and raises an ArgumentError starting from version 1.6.0:
-
-    # BAD: raises ArgumentError
-    as_enum :status, [:active, :inactive, :archived], :column => "status"
-
-    # GOOD
-    as_enum :project_status, [:active, :inactive, :archived], :column => "status"
-
-Do not use states named after existing, or well known method names, like `new` or `create`, e.g.
-
-    # BAD, conflicts with Rails ActiveRecord Methods (!)
-    as_enum :handle, [:new, :create, :update]
-
-    # BETTER, prefixes all methods
-    as_enum :handle, [:new, :create, :update], :prefix => true
-
-Searching for certain values by using the finder methods:
-
-    User.where(:gender_cd => User.female)
-
-Working with database backed values, now assuming that there exists a +genders+ table:
-
-    class Person < ActiveRecord::Base
-      as_enum :gender, Gender.all.map { |g| [g.name.to_sym, g.id] } # map to array of symbols
-    end
-
-Working with object backed values, the only requirement to enable this is that <em>a)</em> either a field name +name+ exists
-or <em>b)</em> a custom method to convert an object to a symbolized form named +to_enum_sym+ (for general uses overriding
-+to_enum+ is perfectly fine) exists:
-
-    class Status < ActiveRecord::Base
-      # this has a column named :name
-      STATUSES = self.order(:name)
-    end
-
-    class BankTransaction < ActiveRecord::Base
-      as_enum :status, Status::STATUSES
-    end
-
-    # what happens now? the id's of Status now serve as enumeration key and the
-    # Status object as the value so...
-    t = BankTransaction.new
-    t.pending!
-    t.status # => #<Status id: 1, name: "pending">
-
-    # and it's also possible to access the objects/values using:
-    BankTransaction.statuses(:pending) # => 1, access by symbol (not) the object!
-    BankTransaction.statuses.pending   # => 1
-    BankTransaction.statuses.pending(true) # => #<Status id: 1, name: "pending">
-
-== Known issues/Open items
-
-* Maybe the <tt>:whiny</tt> option should default to <tt>false</tt>, so that generally no exceptions are thrown if a user fakes a request?
-* Convert to RSpec and clean up tests
-* Make `:slim => true` the default option...?
-
-== Contributors
-
-* @dmitry - bugfixes and other improvements
-* @tarsolya - implemented all the ruby 1.9 and rails 3 goodness!
-* @dbalatero - rails 2.3.5 bugfix & validator fixes
-* @johnthethird - feature for <tt>_for_select</tt> to return the values
-* @sinsiliux - ruby 1.9 fixes and removed AR dependency
-* @sled - mongoid support
-* @abrom - <tt>find_by_...</tt> method
-* @mhuggins - translations fixes
-* and all others: https://github.com/lwe/simple_enum/graphs/contributors thanks
-
-== Licence & Copyright
-Copyright (c) 2011 by Lukas Westermann, Licenced under MIT Licence (see LICENCE file)

data/lib/simple_enum/enum_hash.rb

@@ -1,64 +0,0 @@
-module SimpleEnum
-
-  # Internal hash class, used to handle the enumerations et al.
-  # Works like to original +Hash+ class, but with some added value,
-  # like access to
-  #
-  class EnumHash < ::ActiveSupport::OrderedHash
-
-    # Converts an entity to a symbol, uses to_enum_sym, if possible.
-    def self.symbolize(sym)
-      return sym.to_enum_sym if sym.respond_to?(:to_enum_sym)
-      return sym.to_sym if sym.respond_to?(:to_sym)
-      return sym.name.to_s.parameterize('_').to_sym if sym.respond_to?(:name)
-      sym.to_param.to_sym if sym.present? && sym.respond_to?(:to_param)
-      sym unless sym.blank?
-    end
-
-    def initialize(args = [], strings = false)
-      super()
-
-      @reverse_sym_lookup = {}
-      @sym_value_lookup = {}
-
-      if args.is_a?(Hash)
-        args.each { |k,v| set_value_for_reverse_lookup(k, v) }
-      else
-        ary = args.send(args.respond_to?(:enum_with_index) ? :enum_with_index : :each_with_index).to_a unless args.first.respond_to?(:map)
-        ary = args.map { |e| [e, e.id] } if args.first.respond_to?(:map) && !args.first.is_a?(Array)
-        ary ||= args
-        ary.each { |e| set_value_for_reverse_lookup(e[0], strings ? e[0].to_s : e[1]) }
-      end
-
-      @stringified_keys = keys.map(&:to_s)
-
-      freeze
-    end
-
-    def contains?(value)
-      @stringified_keys.include?(value.to_s) || values.include?(value)
-    end
-
-    def default(k = nil)
-      @sym_value_lookup[EnumHash.symbolize(k)] if k
-    end
-
-    def method_missing(symbol, *args)
-      sym = EnumHash.symbolize(symbol)
-      if @sym_value_lookup.has_key?(sym)
-        return @reverse_sym_lookup[sym] if args.first
-        self[symbol]
-      else
-        super
-      end
-    end
-
-    private
-      def set_value_for_reverse_lookup(key, value)
-        sym = EnumHash.symbolize(key)
-        self[key] = value
-        @reverse_sym_lookup[sym] = key
-        @sym_value_lookup[sym] = value
-      end
-  end
-end

data/lib/simple_enum/validation.rb

@@ -1,58 +0,0 @@
-module ActiveModel
-  module Validations
-    class AsEnumValidator < ActiveModel::Validator
-      attr_reader :attributes
-
-      def initialize(options)
-        @attributes = Array.wrap(options.delete(:attributes))
-        raise ":attributes cannot be blank" if @attributes.empty?
-        super
-      end
-
-      def setup(klass)
-        @klass = klass
-      end
-
-      def validate(record)
-        attributes.each do |attribute|
-          enum_def = @klass.enum_definitions[attribute]
-          raw_value = record.send(enum_def[:column])
-
-          raw_value = raw_value.to_s if enum_def[:options][:strings] && raw_value
-
-          next if (raw_value.nil? && options[:allow_nil]) || (raw_value.blank? && options[:allow_blank])
-
-          unless @klass.send(enum_def[:name].to_s.pluralize).values.include?(raw_value)
-            record.errors.add(attribute, :invalid_enum, options)
-          end
-        end
-      end
-    end
-
-    module HelperMethods
-      # Validates an +as_enum+ field based on the value of it's column.
-      #
-      # Model:
-      #    class User < ActiveRecord::Base
-      #      as_enum :gender, [ :male, :female ]
-      #      validates_as_enum :gender
-      #    end
-      #
-      # View:
-      #    <%= select(:user, :gender, User.genders.keys) %>
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default: is <tt>[:activerecord, :errors, :messages, :invalid_enum]</tt>).
-      # * <tt>:on</tt> - Specifies when this validation is active (default is always, other options <tt>:create</tt>, <tt>:update</tt>).
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a true or false value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_as_enum(*attr_names)
-        validates_with AsEnumValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end

data/locales/en.yml

@@ -1,10 +0,0 @@
-# english translation
-en:
-  activerecord:
-    errors:
-      messages:
-        invalid_enum: invalid option supplied
-  mongoid:
-    errors:
-      messages:
-        invalid_enum: invalid option supplied

data/test/array_conversions_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-
-class ArrayConversionsTest < MiniTest::Unit::TestCase
-  def setup
-    reload_db :genders => true
-  end
-  
-  def test_conversion_to_enumartions
-    with_enum = named_dummy('DummyArrayTest1') do
-       as_enum :gender, Gender.all.map { |g| [g.name.to_sym, g.id] }       
-    end   
-    
-    assert_equal @male.id, with_enum.male
-    assert_equal @female.id, with_enum.female
-    assert_equal @female.id, with_enum.genders(:female)
-    
-    jane = with_enum.new :gender => :female
-    assert_equal :female, jane.gender
-    assert_equal @female.id, jane.gender_cd    
-  end
-end

data/test/class_methods_test.rb

@@ -1,114 +0,0 @@
-require 'test_helper'
-
-class ClassMethodsTest < MiniTest::Unit::TestCase
-  def setup
-    reload_db
-  end
-
-  def test_that_klass_genders_array_accessor_equal_to_attr_accessor
-    assert_equal 0, Dummy.genders(:male)
-    assert_equal Dummy.genders(:male), Dummy.genders[:male]
-    assert_nil Dummy.genders(:inexistent)
-    assert_nil Dummy.genders[:inexistent]
-    refute_nil Dummy.genders[:female]
-  end
-
-  def test_inheritance_of_genders_to_subclasses
-    # issue#3
-    assert_equal({ :female => 1, :male => 0}, SpecificDummy.genders)
-  end
-
-  def test_genders_reader_created
-    assert_equal [0, 1], Dummy.genders.values.sort
-    assert_equal %w{female male}, Dummy.genders.keys.map(&:to_s).sort
-  end
-
-  def test_that_klass_genders_return_array_of_values
-    # usefuled for IN clauses
-    assert_equal [0, 1], Dummy.genders(:male, :female)
-    assert_equal [1, 0], Dummy.genders(:female, :male)
-  end
-
-  def test_inverted_hash_returns_synonym_by_code
-    assert_equal :male, Dummy.genders.invert[0]
-    assert_equal :female, Dummy.genders.invert[1]
-  end
-
-  def test_generation_of_value_shortcuts_on_class
-    g = Dummy.new
-
-    assert_equal 0, Dummy.male
-    assert_equal 1, Dummy.female
-    assert_equal 'alpha', Dummy.alpha
-    assert_respond_to Dummy, :male
-    assert_respond_to Dummy, :female
-    assert_respond_to Dummy, :beta
-    assert_respond_to Dummy, :foobar
-  end
-
-  def test_that_no_klass_shortcuts_are_created_if_slim_true
-    with_slim = named_dummy('Dummy1') do
-      as_enum :gender, [:male, :female], :slim => true
-    end
-
-    assert !with_slim.respond_to?(:male)
-    assert !with_slim.respond_to?(:female)
-    assert_respond_to with_slim, :genders
-  end
-
-  def test_that_no_klass_shortcuts_are_created_if_slim_class_though_instance_shortcuts_are
-    with_slim_class = named_dummy('Dummy2') do
-      as_enum :gender, [:male, :female], :slim => :class
-    end
-
-    jane = with_slim_class.new
-
-    assert_respond_to jane, :male!
-    assert_respond_to jane, :female!
-    assert !with_slim_class.respond_to?(:male)
-    assert !with_slim_class.respond_to?(:female)
-    assert_respond_to with_slim_class, :genders
-    assert_same 0, with_slim_class.genders.male
-    assert_same 1, with_slim_class.genders[:female]
-  end
-
-  def test_that_klass_shortcuts_respect_prefix_true_and_are_prefixed_by_enum_cd
-    with_prefix = named_dummy('Dummy3') do
-      as_enum :gender, [:male, :female], :prefix => true
-    end
-
-    assert !with_prefix.respond_to?(:male)
-    assert !with_prefix.respond_to?(:female)
-    assert_respond_to with_prefix, :gender_male
-    assert_respond_to with_prefix, :gender_female
-    assert_equal 0, with_prefix.gender_male
-    assert_respond_to with_prefix, :genders
-  end
-
-  def test_to_ensure_that_klass_shortcut_also_work_with_custom_prefixes
-    with_custom_prefix = named_dummy('Dummy4') do
-      as_enum :gender, [:male, :female], :prefix => :g
-    end
-
-    assert !with_custom_prefix.respond_to?(:male)
-    assert !with_custom_prefix.respond_to?(:female)
-    assert !with_custom_prefix.respond_to?(:gender_female)
-    assert_respond_to with_custom_prefix, :g_male
-    assert_respond_to with_custom_prefix, :g_female
-    assert_equal 1, with_custom_prefix.g_female
-    assert_respond_to with_custom_prefix, :genders
-  end
-
-  def test_that_the_human_enum_name_method_returns_translated_humanized_values
-    assert_equal :male.to_s.humanize, Dummy.human_enum_name(:genders, :male)
-    assert_equal "Girl", Dummy.human_enum_name(:genders, :female)
-    assert_equal "Foo", Dummy.human_enum_name(:didums, :foo)
-    assert_equal "Foos", Dummy.human_enum_name(:didums, :foo, :count => 5)
-  end
-
-  def test_enum_for_select_value_class_method
-    for_select = Dummy.genders_for_select(:value)
-    assert_equal ["Male", 0], for_select.first
-    assert_equal ["Girl", 1], for_select.last
-  end
-end

data/test/dirty_attributes_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-DirtyDummy = anonymous_dummy do
-  as_enum :gender, [:male, :female], :dirty => true
-end
-
-class DirtyAttributesTest < ActiveSupport::TestCase
-  def setup
-    reload_db
-  end
-
-  def test_setting_using_changed_on_enum
-    jane = DirtyDummy.create!(:gender => :female)
-    assert_equal 1, jane.gender_cd
-    jane.gender = :male # operation? =)
-    assert_equal :male, jane.gender
-    assert_equal true, jane.gender_cd_changed?
-    assert_equal true, jane.gender_changed?
-  end
-
-  def test_access_old_value_via_gender_was
-    john = DirtyDummy.create!(:gender => :male)
-    assert_equal 0, john.gender_cd
-    john.gender = :female
-    assert_equal :female, john.gender
-    assert_equal 0, john.gender_cd_was
-    assert_equal :male, john.gender_was
-  end
-
-  def test_dirty_methods_are_disabled_by_default
-    no_dirty = Dummy.new
-    assert !no_dirty.respond_to?(:gender_was), "should not respond_to :gender_was"
-    assert !no_dirty.respond_to?(:gender_changed?), "should not respond_to :gender_changed?"
-    assert !no_dirty.respond_to?(:word_was), "should not respond_to :word_was"
-    assert !no_dirty.respond_to?(:word_changed?), "should not respond_to :word_changed?"
-  end
-end

data/test/enum_hash_test.rb

@@ -1,73 +0,0 @@
-require 'test_helper'
-require 'simple_enum/enum_hash'
-
-class EnumHashTest < MiniTest::Unit::TestCase
-
-  def test_create_new_enumhash_instance_from_array_of_symbols
-    genders = SimpleEnum::EnumHash.new [:male, :female]
-
-    assert_same 0, genders[:male]
-    assert_same 1, genders[:female]
-    assert_same 0, genders.male
-    assert_same :female, genders.female(true)
-  end
-
-  def test_create_new_enumhash_instance_from_hash
-    status = SimpleEnum::EnumHash.new :inactive => 0, :active => 1, :archived => 99
-
-    assert_same 0, status.inactive
-    assert_same 1, status[:active]
-  end
-
-  def test_create_new_enumhash_instance_from_query_results
-    reload_db :genders => true
-    genders = SimpleEnum::EnumHash.new Gender.all
-
-    assert_same 0, genders[@male]
-    assert_same genders[@male], genders[:male]
-    assert_same 1, genders.female
-    assert_equal @male, genders.send(:male, true)
-  end
-
-  def test_that_enumhash_keys_are_ordered
-    ordered = SimpleEnum::EnumHash.new [:alpha, :beta, :gamma, :delta, :epsilon, :zeta, :eta]
-    expected_keys = [:alpha, :beta, :gamma, :delta, :epsilon, :zeta, :eta]
-    assert_equal expected_keys, ordered.keys
-  end
-
-  def test_valid_key_value_association_when_simple_array_is_merged_into_enumhash
-    a = [:a, :b, :c, :d]
-    h = SimpleEnum::EnumHash.new(a)
-
-    assert_same 0, h[:a]
-    assert_same 1, h[:b]
-    assert_same 2, h[:c]
-    assert_same 3, h[:d]
-    assert_equal [:a, :b, :c, :d], h.keys
-  end
-
-  def test_that_an_already_correct_looking_array_is_converted_to_hash
-    a = [[:a, 5], [:b, 10]]
-    h = SimpleEnum::EnumHash.new(a)
-
-    assert_same 5, h[:a]
-    assert_same 10, h[:b]
-    assert_equal [:a, :b], h.keys
-  end
-
-  def test_that_an_array_of_query_results_are_converted_to_result_ids
-    reload_db :genders => true # reload db
-    a = Gender.all
-
-    h = SimpleEnum::EnumHash.new(a)
-
-    assert_same 0, h[@male]
-    assert_same 1, h[@female]
-  end
-
-  def test_strings_option
-    h = SimpleEnum::EnumHash.new([:male, :female], true)
-    assert_equal "male", h[:male]
-    assert_equal "female", h[:female]
-  end
-end