simple_enum 0.3.0

data/simple_enum.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{simple_enum}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Lukas Westermann"]
+  s.date = %q{2009-10-07}
+  s.email = %q{lukas.westermann@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENCE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "lib/simple_enum.rb",
+     "lib/simple_enum/array_support.rb",
+     "lib/simple_enum/enum_hash.rb",
+     "lib/simple_enum/object_support.rb",
+     "lib/simple_enum/validation.rb",
+     "lib/simple_enum/version.rb",
+     "locales/en.yml",
+     "simple_enum.gemspec",
+     "test/array_conversions_test.rb",
+     "test/class_methods_test.rb",
+     "test/enum_hash_test.rb",
+     "test/finders_test.rb",
+     "test/models.rb",
+     "test/object_backed_test.rb",
+     "test/object_support_test.rb",
+     "test/prefixes_test.rb",
+     "test/se_array_support_test.rb",
+     "test/simple_enum_test.rb",
+     "test/test_helper.rb",
+     "test/without_shortcuts_test.rb"
+  ]
+  s.homepage = %q{http://github.com/lwe/simple_enum}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Simple enum-like field support for ActiveRecord (including validations and i18n)}
+  s.test_files = [
+    "test/array_conversions_test.rb",
+     "test/class_methods_test.rb",
+     "test/enum_hash_test.rb",
+     "test/finders_test.rb",
+     "test/models.rb",
+     "test/object_backed_test.rb",
+     "test/object_support_test.rb",
+     "test/prefixes_test.rb",
+     "test/se_array_support_test.rb",
+     "test/simple_enum_test.rb",
+     "test/test_helper.rb",
+     "test/without_shortcuts_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/array_conversions_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class ArrayConversionsTest < ActiveSupport::TestCase  
+  def setup
+    reload_db :genders => true
+  end
+  
+  test "that conversion of Gender.find(:all).map {...} to enumeration values as symbols works the same as [:male,:female]" do
+    with_enum = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      as_enum :gender, Gender.find(:all).map { |g| [g.name.to_sym, g.id] }
+    end
+    
+    assert_equal 0, with_enum.male
+    assert_equal 1, with_enum.female
+    assert_equal 1, with_enum.genders(:female)
+    
+    jane = with_enum.new :gender => :female
+    assert_equal :female, jane.gender
+    assert_equal 1, jane.gender_cd    
+  end
+end

data/test/class_methods_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+class ClassMethodsTest < ActiveSupport::TestCase  
+  def setup
+    reload_db
+  end
+
+  test "that Klass.genders[:sym] == Klass.genders(:sym)" do
+    assert_equal 0, Dummy.genders(:male)
+    assert_equal Dummy.genders(:male), Dummy.genders[:male]
+    assert_nil Dummy.genders(:inexistent)
+    assert_nil Dummy.genders[:inexistent]
+  end
+    
+  test "generation of value shortcuts on class" do
+    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
+  
+  test "that no Klass.shortcut are created if :slim => true" do
+    with_slim = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      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
+  
+  test "that no Klass.shortcut's are created if :slim => :class, though instance shortcuts are" do
+    with_slim_class = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      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
+  
+  test "that Klass.shortcut respect :prefix => true and are prefixed by \#{enum_cd}" do
+    with_prefix = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      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
+  
+  test "to ensure that Klass.shortcut also work with custom prefixes" do
+    with_custom_prefix = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      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
+  
+  test "new :upcase option for those guys picky with coding guidelines etc." do
+    with_upcase = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      as_enum :gender, [:male, :female], :upcase => true
+    end
+    
+    assert_respond_to with_upcase, :GENDERS
+    assert_same 0, with_upcase.GENDERS.male
+    assert_same 1, with_upcase.GENDERS[:female]
+  end
+end

data/test/enum_hash_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'simple_enum/enum_hash'
+
+class EnumHashTest < ActiveSupport::TestCase  
+  
+  test "create new EnumHash instance from array of symbols" do
+    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
+
+  test "create new EnumHash instance from Hash" do
+    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
+    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]
+    assert_same 1, genders.female
+    assert_equal male, genders.send(:male, true)
+  end
+end

data/test/finders_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class FindersTest < ActiveSupport::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'
+    
+    assert_equal 2, girls.length
+    
+    assert_equal 'Anna', girls.first.name
+    assert_equal :female, girls.first.gender
+    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) }
+    
+    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
+  
+  test "find with string conditions for all :didum = :foo" do
+    foos = Dummy.find :all, :conditions => ['other = ?', Dummy.didums(:foo)]
+    
+    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)}"
+    
+    assert_equal 1, men.length
+    assert_equal true, men.first.male?
+  end  
+end

data/test/models.rb

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

data/test/object_backed_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class ObjectBackedTest < ActiveSupport::TestCase  
+  def setup
+    reload_db :genders => true    
+  end
+
+  test "how working with object backed columns work..." do
+    # 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 = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'      
+      as_enum :gender, { simple_obj.new('Male') => 0, simple_obj.new('Female') => 1 }      
+    end
+    
+    d = with_object.find_by_name('Anna')
+    
+    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
+  
+  test "db backed objects, using method described in 'Advanced Rails Recipes - Recipe 61: Look Up Constant Data Efficiently'" do
+    # "cache" as defined in ARR#61
+    genders = Gender.find(: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'
+      as_enum :gender, genders
+    end
+    
+    d = with_db_obj.find_by_name('Bella');
+    
+    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
+    end
+    
+    assert_same male.id, with_db_obj.male
+    assert_same male, with_db_obj.male(true)
+    
+    assert_same :male, Dummy.male(true)
+    assert_same 0, Dummy.male
+  end
+end

data/test/object_support_test.rb

@@ -0,0 +1,27 @@
+class ObjectSupportTest < ActiveSupport::TestCase
+  
+  test "ensure that symbols stay symbols" do
+    assert_same :sym, :sym.to_enum_sym
+  end
+  
+  test "ensure that strings are just converted to symbols, whatever they look like" do
+    assert_same :sym, 'sym'.to_enum_sym
+    assert_same :OtherSym, 'OtherSym'.to_enum_sym
+  end
+  
+  test "convert custom class to symbol, by providing attr_accessor :name" do
+    has_name = Class.new do
+      attr_accessor :name
+    end
+    
+    named = has_name.new
+    named.name = 'sym'
+    
+    assert_same :sym, named.to_enum_sym
+    
+    another_named = has_name.new
+    another_named.name = 'Contains Spaces?'
+        
+    assert_same :contains_spaces, another_named.to_enum_sym
+  end
+end

data/test/prefixes_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class PrefixesTest < ActiveSupport::TestCase  
+  def setup
+    reload_db
+  end
+
+  test "set :prefix => true and ensure that 'gender' is prefixed to <symbol>? and <symbol>! methods" do
+    with_prefix = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      as_enum :gender, [:male, :female], :prefix => true
+    end
+    
+    d = with_prefix.new :gender => :male
+    assert_respond_to d, :gender_male?
+    assert_respond_to d, :gender_male!
+    assert_respond_to d, :gender_female?
+    assert_respond_to d, :gender_female!
+    
+    # just ensure that it DOES NOT RESPOND TO good old male!
+    assert !d.respond_to?(:male!)
+  end
+  
+  test "set :prefix => 'didum' and ensure that 'didum' is prefix to <symbol>? and <symbol>! methods" do
+    with_string_prefix = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      as_enum :gender, [:male, :female], :prefix => 'didum'
+    end
+    
+    d = with_string_prefix.new :gender => :female
+    assert_respond_to d, :didum_female?
+    assert_respond_to d, :didum_female!    
+    
+    # just check wheter the results are still correct :)
+    assert d.didum_female?
+    assert !d.didum_male?
+  end
+end

data/test/se_array_support_test.rb

@@ -0,0 +1,32 @@
+class SeArraySupportTest < ActiveSupport::TestCase
+  test "that when simple array is merge to hash, array values are the keys and indicies are values" do
+    a = [:a, :b, :c, :d]
+    h = a.to_hash_magic
+    
+    assert_same 0, h[:a]
+    assert_same 1, h[:b]
+    assert_same 2, h[:c]
+    assert_same 3, h[:d]
+  end
+  
+  test "that an already correct looking array is converted to a hash" do
+    a = [[:a, 5], [:b, 10]]
+    h = a.to_hash_magic
+    
+    assert_same 5, h[:a]
+    assert_same 10, h[:b]
+  end
+  
+  test "that an array of ActiveRecords are converted to <obj> => obj.id" do
+    reload_db :genders => true # reload db
+    a = Gender.find(:all, :order => :id)
+    
+    male = Gender.find(0)
+    female = Gender.find(1)
+    
+    h = a.to_hash_magic
+    
+    assert_same 0, h[male]
+    assert_same 1, h[female]
+  end
+end

data/test/simple_enum_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class SimpleEnumTest < ActiveSupport::TestCase  
+  def setup
+    reload_db
+  end
+  
+  test "get the correct integer values when setting to symbol" do
+    d = Dummy.new
+    d.gender = :male
+    assert_equal(0, d.gender_cd)
+  end
+  
+  test "get the correct symbol when setting the integer value" do
+    d = Dummy.new
+    d.gender_cd = 1
+    assert_equal(:female, d.gender)
+  end
+  
+  test "verify that <symbol>? returns correct result" do
+    d = Dummy.new
+    d.gender = :male
+    assert_equal(true, d.male?)
+    assert_equal(false, d.female?)
+  end
+  
+  test "get symbol when rows are fetched from db" do
+    # Anna
+    assert_equal(:female, Dummy.find(1).gender)
+    assert_equal(:alpha, Dummy.find(1).word)
+    assert_equal(:foo, Dummy.find(1).didum)
+    
+    # Bella
+    assert_equal(true, Dummy.find(2).female?)
+    assert_equal(true, Dummy.find(2).beta?)
+    assert_equal(:bar, Dummy.find(2).didum)
+
+    # Chris
+    assert_equal(false, Dummy.find(3).female?)
+    assert_equal(:gamma, Dummy.find(3).word)
+    assert_equal(:foobar, Dummy.find(3).didum)    
+  end
+  
+  test "create and save new record then test symbols" do
+    d = Dummy.create({ :name => 'Dummy', :gender_cd => 0 }) # :gender => male
+    assert_equal(true, d.male?)
+    
+    # change :gender_cd to 1
+    d.female!
+    d.save!    
+    assert_equal(true, Dummy.find(d.id).female?)
+  end
+  
+  test "add validation and test validations" do
+    Dummy.class_eval do; validates_as_enum :gender; end
+    #with_validation = Class.new(Dummy) do
+    #  validates_as_enum :gender
+    #end
+    
+    d = Dummy.new :gender_cd => 5 # invalid number :)
+    assert_equal(false, d.save)
+    d.gender_cd = 1
+    assert_equal(true, d.save)
+    assert_equal(:female, d.gender)
+  end
+  
+  test "raises ArgumentError if invalid symbol is passed" do
+    assert_raise ArgumentError do
+      Dummy.new :gender => :foo
+    end
+  end
+  
+  test "raises NO ArgumentError if :whiny => false is defined" do
+    not_whiny = Class.new(Dummy) do
+      as_enum :gender, [:male, :female], :whiny => false
+    end
+    
+    d = not_whiny.new :gender => :foo
+    assert_nil(d.gender)
+  end
+  
+  test "ensure that setting to 'nil' works if :whiny => true and :whiny => false" do
+    d = Dummy.new :gender => :male    
+    assert_equal(:male, d.gender)
+    d.gender = nil
+    assert_nil(d.gender)
+    
+    not_whiny_again = Class.new(Dummy) do
+      as_enum :gender, [:male, :female], :whiny => false
+    end
+    
+    d = not_whiny_again.new :gender => :male
+    assert_equal(:male, d.gender)
+    d.gender = nil
+    assert_nil(d.gender)    
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,66 @@
+# Setup environment for both tests and IRB interactive console
+#
+
+$KCODE = 'u' # to make parameterize work...
+
+require 'rubygems'
+
+gem 'sqlite3-ruby'
+
+require 'active_support'
+require 'active_record'
+
+# setup fake rails env
+ROOT       = File.join(File.dirname(__FILE__), '..')
+RAILS_ROOT = ROOT
+RAILS_ENV  = 'test'
+
+# create database connection (in memory db!)
+ActiveRecord::Base.establish_connection({ :adapter => 'sqlite3', :database => ':memory:'})
+
+# load simple_enum
+require File.join(ROOT, 'init')
+
+# load dummy class
+require File.join(ROOT, 'test', 'models')
+
+# Reload database
+def reload_db(options = {})
+  options = { :fill => true, :genders => false }.merge(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  
+  
+  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.new({ :name => 'male' })
+    male.id = 0;
+    male.save!
+    
+    female = Gender.new({ :name => 'female' })
+    female.id = 1;
+    female.save!
+  end
+end
+
+# do some magic to initialze DB for IRB session
+if Object.const_defined?('IRB')
+  reload_db :fill => true, :genders => true
+else # and load test classes when in test cases...
+  require 'test/unit'  
+  require 'active_support/test_case'
+end

data/test/without_shortcuts_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class SlimDummy < ActiveRecord::Base
+  set_table_name 'dummies'
+  as_enum :gender, [:male, :female], :slim => true
+end
+
+class WithoutShortcutsTest < ActiveSupport::TestCase  
+  def setup
+    reload_db
+  end
+
+  test "that no shortcut methods are generated if :slim => true" do
+    jane = SlimDummy.new
+    jane.gender = :female
+    
+    # ensure that other methods still work as expected
+    assert_equal 1, jane.gender_cd
+    assert_equal :female, jane.gender
+    
+    # then check for availability  of shortcut methods
+    assert !jane.respond_to?(:male!), "should not respond_to <male!>"
+    assert !jane.respond_to?(:female?), "should not respond_to <female?>"
+  end
+  
+  test "that saving and loading from a DB still works, even if :slim => true" do
+    anna = SlimDummy.find_by_name 'Anna'
+    
+    assert_equal 1, anna.gender_cd
+    assert_equal :female, anna.gender
+    
+    # change anna, save + reload
+    anna.gender = :male
+    anna.save!
+    anna.reload
+    
+    assert_equal 0, anna.gender_cd
+    assert_equal :male, anna.gender
+  end
+end