simple_enum 1.6.9 → 2.0.0.rc1

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

data/test/finders_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-class FindersTest < MiniTest::Unit::TestCase
-  def setup
-    reload_db
-  end
-
-  def test_find_all_female_genders
-    girls = Dummy.where(:gender_cd => Dummy.genders[:female]).sort { |a,b| a.name <=> b.name }
-    
-    assert_equal 2, girls.length
-    
-    assert_equal 'Anna', girls.first.name
-    assert_equal :female, girls.first.gender
-    assert_equal true, girls.first.female?
-  end
-  
-  def test_find_all_gamma_words
-    gammas = Dummy.where(:word_cd => Dummy.words(:gamma)).all
-    
-    assert_equal 1, gammas.length
-    assert_equal 'Chris', gammas.first.name
-    assert_equal true, gammas.first.male?
-    assert_equal 'gamma', gammas.first.word_cd
-    assert_equal :gamma, gammas.first.word
-  end
-  
-  def test_find_all_with_attribute_didum_equal_to_foo
-    skip('Not available in Mongoid') if mongoid?
-    
-    foos = Dummy.where('other = ?', Dummy.didums(:foo)).all   
-    
-    assert_equal 1, foos.length
-    assert_equal false, foos.first.foobar?
-  end
-  
-  def test_find_using_insecure_inline_string_conditions
-    skip('Not available in Mongoid') if mongoid?
-    
-    men = Dummy.where("gender_cd = #{Dummy.genders(:male)}").all
-    
-    assert_equal 1, men.length
-    assert_equal true, men.first.male?
-  end  
-end

data/test/locales.yml

@@ -1,25 +0,0 @@
-# english translation
-en:
-  activerecord:
-    errors:
-      models:
-        validated_computer:
-          attributes:
-            operating_system:
-              invalid_enum: y u no os?
-  mongoid:
-    errors:
-      models:
-        validated_computer:
-          attributes:
-            operating_system:
-              invalid_enum: y u no os?
-
-  enums:
-    dummy:
-      genders:
-        female: Girl
-      didums:
-        foo:
-          one: Foo
-          other: Foos

data/test/mongoid_test.rb

@@ -1,66 +0,0 @@
-require 'test_helper'
-
-class MongoidTest < MiniTest::Unit::TestCase
-  def setup
-    @default_options = SimpleEnum.default_options
-    reload_db
-  end
-
-  def teardown
-    SimpleEnum.default_options.clear.update(@default_options)
-  end
-
-  def test_creates_a_field_per_default
-    skip('Only available in mongoid') unless mongoid?
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female]
-    end
-    refute_nil klass.new.fields['gender_cd']
-  end
-
-  def test_passing_custom_field_options
-    skip('Only available in mongoid') unless mongoid?
-    klass = anonymous_dummy do
-      field :verify, :type => Integer
-      as_enum :gender, [:male, :female], :field => { :type => Integer, :default => 1 }
-    end
-
-    gender_field = klass.new.fields['gender_cd']
-    refute_nil gender_field
-    assert_equal 1, gender_field.default
-    assert_equal klass.fields['verify'].class, gender_field.class
-    assert_equal :female, klass.new.gender
-  end
-
-  def test_skip_field_creation_if_field_false
-    skip('Only available in mongoid') unless mongoid?
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female], :field => false
-    end
-
-    assert_nil klass.new.fields['gender_cd']
-  end
-
-  def test_default_field_options
-    skip('Only available in mongoid') unless mongoid?
-    SimpleEnum.default_options[:field] = { :type => String }
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female]
-    end
-
-    refute_nil klass.new.fields['gender_cd']
-    assert_equal String, klass.new.fields['gender_cd'].options[:type]
-  end
-
-  def test_default_field_options_are_merged_recursivly
-    skip('Only available in mongoid') unless mongoid?
-    SimpleEnum.default_options[:field] = { :type => String }
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female], :field => { :default => "0" }
-    end
-
-    refute_nil klass.new.fields['gender_cd']
-    assert_equal String, klass.new.fields['gender_cd'].options[:type]
-    assert_equal "0", klass.new.fields['gender_cd'].options[:default]
-  end
-end

data/test/object_backed_test.rb

@@ -1,61 +0,0 @@
-require 'test_helper'
-
-class ObjectBackedTest < MiniTest::Unit::TestCase
-  def setup
-    reload_db :genders => true    
-  end
-
-  def test_how_working_with_object_backed_columns_work
-    # simple object -> not db backed instance
-    simple_obj = Class.new do
-      attr_accessor :name
-      def initialize(name)
-        @name = name
-      end  
-    end
-        
-    # create new class by using simple_obj
-    with_object = anonymous_dummy do
-      as_enum :gender, { simple_obj.new('Male') => 0, simple_obj.new('Female') => 1 }      
-    end
-        
-    d = with_object.where(:name => 'Anna').first
-    
-    assert_same simple_obj, d.gender.class
-    assert_equal 'Female', d.gender.name
-    assert_same true, d.female?
-    assert_same false, d.male?
-    assert_same 0, with_object.male    
-  end
-  
-  def test_db_backed_objects
-    # using method described in 'Advanced Rails Recipes - Recipe 61: Look Up Constant Data Efficiently'
-    # "cache" as defined in ARR#61
-    genders = Gender.all
-    # works without mapping... .map { |g| [g, g.id] }
-    
-    # use cached array of values
-    with_db_obj = anonymous_dummy do
-      as_enum :gender, genders
-    end
-    
-    d = with_db_obj.where(:name => 'Bella').first
-    
-    assert_respond_to with_db_obj, :female
-    assert_respond_to with_db_obj, :male
-    assert_equal 0, with_db_obj.male
-  end
-  
-  def test_that_accesing_keys_and_values_of_each_enumeration_value_works_as_expected
-
-    with_db_obj = anonymous_dummy do
-      as_enum :gender, Gender.all.to_a
-    end
-    
-    assert_same 0, with_db_obj.male
-    assert_equal @male.id, with_db_obj.male(true).id
-    
-    assert_same :male, Dummy.male(true)
-    assert_same 0, Dummy.male
-  end
-end

data/test/orm/active_record.rb

@@ -1,114 +0,0 @@
-require 'active_record/version'
-
-def orm_version
-  ActiveRecord::VERSION::STRING
-end
-
-def ar32?
-  ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR >= 2
-end
-
-def setup_db
-  # create database connection (in memory db!)
-  ActiveRecord::Base.establish_connection({
-    :adapter => RUBY_PLATFORM =~ /java/ ? 'jdbcsqlite3' : 'sqlite3',
-    :database => ':memory:'})
-    
-  # Fix visitor, for JRuby
-  if RUBY_PLATFORM =~ /java/ && ar32?
-    ActiveRecord::ConnectionAdapters::SQLiteAdapter.send(:define_method, :visitor) do
-      @visitor ||= Arel::Visitors::SQLite.new(self)
-    end
-  end
-end
-
-# Reload database
-def reload_db(options = {})
-  ActiveRecord::Base.connection.create_table :dummies, :force => true do |t|
-    t.column :name, :string
-    t.column :gender_cd, :integer
-    t.column :word_cd, :string, :limit => 5
-    t.column :role_cd, :string
-    t.column :other, :integer
-    t.column :numeric_cd, :string
-    t.column :nilish_cd, :string
-  end
-
-  # Create ref-data table and fill with records
-  ActiveRecord::Base.connection.create_table :genders, :force => true do |t|
-    t.column :name, :string
-  end
-  
-  # Validations
-  ActiveRecord::Base.connection.create_table :computers, :force => true do |t|
-    t.column :name, :string
-    t.column :operating_system_cd, :integer
-    t.column :manufacturer_cd, :integer
-  end  
-  
-  fill_db(options)
-end
-
-# Models
-def anonymous_dummy(&block)
-  Class.new(ActiveRecord::Base) do
-    ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-    instance_eval &block 
-  end
-end
-
-def extend_computer(current_i18n_name = "Computer", &block)
-  Class.new(Computer) do
-    ar32? ? self.table_name = 'computers' : set_table_name('computers')
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def extend_dummy(current_i18n_name = "Dummy", &block)
-  Class.new(Dummy) do
-    ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def named_dummy(class_name, &block)
-  begin
-    return class_name.constantize
-  rescue NameError
-    klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
-    klass.module_eval do
-      ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-      instance_eval &block
-    end
-    klass
-  end
-end
-
-class Dummy < ActiveRecord::Base
-  as_enum :gender, [:male, :female]
-  as_enum :word, { :alpha => 'alpha', :beta => 'beta', :gamma => 'gamma'}
-  as_enum :didum, [ :foo, :bar, :foobar ], :column => 'other'
-  as_enum :role, [:admin, :member, :anon], :strings => true
-  as_enum :numeric, [:"100", :"3.14"], :strings => true
-  as_enum :nilish, [:nil], :strings => true
-end
-
-class Gender < ActiveRecord::Base
-end
-
-class Computer < ActiveRecord::Base
-  as_enum :manufacturer, [:dell, :compaq, :apple]
-  as_enum :operating_system, [:windows, :osx, :linux, :bsd]
-end
-
-# Used to test STI stuff
-class SpecificDummy < Dummy
-  ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-end
-

data/test/orm/common.rb

@@ -1,23 +0,0 @@
-class MockName < String
-  def name; to_s end
-  
-  def self.mock!(name)
-    ActiveModel::Name.new(MockName.new(name))
-  end
-end
-
-def fill_db(options={})
-  options = { :fill => true, :genders => false }.merge(options)
-
-  if options[:fill]
-    # fill db with some rows
-    Dummy.create({ :name => 'Anna',  :gender_cd => 1, :word_cd => 'alpha', :other => 0})
-    Dummy.create({ :name => 'Bella', :gender_cd => 1, :word_cd => 'beta', :other => 1})
-    Dummy.create({ :name => 'Chris', :gender_cd => 0, :word_cd => 'gamma', :other => 2})
-  end
-
-  if options[:genders]
-    @male   = Gender.create!({ :name => 'male' })
-    @female = Gender.create!({ :name => 'female' })
-  end
-end

data/test/orm/mongoid.rb

@@ -1,114 +0,0 @@
-require 'mongoid/version'
-require 'simple_enum/mongoid'
-
-def orm_version
-  Mongoid::VERSION
-end
-
-def setup_db
-  # create database connection
-  Mongoid.configure do |config|
-    config.master = Mongo::Connection.new('localhost').db("simple-enum-test-suite")
-    config.use_utc = true
-    config.include_root_in_json = true
-  end
-end
-
-
-# Reload database
-def reload_db(options = {})
-
-  # clear collections except system
-  Mongoid.master.collections.select do |collection|
-    collection.name !~ /system/
-  end.each(&:drop)
-
-  fill_db(options)
-end
-
-# models
-def anonymous_dummy(&block)
-  Class.new do
-    include Mongoid::Document
-    include SimpleEnum::Mongoid
-    self.collection_name = 'dummies'
-    instance_eval &block
-  end
-end
-
-def extend_computer(current_i18n_name = "Computer", &block)
-  Class.new(Computer) do
-    self.collection_name = 'computers'
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def extend_dummy(current_i18n_name = "Dummy", &block)
-  Class.new(Dummy) do
-    self.collection_name = 'dummies'
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def named_dummy(class_name, &block)
-  begin
-    return class_name.constantize
-  rescue NameError
-    klass = Object.const_set(class_name, Class.new)
-    klass.module_eval do
-      include Mongoid::Document
-      include SimpleEnum::Mongoid
-
-      self.collection_name = 'dummies'
-      instance_eval &block
-    end
-
-    klass
-  end
-
-end
-
-class Dummy
-  include Mongoid::Document
-  include SimpleEnum::Mongoid
-
-  as_enum :gender, [:male, :female]
-  as_enum :word, { :alpha => 'alpha', :beta => 'beta', :gamma => 'gamma'}
-  as_enum :didum, [ :foo, :bar, :foobar ], :column => 'other'
-  as_enum :role, [:admin, :member, :anon], :strings => true
-  as_enum :numeric, [:"100", :"3.14"], :strings => true
-  as_enum :nilish, [:nil], :strings => true
-
-  before_save :check_typed
-
-  def check_typed
-    attributes['_type'] = nil unless (self.hereditary? || self.polymorphic?)
-  end
-
-end
-
-class Gender
-  include Mongoid::Document
-  include SimpleEnum::Mongoid
-
-  field :name, :type => String
-end
-
-class Computer
-  include Mongoid::Document
-  include SimpleEnum::Mongoid
-
-  field :name, :type => String
-
-  as_enum :manufacturer, [:dell, :compaq, :apple]
-  as_enum :operating_system, [:windows, :osx, :linux, :bsd]
-end
-
-# Used to test STI stuff
-class SpecificDummy < Dummy; end

data/test/poro_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class POROTest < MiniTest::Unit::TestCase
-  class MyPORO
-    include SimpleEnum
-
-    attr_accessor :gender_cd
-    as_enum :gender, [:male, :female]
-  end
-
-  def test_reading_and_writing
-    poro = POROTest::MyPORO.new
-    poro.gender_cd = 1
-    assert_equal :female, poro.gender
-
-    poro.male!
-    assert_equal 0, poro.gender_cd
-    assert_equal :male, poro.gender
-  end
-end