simple_enum 1.3.2 → 1.4.0

data/.gitignore

@@ -1,2 +1,5 @@
 doc
 pkg
+*.rbc
+.*.sw?
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx
+  - ree

data/Gemfile

@@ -1,7 +1,3 @@
-source :rubygems
+source "http://rubygems.org"
 
-gem "activesupport", "~> 3.0", :require => "active_support"
-gem "activerecord",  "~> 3.0", :require => "active_record"
-
-gem "sqlite3-ruby", :require => "sqlite3", :platforms => :ruby
-gem "jdbc-sqlite3", :require => "jdbcsqlite3", :platforms => :jruby
+gemspec

data/LICENCE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Lukas Westermann (Zurich, Switzerland)
+Copyright (c) 2011 Lukas Westermann (Zurich, Switzerland)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,17 +1,19 @@
 = SimpleEnum - unobtrusive enum-like fields for ActiveRecord
 
 A Rails plugin which brings easy-to-use enum-like functionality to
-ActiveRecord models (now compatible with rails 3, ruby 1.9 and jruby).
+ActiveRecord models (now compatible with rails 3.1, ruby 1.9 and jruby).
+
+Since version 1.4, simple_enum is no longer compatible with activerecord 2.x, use
+version 1.3.2 instead: <https://github.com/lwe/simple_enum/tree/v1.3.2>.
 
 *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 ;)
 
 == Quick start
 
 Add this to a model:
 
     class User < ActiveRecord::Base
-      as_enum :gender, {:female => 1, :male => 0}
+      as_enum :gender, :female => 1, :male => 0
     end
 
 Then create the new column using migrations:
@@ -36,9 +38,9 @@ any fancy metaclass or similar.
     jane.male?     # => false
     jane.gender    # => :female
     jane.gender_cd # => 1
-    
+
 Easily switch to another value using the bang methods.
-    
+
     joe = User.new
     joe.male!     # => :male
     joe.gender    # => :male
@@ -68,11 +70,11 @@ useful when creating queries, displaying option elements or similar:
         class User < ActiveRecord::Base
           as_enum :gender, [:male, :female], :column => 'sex'
         end
-        
+
 * To make it easier to create dropdowns with values use:
 
         <%= select(:user, :gender, User.genders.keys) %>
-        
+
 * It's possible to validate the internal enum values, just like any other ActiveRecord validation:
 
         class User < ActiveRecord::Base
@@ -85,7 +87,7 @@ useful when creating queries, displaying option elements or similar:
   instead the value of <tt>@user.gender_cd</tt>.
 * If the shortcut methods (like <tt><symbol>?</tt>, <tt><symbol>!</tt> or <tt>Klass.<symbol></tt>) conflict with something in your class, it's possible to
   define a prefix:
-  
+
         class User < ActiveRecord::Base
           as_enum :gender, [:male, :female], :prefix => true
         end
@@ -93,43 +95,43 @@ useful when creating queries, displaying option elements or similar:
         jane = User.new :gender => :female
         jane.gender_female? # => true
         User.gender_female  # => 1, this also works on the class methods
-        
+
   The <tt>:prefix</tt> option not only takes a boolean value as an argument, but instead can also be supplied a custom
   prefix (i.e. any string or symbol), so with <tt>:prefix => 'foo'</tt> all shortcut methods would look like: <tt>foo_<symbol>...</tt>
   *Note*: if the <tt>:slim => true</tt> is defined, this option has no effect whatsoever (because no shortcut methods are generated).
 * Sometimes it might be useful to disable the generation of the shortcut methods (<tt><symbol>?</tt>, <tt><symbol>!</tt> and <tt>Klass.<symbol></tt>), to do so just add the option <tt>:slim => true</tt>:
-  
+
         class User < ActiveRecord::Base
           as_enum :gender, [:male, :female], :slim => true
         end
 
         jane = User.new :gender => :female
-        jane.female? # => throws NoMethodError: undefined method `female?' 
-        User.male    # => throws NoMethodError: undefined method `male' 
-  
+        jane.female? # => throws NoMethodError: undefined method `female?'
+        User.male    # => throws NoMethodError: undefined method `male'
+
   Yet the setter and getter for <tt>gender</tt>, as well as the <tt>User.genders</tt> methods are still available, only all shortcut
   methods for each of the enumeration values are not generated.
-  
+
   It's also possible to set <tt>:slim => :class</tt> which only disables the generation of any class-level shortcut method, because those
   are also available via the enhanced enumeration hash:
-  
+
         class Message < ActiveRecord::Base
-          as_enum :status, { :unread => 0, :read => 1, :archived => 99}, :slim => :class
+          as_enum :status, { :unread => 0, :read => 1, :archived => 99 }, :slim => :class
         end
-        
+
         msg = Message.new :body => 'Hello World!', status_cd => 0
         msg.read?                      # => false; shortuct methods on instance are still enabled
         msg.status                     # => :unread
         Message.unread                 # => throws NoMethodError: undefined method `unread`
         Message.statuses.unread        # => 0
         Message.statuses.unread(true)  # => :unread
-        
+
         # or useful for IN queries
         Messages.statuses(:unread, :read) # => [0, 1]
-        
+
 * As a default an <tt>ArgumentError</tt> is raised if the user tries to set the field to an invalid enumeration value, to change this
   behaviour use the <tt>:whiny</tt> option:
-  
+
         class User < ActiveRecord::Base
           as_enum :gender, [:male, :female], :whiny => false
         end
@@ -138,10 +140,20 @@ useful when creating queries, displaying option elements or similar:
 
        # on the gender field
        <%= select("user", "gender", User.genders_for_select) %>
-       
+
        # or on the '_cd' field
        <%= select("user", "gender_cd", User.genders_for_select(:value))
 
+  Translations need to be stored like:
+
+       de:
+         activerecord:
+           enums:
+             user:              # the Model, as User.class.name.underscore
+               genders:         # pluralized version of :gender
+                 male: männlich
+                 female: weiblich
+
 * To define any option globally, like setting <tt>:whiny</tt> to +false+, or globally enable <tt>:prefix</tt>; all default options
   are stored in <tt>SimpleEnum.default_options</tt>, this hash can be easily changed in your initializers or wherever:
 
@@ -152,38 +164,38 @@ useful when creating queries, displaying option elements or similar:
 
 Searching for certain values by using the finder methods:
 
-    User.find :all, :conditions => { :gender_cd => User.female }
-    
+    User.where(:gender_cd => User.female)
+
 Working with database backed values, now assuming that there exists a +genders+ table:
 
     class Person < ActiveRecord::Base
-      as_enum :gender, Gender.find(:all).map { |g| [g.name.to_sym, g.id] } # map to array of symbols
+      as_enum :gender, Gender.all.map { |g| [g.name.to_sym, g.id] } # map to array of symbols
     end
-    
+
 Working with object backed values, the only requirement to enable this is that <em>a)</em> either a field name +name+ exists
 or <em>b)</em> a custom method to convert an object to a symbolized form named +to_enum_sym+ (for general uses overriding
 +to_enum+ is perfectly fine) exists:
 
     class Status < ActiveRecord::Base
       # this has a column named :name
-      STATUSES = self.find(:all, :order => :name)
+      STATUSES = self.order(:name)
     end
-    
+
     class BankTransaction < ActiveRecord::Base
-      as_enum :status, Status.STATUSES
+      as_enum :status, Status::STATUSES
     end
-    
+
     # what happens now? the id's of Status now serve as enumeration key and the
-    # Status object as the value so...    
+    # Status object as the value so...
     t = BankTransaction.new
     t.pending!
     t.status # => #<Status id: 1, name: "pending">
-        
+
     # and it's also possible to access the objects/values using:
     BankTransaction.statuses(:pending) # => 1, access by symbol (not) the object!
     BankTransaction.statuses.pending   # => 1
     BankTransaction.statuses.pending(true) # => #<Status id: 1, name: "pending">
-    
+
 == Known issues/Open items
 
 * 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?
@@ -192,10 +204,11 @@ or <em>b)</em> a custom method to convert an object to a symbolized form named +
 
 == Contributors
 
-* dmitry - bugfixes and other improvements
-* tarsolya - implemented all the ruby 1.9 and rails 3 goodness!
-* dbalatero - rails 2.3.5 bugfix
-* johnthethird - feature for <tt>_for_select</tt> to return the values
+* @dmitry - bugfixes and other improvements
+* @tarsolya - implemented all the ruby 1.9 and rails 3 goodness!
+* @dbalatero - rails 2.3.5 bugfix & validator fixes
+* @johnthethird - feature for <tt>_for_select</tt> to return the values
+* @sinsiliux - ruby 1.9 fixes and removed AR dependency
 
 == Licence & Copyright
-Copyright (c) 2009 by Lukas Westermann, Licenced under MIT Licence (see LICENCE file)
+Copyright (c) 2011 by Lukas Westermann, Licenced under MIT Licence (see LICENCE file)

data/Rakefile

@@ -1,9 +1,10 @@
-require 'rake'
+require 'rubygems'
+require 'bundler'
 require 'rake/testtask'
-require 'rake/rdoctask'
 
-# kinda ensure simple_enum is on load path
-$: << File.join(File.dirname(__FILE__), 'lib')
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
 
 desc 'Default: run unit tests.'
 task :default => :test
@@ -12,68 +13,6 @@ desc 'Test the simple_enum plugin.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.test_files = Dir.glob('test/**/*_test.rb')
   t.verbose = true
 end
-
-desc 'Generate documentation for the simple_enum plugin (results in doc/).'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.title    = 'SimpleEnum'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-  rdoc.rdoc_files.include('LICENCE');
-end
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    require 'rubygems'
-    require 'simple_enum'
-    
-    gemspec.name = "simple_enum"
-    gemspec.version = SimpleEnum::VERSION
-    gemspec.summary = "Simple enum-like field support for ActiveRecord (including validations and i18n)"
-    gemspec.email = "lukas.westermann@gmail.com"
-    gemspec.homepage = "http://github.com/lwe/simple_enum"
-    gemspec.authors = ["Lukas Westermann"] # ask & add "Dmitry Polushkin"
-    
-    gemspec.files.reject! { |file| file =~ /\.gemspec$/ } # kinda redundant
-  end
-  Jeweler::GemcutterTasks.new  
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler"
-end
-
-namespace :metrics do
-  desc 'Report code statistics for library and tests to shell.'
-  task :stats do |t|
-    require 'code_statistics'
-    dirs = {
-      'Libraries' => 'lib',
-      'Unit tests' => 'test'
-    }.map { |name,dir| [name, File.join(File.dirname(__FILE__), dir)] }
-    CodeStatistics.new(*dirs).to_s
-  end
-  
-  desc 'Report code coverage to HTML (doc/coverage) and shell (requires rcov).'
-  task :coverage do |t|
-    rm_f "doc/coverage"
-    mkdir_p "doc/coverage"
-    rcov = %(rcov -Ilib:test --exclude '\/gems\/' -o doc/coverage -T test/*_test.rb )
-    system rcov
-  end
-end
-
-desc 'Start IRB console with loaded test/test_helper.rb and sqlite db.'
-task :console do |t|
-  chdir File.dirname(__FILE__)
-  exec 'irb -Ilib/ -r test/test_helper'
-end
-
-desc 'Clean up generated files.'
-task :clean do |t|
-  FileUtils.rm_rf "doc"
-  FileUtils.rm_rf "pkg"  
-end

data/lib/simple_enum.rb

@@ -9,7 +9,6 @@
 # See the +as_enum+ documentation for more details.
 
 # because we depend on AR and i18n
-require 'active_record'
 require 'i18n'
 
 require 'simple_enum/enum_hash'
@@ -20,11 +19,8 @@ require 'simple_enum/validation'
 # of +SimpleEnum::ClassMethods+ for more details.
 module SimpleEnum
 
-  # +SimpleEnum+ version string.
-  VERSION = "1.3.2".freeze
-
   class << self
-    
+
     # Provides configurability to SimpleEnum, allows to override some defaults which are
     # defined for all uses of +as_enum+. Most options from +as_enum+ are available, such as:
     # * <tt>:prefix</tt> - Define a prefix, which is prefixed to the shortcut methods (e.g. <tt><symbol>!</tt> and
@@ -41,15 +37,18 @@ module SimpleEnum
       @default_options ||= {
         :whiny => true,
         :upcase => false
-      } 
+      }
     end
-    
+
     def included(base) #:nodoc:
+      base.send :class_attribute, :enum_definitions, :instance_write => false, :instance_reader => false
+      base.enum_definitions = {}
       base.send :extend, ClassMethods
     end
   end
-  
+
   module ClassMethods
+
     # Provides ability to create simple enumerations based on hashes or arrays, backed
     # by integer columns (but not limited to integer columns).
     #
@@ -58,7 +57,7 @@ module SimpleEnum
     #
     #   add_column :users, :gender_cd, :integer
     #   add_column :users, :status, :integer # and a custom column...
-    #      
+    #
     # and then in your model:
     #
     #   class User < ActiveRecord::Base
@@ -80,7 +79,7 @@ module SimpleEnum
     #   john_doe.gender_cd       # => 0
     #
     # And to make life a tad easier: a few shortcut methods to work with the enumeration are also created.
-    # 
+    #
     #   john_doe.male?           # => true
     #   john_doe.female?         # => false
     #   john_doe.female!         # => :female (set's gender to :female => gender_cd = 1)
@@ -127,12 +126,12 @@ module SimpleEnum
     #
     #   class Address < ActiveRecord::Base
     #     as_enum :canton, {:aargau => 'ag', ..., :wallis => 'vs', :zug => 'zg', :zurich => 'zh'}, :slim => true
-    #   end    
+    #   end
     #
     #   home = Address.new(:canton => :zurich, :street => 'Bahnhofstrasse 1', ...)
     #   home.canton       # => :zurich
     #   home.canton_cd    # => 'zh'
-    #   home.aargau!      # throws NoMethodError: undefined method `aargau!' 
+    #   home.aargau!      # throws NoMethodError: undefined method `aargau!'
     #   Address.aargau    # throws NoMethodError: undefined method `aargau`
     #
     # This is especially useful if there are (too) many enumeration values, or these shortcut methods
@@ -155,56 +154,60 @@ module SimpleEnum
       options.assert_valid_keys(:column, :whiny, :prefix, :slim, :upcase)
 
       metaclass = (class << self; self; end)
-    
+
       # convert array to hash...
       values = SimpleEnum::EnumHash.new(values)
       values_inverted = values.invert
-    
+
       # store info away
-      write_inheritable_attribute(:enum_definitions, {}) if enum_definitions.nil?
-      enum_definitions[enum_cd] = enum_definitions[options[:column]] = { :name => enum_cd, :column => options[:column], :options => options }
-    
-      # generate getter       
+      self.enum_definitions = {} if self.enum_definitions.nil?
+      self.enum_definitions[enum_cd] = self.enum_definitions[options[:column]] = { :name => enum_cd, :column => options[:column], :options => options }
+
+      # generate getter
       define_method("#{enum_cd}") do
         id = read_attribute options[:column]
         values_inverted[id]
       end
-    
+
       # generate setter
       define_method("#{enum_cd}=") do |new_value|
         v = new_value.blank? ? nil : values[new_value.to_sym]
         raise(ArgumentError, "Invalid enumeration value: #{new_value}") if (options[:whiny] and v.nil? and !new_value.blank?)
         write_attribute options[:column], v
       end
-    
-      # allow access to defined values hash, e.g. in a select helper or finder method.      
+
+      # allow access to defined values hash, e.g. in a select helper or finder method.
       attr_name = enum_cd.to_s.pluralize
       enum_attr = :"#{attr_name.downcase}_enum_hash"
-      write_inheritable_attribute(enum_attr, values)
-      
+
       class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        class_attribute #{enum_attr.inspect}, :instance_write => false, :instance_reader => false
+
         def self.#{attr_name}(*args)
-          return read_inheritable_attribute(#{enum_attr.inspect}) if args.first.nil?
-          return read_inheritable_attribute(#{enum_attr.inspect})[args.first] if args.size == 1
-          args.inject([]) { |ary, sym| ary << read_inheritable_attribute(#{enum_attr.inspect})[sym]; ary }
+          return #{enum_attr} if args.first.nil?
+          return #{enum_attr}[args.first] if args.size == 1
+          args.inject([]) { |ary, sym| ary << #{enum_attr}[sym]; ary }
         end
-        
+
         def self.#{attr_name}_for_select(attr = :key, &block)
           self.#{attr_name}.map do |k,v|
             [block_given? ? yield(k,v) : self.human_enum_name(#{attr_name.inspect}, k), attr == :value ? v : k]
           end
         end
       RUBY
-    
+
+      # write values
+      self.send "#{enum_attr}=", values
+
       # only create if :slim is not defined
       if options[:slim] != true
         # create both, boolean operations and *bang* operations for each
         # enum "value"
         prefix = options[:prefix] && "#{options[:prefix] == true ? enum_cd : options[:prefix]}_"
-    
+
         values.each do |k,code|
           sym = k.to_enum_sym
-        
+
           define_method("#{prefix}#{sym}?") do
             code == read_attribute(options[:column])
           end
@@ -212,7 +215,7 @@ module SimpleEnum
             write_attribute options[:column], code
             sym
           end
-        
+
           # allow class access to each value
           unless options[:slim] === :class
             metaclass.send(:define_method, "#{prefix}#{sym}", Proc.new { |*args| args.first ? k : code })
@@ -222,7 +225,7 @@ module SimpleEnum
     end
 
     include Validation
-    
+
     def human_enum_name(enum, key, options = {})
       klasses = self.respond_to?(:descendants) ? descendants : ancestors
       defaults = ([self] + klasses).map { |klass| :"#{klass.name.underscore}.#{enum}.#{key}" }
@@ -232,18 +235,11 @@ module SimpleEnum
       options[:count] ||= 1
       I18n.translate(defaults.shift, options.merge(:default => defaults.flatten, :scope => [:activerecord, :enums]))
     end
-  
-    protected
-      # Returns enum definitions as defined by each call to
-      # +as_enum+.
-      def enum_definitions
-        read_inheritable_attribute(:enum_definitions)
-      end
   end
 end
 
 # Tie stuff together and load translations if ActiveRecord is defined
 Object.send(:include, SimpleEnum::ObjectSupport)
- 
-ActiveRecord::Base.send(:include, SimpleEnum)
+
+ActiveRecord::Base.send(:include, SimpleEnum) if defined?(ActiveRecord)
 I18n.load_path << File.join(File.dirname(__FILE__), '..', 'locales', 'en.yml')

data/lib/simple_enum/validation.rb

@@ -1,6 +1,5 @@
 module SimpleEnum
   module Validation
-    
     # Validates an +as_enum+ field based on the value of it's column.
     #
     # Model:
@@ -14,7 +13,7 @@ module SimpleEnum
     #
     # Configuration options:
     # * <tt>:message</tt> - A custom error message (default: is <tt>[:activerecord, :errors, :messages, :invalid_enum]</tt>).
-    # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+    # * <tt>:on</tt> - Specifies when this validation is active (default is always, other options <tt>:create</tt>, <tt>:update</tt>).
     # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
     #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
     #   method, proc or string should return or evaluate to a true or false value.
@@ -22,15 +21,18 @@ 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 = attr_names.extract_options!
+
       attr_names.map! { |e| enum_definitions[e][:column] } # map to column name
-      validates_each(attr_names) do |record, attr_name, value|
+
+      validates_each(attr_names, configuration) 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)
+          params = { :value => value}
+          params[:default] = configuration[:message] if configuration[:message].present?
+          record.errors.add(enum_def[:name], :invalid_enum, params)
         end
       end
     end
   end
-end
+end

data/lib/simple_enum/version.rb

@@ -0,0 +1,5 @@
+module SimpleEnum
+
+  # +SimpleEnum+ version string.
+  VERSION = "1.4.0"
+end

data/locales/en.yml

@@ -4,11 +4,3 @@ en:
     errors:
       messages:
         invalid_enum: invalid option supplied.
-    enums:
-      dummy:
-        genders:
-          female: Girl
-        didums:
-          foo:
-            one: Foo
-            other: Foos

data/simple_enum.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simple_enum/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simple_enum"
+  s.version     = SimpleEnum::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "Simple enum-like field support for active records."
+  s.description = ""
+
+  s.required_ruby_version     = ">= 1.8.7"
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.authors  = ["Lukas Westermann"]
+  s.email    = ["lukas.westermann@gmail.com"]
+  s.homepage = "http://github.com/lwe/simple_enum"
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_path     = 'lib'
+
+  s.license          = 'MIT'
+
+  s.add_dependency "activesupport", "~> 3.0"
+
+  s.add_development_dependency 'rake', '>= 0.8.7'
+  s.add_development_dependency 'activerecord', '~> 3.0'
+  s.add_development_dependency 'mongoid', '~> 2.0'
+
+  unless RUBY_PLATFORM =~ /java/
+    s.add_development_dependency 'sqlite3'
+  else
+    s.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
+  end
+end

data/test/locales.yml

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

data/test/models.rb

@@ -1,12 +1,17 @@
 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 :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
   set_table_name 'dummies'

data/test/object_support_test.rb

@@ -1,3 +1,5 @@
+require File.expand_path('../test_helper', __FILE__)
+
 class ObjectSupportTest < ActiveSupport::TestCase
   
   test "ensure that symbols stay symbols" do
@@ -24,4 +26,4 @@ class ObjectSupportTest < ActiveSupport::TestCase
         
     assert_same :contains_spaces, another_named.to_enum_sym
   end
-end
+end

data/test/simple_enum_test.rb

@@ -1,35 +1,39 @@
 require 'test_helper'
 
-class SimpleEnumTest < ActiveSupport::TestCase  
+class SimpleEnumTest < ActiveSupport::TestCase
   def setup
     reload_db
   end
-  
+
+  test "reading public enum_definitions" do
+    assert_equal "gender_cd", Dummy.enum_definitions[:gender][:column]
+  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?)
@@ -38,58 +42,160 @@ class SimpleEnumTest < ActiveSupport::TestCase
     # Chris
     assert_equal(false, Dummy.find(3).female?)
     assert_equal(:gamma, Dummy.find(3).word)
-    assert_equal(:foobar, Dummy.find(3).didum)    
+    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!    
+    d.save!
     assert_equal(true, Dummy.find(d.id).female?)
   end
-  
-  test "add validation and test validations" do
-    Dummy.class_eval { validates_as_enum :gender }
-    
-    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)
+
+  test "validation :if" do
+    class ValidateIfComputer < Computer
+      set_table_name 'computers'
+
+      validates_as_enum :manufacturer, :if => lambda { |computer|
+        computer.name == "Fred"
+      }
+    end
+
+    computer = ValidateIfComputer.new(:manufacturer_cd => 48328432)
+
+    computer.name = nil
+    assert_equal(true, computer.save)
+
+    computer.name = "Fred"
+    assert_equal(false, computer.save)
+  end
+
+  test "validation :unless" do
+    class ValidateUnlessComputer < Computer
+      set_table_name 'computers'
+
+      validates_as_enum :manufacturer, :unless => lambda { |computer|
+        computer.name == "Unless"
+      }
+    end
+
+    computer = ValidateUnlessComputer.new(:manufacturer_cd => 48328432)
+
+    computer.name = nil
+    assert_equal(false, computer.save)
+    assert_equal(1, computer.errors[:manufacturer].size)
+
+    computer.name = "Unless"
+    assert_equal(true, computer.save)
+  end
+
+  test "validation :on => :update" do
+    class ValidateOnUpdateComputer < Computer
+      set_table_name 'computers'
+
+      validates_as_enum :manufacturer, :on => :update
+    end
+
+    computer = ValidateOnUpdateComputer.new(:manufacturer_cd => nil)
+    assert_equal(true, computer.save)
+
+    computer.name = 'Something else'
+    assert_equal(false, computer.save)
+    assert_equal(1, computer.errors[:manufacturer].size)
+  end
+
+  test "validation :on => :create" do
+    class ValidateOnCreateComputer < Computer
+      set_table_name 'computers'
+
+      validates_as_enum :manufacturer, :on => :create
+    end
+
+    computer = ValidateOnCreateComputer.new(:manufacturer_cd => nil)
+    assert_equal(false, computer.save)
+    assert_equal(1, computer.errors[:manufacturer].size)
+
+    computer.manufacturer = :apple
+    assert_equal(true, computer.save)
+
+    computer.manufacturer = nil
+    assert_equal(true, computer.save)
+  end
+
+  test "validation :allow_nil" do
+    class ValidateAllowNilComputer < Computer
+      set_table_name 'computers'
+
+      validates_as_enum :manufacturer, :allow_nil => true
+    end
+
+    computer = ValidateAllowNilComputer.new(:manufacturer_cd => nil)
+    assert_equal(true, computer.save)
+
+    computer.manufacturer = :apple
+    assert_equal(true, computer.save)
+
+    computer.manufacturer_cd = 84321483219
+    assert_equal(false, computer.save)
+    assert_equal(1, computer.errors[:manufacturer].size)
   end
-  
+
+  test "default error messages using translations" do
+    class ValidatedComputer < Computer
+      set_table_name 'computers'
+      validates_as_enum :manufacturer
+      validates_as_enum :operating_system
+    end
+
+    computer = ValidatedComputer.new
+    assert !computer.save, "save should return false"
+    assert_equal "invalid option supplied.", computer.errors[:manufacturer].first
+    assert_equal "y u no os?", computer.errors[:operating_system].first
+  end
+
+  test "allow setting custom error via :message" do
+    class ValidateMessageComputer < Computer
+      set_table_name 'computers'
+      validates_as_enum :manufacturer, :message => "invalid manufacturer"
+    end
+
+    computer = ValidateMessageComputer.new
+    assert !computer.valid?, "valid? should return false"
+    assert_equal "invalid manufacturer", computer.errors[:manufacturer].first
+  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)
     d.gender = ''
     assert_nil(d.gender)
   end
-  
+
   test "ensure that setting to 'nil' works if :whiny => true and :whiny => false" do
-    d = Dummy.new :gender => :male    
+    d = Dummy.new :gender => :male
     assert_equal(:male, d.gender)
     d.gender = nil
     assert_nil(d.gender)
     d.gender = ''
     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

data/test/test_helper.rb

@@ -12,25 +12,23 @@ require 'active_record'
 require 'active_support/version'
 require 'active_record/version'
 
-# 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 => RUBY_PLATFORM =~ /java/ ? 'jdbcsqlite3' : 'sqlite3',
   :database => ':memory:'})
 
 # load simple_enum
-require File.join(ROOT, 'init')
+require 'simple_enum'
 
 # load dummy class
-require File.join(ROOT, 'test', 'models')
+require File.join(File.dirname(__FILE__), 'models')
 
 # Test environment info
 puts "Testing against: activesupport-#{ActiveSupport::VERSION::STRING}, activerecord-#{ActiveRecord::VERSION::STRING}"
 
+# Add test locales
+I18n.load_path << File.join(File.dirname(__FILE__), 'locales.yml')
+
 # Reload database
 def reload_db(options = {})
   options = { :fill => true, :genders => false }.merge(options)
@@ -40,24 +38,30 @@ def reload_db(options = {})
     t.column :word_cd, :string, :limit => 5
     t.column :other, :integer
   end
-  
+
+  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
+
   # Create ref-data table and fill with records
   ActiveRecord::Base.connection.create_table :genders, :force => true do |t|
     t.column :name, :string
-  end  
-  
+  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]    
+
+  if options[:genders]
     male = Gender.new({ :name => 'male' })
     male.id = 0;
     male.save!
-    
+
     female = Gender.new({ :name => 'female' })
     female.id = 1;
     female.save!
@@ -68,6 +72,6 @@ end
 if Object.const_defined?('IRB')
   reload_db :fill => true, :genders => true
 else # and load test classes when in test cases...
-  require 'test/unit'  
+  require 'test/unit'
   require 'active_support/test_case'
-end
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: simple_enum
 version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: 
+  prerelease: false
   segments: 
   - 1
-  - 3
-  - 2
-  version: 1.3.2
+  - 4
+  - 0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Lukas Westermann
@@ -15,37 +14,102 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-08 00:00:00 +01:00
+date: 2011-09-09 00:00:00 +02:00
 default_executable: 
-dependencies: []
-
-description: 
-email: lukas.westermann@gmail.com
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: ""
+email: 
+- lukas.westermann@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
 - .gitignore
+- .travis.yml
 - Gemfile
-- Gemfile.BACKPORT
-- Gemfile.BACKPORT.lock
-- Gemfile.lock
 - LICENCE
 - README.rdoc
 - Rakefile
-- init.rb
 - lib/simple_enum.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/locales.yml
 - test/models.rb
 - test/object_backed_test.rb
 - test/object_support_test.rb
@@ -55,43 +119,44 @@ files:
 - test/without_shortcuts_test.rb
 has_rdoc: true
 homepage: http://github.com/lwe/simple_enum
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.1
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Simple enum-like field support for ActiveRecord (including validations and i18n)
+summary: Simple enum-like field support for active records.
 test_files: 
 - test/array_conversions_test.rb
 - test/class_methods_test.rb
 - test/enum_hash_test.rb
 - test/finders_test.rb
+- test/locales.yml
 - test/models.rb
 - test/object_backed_test.rb
 - test/object_support_test.rb

data/Gemfile.BACKPORT

@@ -1,7 +0,0 @@
-source :rubygems
-
-gem "activesupport", "2.3.5", :require => "active_support"
-gem "activerecord",  "2.3.5", :require => "active_record"
-
-gem "sqlite3-ruby", :require => "sqlite3", :platforms => :ruby
-gem "jdbc-sqlite3", :require => "jdbcsqlite3", :platforms => :jruby

data/Gemfile.BACKPORT.lock

@@ -1,16 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activerecord (2.3.5)
-      activesupport (= 2.3.5)
-    activesupport (2.3.5)
-    sqlite3-ruby (1.3.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activerecord (= 2.3.5)
-  activesupport (= 2.3.5)
-  jdbc-sqlite3
-  sqlite3-ruby

data/Gemfile.lock

@@ -1,29 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activemodel (3.0.5)
-      activesupport (= 3.0.5)
-      builder (~> 2.1.2)
-      i18n (~> 0.4)
-    activerecord (3.0.5)
-      activemodel (= 3.0.5)
-      activesupport (= 3.0.5)
-      arel (~> 2.0.2)
-      tzinfo (~> 0.3.23)
-    activesupport (3.0.5)
-    arel (2.0.9)
-    builder (2.1.2)
-    i18n (0.5.0)
-    sqlite3 (1.3.3)
-    sqlite3-ruby (1.3.3)
-      sqlite3 (>= 1.3.3)
-    tzinfo (0.3.24)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activerecord (~> 3.0)
-  activesupport (~> 3.0)
-  jdbc-sqlite3
-  sqlite3-ruby

data/init.rb

@@ -1 +0,0 @@
-require 'simple_enum'