simple_enum 1.4.1 → 1.5.0

data/test/dirty_attributes_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
-class DirtyDummy < ActiveRecord::Base
-  set_table_name 'dummies'
+DirtyDummy = anonymous_dummy do
   as_enum :gender, [:male, :female], :dirty => true
 end
 
@@ -10,7 +9,7 @@ class DirtyAttributesTest < ActiveSupport::TestCase
     reload_db
   end
 
-  test "setting using changed? on enum" do
+  def test_setting_using_changed_on_enum
     jane = DirtyDummy.create!(:gender => :female)
     assert_equal 1, jane.gender_cd
     jane.gender = :male # operation? =)
@@ -19,7 +18,7 @@ class DirtyAttributesTest < ActiveSupport::TestCase
     assert_equal true, jane.gender_changed?
   end
 
-  test "access old value via gender_was" do
+  def test_access_old_value_via_gender_was
     john = DirtyDummy.create!(:gender => :male)
     assert_equal 0, john.gender_cd
     john.gender = :female
@@ -28,7 +27,7 @@ class DirtyAttributesTest < ActiveSupport::TestCase
     assert_equal :male, john.gender_was
   end
 
-  test "dirty methods are disabled by default (opt-in)" do
+  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?"

data/test/enum_hash_test.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
 require 'simple_enum/enum_hash'
 
-class EnumHashTest < ActiveSupport::TestCase  
+class EnumHashTest < MiniTest::Unit::TestCase
   
-  test "create new EnumHash instance from array of symbols" do
+  def test_create_new_enumhash_instance_from_array_of_symbols
     genders = SimpleEnum::EnumHash.new [:male, :female]
     
     assert_same 0, genders[:male]
@@ -12,32 +12,30 @@ class EnumHashTest < ActiveSupport::TestCase
     assert_same :female, genders.female(true)
   end
 
-  test "create new EnumHash instance from Hash" do
+  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
   
-  test "create new EnumHash instance from ActiveRecord results" do
+  def test_create_new_enumhash_instance_from_query_results
     reload_db :genders => true
-    genders = SimpleEnum::EnumHash.new Gender.find(:all)
-    
-    male = Gender.find(0)
-    
-    assert_same 0, genders[male]
-    assert_same genders[male], genders[:male]
+    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)
+    assert_equal @male, genders.send(:male, true)
   end
   
-  test "that EnumHash keys are ordered" do
+  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
   
-  test "that when simple array is merge into a EnumHash, array values are the keys and indicies are values" do
+  def test_valid_key_value_association_when_simple_array_is_merged_into_enumhash
     a = [:a, :b, :c, :d]
     h = SimpleEnum::EnumHash.new(a)
     
@@ -48,7 +46,7 @@ class EnumHashTest < ActiveSupport::TestCase
     assert_equal [:a, :b, :c, :d], h.keys
   end
   
-  test "that an already 'correct' looking array is converted to a hash" do
+  def test_that_an_already_correct_looking_array_is_converted_to_hash
     a = [[:a, 5], [:b, 10]]
     h = SimpleEnum::EnumHash.new(a)
     
@@ -57,16 +55,13 @@ class EnumHashTest < ActiveSupport::TestCase
     assert_equal [:a, :b], h.keys
   end
   
-  test "that an array of ActiveRecords are converted to <obj> => obj.id" do
+  def test_that_an_array_of_query_results_are_converted_to_result_ids
     reload_db :genders => true # reload db
-    a = Gender.find(:all, :order => :id)
-    
-    male = Gender.find(0)
-    female = Gender.find(1)
+    a = Gender.all
     
     h = SimpleEnum::EnumHash.new(a)
     
-    assert_same 0, h[male]
-    assert_same 1, h[female]
+    assert_same 0, h[@male]
+    assert_same 1, h[@female]
   end  
 end

data/test/finders_test.rb

@@ -1,12 +1,12 @@
 require 'test_helper'
 
-class FindersTest < ActiveSupport::TestCase  
+class FindersTest < MiniTest::Unit::TestCase
   def setup
     reload_db
   end
 
-  test "find all where :gender = :female" do
-    girls = Dummy.find :all, :conditions => { :gender_cd => Dummy.genders[:female] }, :order => 'name ASC'
+  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
     
@@ -15,8 +15,8 @@ class FindersTest < ActiveSupport::TestCase
     assert_equal true, girls.first.female?
   end
   
-  test "find all where :word is 'gamma'" do
-    gammas = Dummy.find :all, :conditions => { :word_cd => Dummy.words(:gamma) }
+  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
@@ -25,15 +25,19 @@ class FindersTest < ActiveSupport::TestCase
     assert_equal :gamma, gammas.first.word
   end
   
-  test "find with string conditions for all :didum = :foo" do
-    foos = Dummy.find :all, :conditions => ['other = ?', Dummy.didums(:foo)]
+  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
   
-  test "find using insecure inline string conditions" do
-    men = Dummy.find :all, :conditions => "gender_cd = #{Dummy.genders(:male)}"
+  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?

data/test/locales.yml

@@ -3,15 +3,23 @@ en:
   activerecord:
     errors:
       models:
-        simple_enum_test/validated_computer:
+        validated_computer:
           attributes:
             operating_system:
               invalid_enum: y u no os?
-    enums:
-      dummy:
-        genders:
-          female: Girl
-        didums:
-          foo:
-            one: Foo
-            other: Foos
+  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

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class MongoidTest < MiniTest::Unit::TestCase
+  def setup
+    reload_db
+  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
+end

data/test/object_backed_test.rb

@@ -1,11 +1,11 @@
 require 'test_helper'
 
-class ObjectBackedTest < ActiveSupport::TestCase  
+class ObjectBackedTest < MiniTest::Unit::TestCase
   def setup
     reload_db :genders => true    
   end
 
-  test "how working with object backed columns work..." do
+  def test_how_working_with_object_backed_columns_work
     # simple object -> not db backed instance
     simple_obj = Class.new do
       attr_accessor :name
@@ -13,14 +13,13 @@ class ObjectBackedTest < ActiveSupport::TestCase
         @name = name
       end  
     end
-    
+        
     # create new class by using simple_obj
-    with_object = Class.new(ActiveRecord::Base) do
-      set_table_name 'dummies'      
+    with_object = anonymous_dummy do
       as_enum :gender, { simple_obj.new('Male') => 0, simple_obj.new('Female') => 1 }      
     end
-    
-    d = with_object.find_by_name('Anna')
+        
+    d = with_object.where(:name => 'Anna').first
     
     assert_same simple_obj, d.gender.class
     assert_equal 'Female', d.gender.name
@@ -29,37 +28,32 @@ class ObjectBackedTest < ActiveSupport::TestCase
     assert_same 0, with_object.male    
   end
   
-  test "db backed objects, using method described in 'Advanced Rails Recipes - Recipe 61: Look Up Constant Data Efficiently'" do
+  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.find(:all)
+    genders = Gender.all
     # works without mapping... .map { |g| [g, g.id] }
     
     # use cached array of values
-    with_db_obj = Class.new(ActiveRecord::Base) do
-      set_table_name 'dummies'
+    with_db_obj = anonymous_dummy do
       as_enum :gender, genders
     end
     
-    d = with_db_obj.find_by_name('Bella');
+    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
   
-  test "that accessing keys and values of each enumeration value works as expected" do
-    genders = Gender.find(:all, :order => :id)
-    
-    male = genders.first
-    female = genders.last
-    
-    with_db_obj = Class.new(ActiveRecord::Base) do
-      set_table_name 'dummies'
-      as_enum :gender, genders
+  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 male.id, with_db_obj.male
-    assert_same male, with_db_obj.male(true)
+    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

data/test/orm/active_record.rb

@@ -0,0 +1,99 @@
+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 :other, :integer
+  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 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'  
+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

@@ -0,0 +1,23 @@
+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