lwe-simple_enum 0.3.0

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

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: lwe-simple_enum
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Lukas Westermann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lukas.westermann@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+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
+has_rdoc: true
+homepage: http://github.com/lwe/simple_enum
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Simple enum-like field support for ActiveRecord (including validations and i18n)
+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