simple_enum 1.0.1 → 1.1.0

data/README.rdoc

@@ -1,7 +1,7 @@
 = SimpleEnum - unobtrusive enum-like fields for ActiveRecord
 
 A Rails plugin which brings easy-to-use enum-like functionality to
-ActiveRecord models.
+ActiveRecord models (now compatible with rails 3, ruby 1.9 and jruby).
 
 *Note*: a recent search on github for `enum` turned out, that there are many, many similar solutions.
 Yet, none seem to provide so many options, but I may be biased ;)
@@ -180,6 +180,12 @@ or <em>b)</em> a custom method to convert an object to a symbolized form named +
 
 * 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?
 * Clean-up code and tests -> bring down LOC ;) (but maintain Code LOC vs. Test LOC ratio which is currently 1:2.9)
+* Make `:slim => true` the default option...?
+
+== Contributors
+
+* dmitry - bugfixes and other improvements
+* tarsolya - implemented all the ruby 1.9 and rails 3 goodness!
 
 == Licence & Copyright
-Copyright (c) 2009 by Lukas Westermann, Licenced under MIT Licence (see LICENCE file)
+Copyright (c) 2009 by Lukas Westermann, Licenced under MIT Licence (see LICENCE file)

data/lib/simple_enum.rb

@@ -8,7 +8,6 @@
 #
 # See the +as_enum+ documentation for more details.
 
-require 'simple_enum/array_support'
 require 'simple_enum/enum_hash'
 require 'simple_enum/object_support'
 require 'simple_enum/validation'
@@ -18,7 +17,7 @@ require 'simple_enum/validation'
 module SimpleEnum
 
   # +SimpleEnum+ version string.
-  VERSION = "1.0.1".freeze
+  VERSION = "1.1.0".freeze
 
   class << self
     
@@ -211,7 +210,11 @@ module SimpleEnum
         
           # allow class access to each value
           unless options[:slim] === :class
-            metaclass.send(:define_method, "#{prefix}#{sym}", Proc.new { |*args| args.first ? k : code })
+            if self.respond_to? :singleton_class
+              singleton_class.send(:define_method, "#{prefix}#{sym}", Proc.new { |*args| args.first ? k : code })
+            else
+              metaclass.send(:define_method, "#{prefix}#{sym}", Proc.new { |*args| args.first ? k : code })
+            end
           end
         end
       end
@@ -220,7 +223,7 @@ module SimpleEnum
     include Validation
     
     def human_enum_name(enum, key, options = {})
-      defaults = self_and_descendants_from_active_record.map { |klass| :"#{klass.name.underscore}.#{enum}.#{key}" }
+      defaults = ([self] + subclasses).map { |klass| :"#{klass.name.underscore}.#{enum}.#{key}" }
       defaults << :"#{enum}.#{key}"
       defaults << options.delete(:default) if options[:default]
       defaults << "#{key}".humanize
@@ -240,8 +243,7 @@ end
 # Tie stuff together and load translations if ActiveRecord is defined
 if Object.const_defined?('ActiveRecord')
   Object.send(:include, SimpleEnum::ObjectSupport)
-  Array.send(:include, SimpleEnum::ArraySupport)
     
   ActiveRecord::Base.send(:include, SimpleEnum)
   I18n.load_path << File.join(File.dirname(__FILE__), '..', 'locales', 'en.yml')
-end
+end

data/lib/simple_enum/enum_hash.rb

@@ -5,21 +5,23 @@ module SimpleEnum
   # like access to 
   #
   # 
-  class EnumHash < ::Hash
-    def initialize(hsh)
-      hsh = hsh.to_hash_magic unless hsh.is_a?(Hash)
+  class EnumHash < ::ActiveSupport::OrderedHash
+    def initialize(args = [])
+      super()
       
       @reverse_sym_lookup = {}
       @sym_value_lookup = {}
-      
-      hsh.each do |k,v|
-        sym = k.to_enum_sym
-        self[k] = v
-        @reverse_sym_lookup[sym] = k
-        @sym_value_lookup[sym] = v
+
+      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.is_a?(ActiveRecord::Base) or args.first.is_a?(Array)
+        ary = args.map { |e| [e, e.id] } if args.first.is_a?(ActiveRecord::Base)
+        ary ||= args
+        ary.each { |e| set_value_for_reverse_lookup(e[0], e[1]) }
       end
     end
-    
+        
     def default(k = nil)
       @sym_value_lookup[k.to_enum_sym] if k
     end
@@ -32,5 +34,13 @@ module SimpleEnum
         super
       end
     end
+    
+    private
+      def set_value_for_reverse_lookup(key, value)
+        sym = key.to_enum_sym
+        self[key] = value
+        @reverse_sym_lookup[sym] = key
+        @sym_value_lookup[sym] = value
+      end    
   end
 end

data/lib/simple_enum/validation.rb

@@ -22,16 +22,15 @@ module SimpleEnum
     #   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)
-      configuration = { :on => :save }
-      configuration.update(attr_names.extract_options!)      
+      @configuration = { :on => :save }
+      @configuration.update(attr_names.extract_options!)      
       attr_names.map! { |e| enum_definitions[e][:column] } # map to column name
-      
-      validates_each(attr_names, configuration) do |record, attr_name, value|
+      validates_each(attr_names) do |record, attr_name, value|
         enum_def = enum_definitions[attr_name]
         unless send(enum_def[:name].to_s.pluralize).values.include?(value)
-          record.errors.add(enum_def[:name], :invalid_enum, :default => configuration[:message], :value => value)
+          record.errors.add(enum_def[:name], :invalid_enum, :default => @configuration[:message], :value => value)
         end
       end
-    end    
+    end
   end
 end

data/test/enum_hash_test.rb

@@ -30,4 +30,43 @@ class EnumHashTest < ActiveSupport::TestCase
     assert_same 1, genders.female
     assert_equal male, genders.send(:male, true)
   end
+  
+  test "that EnumHash keys are ordered" do
+    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
+    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
+  
+  test "that an already 'correct' looking array is converted to a hash" do
+    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
+  
+  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 = SimpleEnum::EnumHash.new(a)
+    
+    assert_same 0, h[male]
+    assert_same 1, h[female]
+  end  
 end

data/test/simple_enum_test.rb

@@ -52,10 +52,7 @@ class SimpleEnumTest < ActiveSupport::TestCase
   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
+    Dummy.class_eval { validates_as_enum :gender }
     
     d = Dummy.new :gender_cd => 5 # invalid number :)
     assert_equal(false, d.save)

data/test/test_helper.rb

@@ -1,12 +1,10 @@
 # Setup environment for both tests and IRB interactive console
 #
 
-$KCODE = 'u' # to make parameterize work...
+$KCODE = 'u' unless RUBY_VERSION =~ /^1\.9/ # to make parameterize work...
 
 require 'rubygems'
 
-gem 'sqlite3-ruby'
-
 require 'active_support'
 require 'active_record'
 
@@ -16,7 +14,9 @@ RAILS_ROOT = ROOT
 RAILS_ENV  = 'test'
 
 # create database connection (in memory db!)
-ActiveRecord::Base.establish_connection({ :adapter => 'sqlite3', :database => ':memory:'})
+ActiveRecord::Base.establish_connection({
+  :adapter => RUBY_PLATFORM =~ /java/ ? 'jdbcsqlite3' : 'sqlite3',
+  :database => ':memory:'})
 
 # load simple_enum
 require File.join(ROOT, 'init')

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 0
   - 1
-  version: 1.0.1
+  - 0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Lukas Westermann
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-06 00:00:00 +02:00
+date: 2010-05-10 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -33,7 +33,6 @@ files:
 - Rakefile
 - 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
@@ -46,7 +45,6 @@ files:
 - 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
@@ -89,7 +87,6 @@ test_files:
 - 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

data/lib/simple_enum/array_support.rb

@@ -1,15 +0,0 @@
-module SimpleEnum
-  module ArraySupport
-    
-    # Magically convert an array to a hash, has some neat features
-    # for active record models and similar.
-    #
-    # TODO: add more documentation; allow block to be passed to customize key/value pairs
-    def to_hash_magic
-      v = enum_with_index.to_a unless first.is_a?(ActiveRecord::Base) or first.is_a?(Array)
-      v = map { |e| [e, e.id] } if first.is_a?(ActiveRecord::Base)
-      v ||= self
-      Hash[*v.flatten]
-    end
-  end
-end

data/test/se_array_support_test.rb

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