active_enum 0.3.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Adam Meehan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,134 @@
+= ActiveEnum
+
+Define enum classes in Rails and use them to enumerate ActiveRecord attributes. Brings together some ideas
+of similar plugins that I liked and does it they way I prefer.
+
+Enum values are stored in memory at the moment but I plan to add database and yaml. 
+
+== Install
+
+On Gemcutter:
+
+  sudo gem install active_enum
+
+And add to your Rails environment.rb
+
+  config.gem 'active_enum'
+
+== Example
+
+Define an enum class with values
+
+  class Sex < ActiveEnum::Base
+    value :id => 1, :name => 'Male'
+    value :id => 2, :name => 'Female'
+  end
+
+Define using implicit id values
+
+  class Sex < ActiveEnum::Base
+    value :name => 'Male'
+    value :name => 'Female'
+  end
+
+Beware that if you change the order of values defined in an enum which don't have explicit ids, then the ids will change.
+This could corrupt your data if the enum values have been stored in a model record, as they will no longer map to
+the original enum.
+
+Enum class usage
+
+  Sex[1]        # => 'Male'
+  Sex['Male']   # => 1
+  Sex[:male]    # => 1
+  Sex.to_select # => [['Male', 1], ['Female',2]] for select form helpers
+
+Use the enum to enumerate an ActiveRecord model attribute
+
+  class User < ActiveRecord::Base
+    enumerate :sex, :with => Sex
+  end
+
+Skip the with option if the enum can be implied from the attribute
+
+  class User < ActiveRecord::Base
+    enumerate :sex
+  end
+
+Define enum class implicitly in enumerate block
+
+  class User < ActiveRecord::Base
+    # defines UserSex enum
+    enumerate :sex do
+      value :name => 'Male'
+    end
+  end
+
+Access the enum values and the enum class using the attribute method with a symbol for the enum component you want
+
+  user = User.new
+  user.sex = 1
+  user.sex         # => 1
+
+  user.sex(:id)    # => 1
+  user.sex(:name)  # => 'Male'
+  user.sex(:enum)  # => Sex 
+
+You can check if the attribute value matches a particular enum value by passing the enum value as an argument to the question method
+
+  user.sex?(:male)    # => true
+  user.sex?(:Male)    # => true
+  user.sex?('Male')   # => true
+  user.sex?('Female') # => false
+
+A convience method on the class is available to the enum class of any enumerated attribute
+
+  User.enum_for(:sex) # => Sex
+
+You can set the default to return the enum name value for enumerated attribute
+
+  ActiveEnum.use_name_as_value = true
+  user.sex # => 'Male'
+
+Define enum classes in bulk without class files, in an initializer file for example.
+
+  ActiveEnum.define do
+
+    # defines Sex
+    enum(:sex) do
+      value :name => 'Male'
+      value :name => 'Female'
+    end
+
+    # defines Language 
+    enum(:language) do
+      value :name => 'English'
+      value :name => 'German'
+    end
+
+  end
+
+All defined enum classes are stored in ActiveEnum.enum_classes array if you need look them up or iterate over them.
+
+You can make an existing model class behave like an enum class with acts_as_enum
+
+  class User < ActiveRecord::Base
+    acts_as_enum :name_column => 'first_name'
+  end
+
+Giving you the familiar enum methods
+
+  User[1]
+  User['Dave']
+  User.to_select
+
+
+== TODO
+* more docs
+* storage options of memory, database or yaml
+* use custom method name for the enumerated attribute
+* named_scopes
+* question methods for enum names e.g. user.male?
+* possibly allow string enum values to assigned to attributes
+* add enum value class for instances if there is a need
+
+Copyright (c) 2009 Adam Meehan, released under the MIT license

data/Rakefile

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'spec/rake/spectask'
+require 'lib/active_enum/version'
+
+GEM_NAME = "active_enum"
+GEM_VERSION = ActiveEnum::VERSION
+AUTHOR   = "Adam Meehan"
+EMAIL    = "adam.meehan@gmail.com"
+HOMEPAGE = "http://github.com/adzap/active_enum"
+SUMMARY  = "Define enum classes in Rails and use them to enumerate ActiveRecord attributes"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = "active_enum"
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM_NAME
+  s.files = %w(MIT-LICENSE README.rdoc Rakefile) + Dir.glob("{lib,spec}/**/*")
+end
+
+desc 'Default: run specs.'
+task :default => :spec
+
+spec_files = Rake::FileList["spec/**/*_spec.rb"]
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = spec_files
+  t.spec_opts = ["-c"]
+end
+
+desc "Generate code coverage"
+Spec::Rake::SpecTask.new(:coverage) do |t|
+  t.spec_files = spec_files
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec,/var/lib/gems']
+end
+
+desc 'Generate documentation for plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveEnum'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM_NAME}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/lib/active_enum.rb

@@ -0,0 +1,31 @@
+require 'active_enum/base'
+require 'active_enum/extensions'
+require 'active_enum/acts_as_enum'
+require 'active_enum/version'
+
+module ActiveEnum
+  mattr_accessor :enum_classes
+  self.enum_classes = []
+
+  mattr_accessor :use_name_as_value
+  self.use_name_as_value = false
+
+  class Configuration
+    def enum(name, &block)
+      class_name = name.to_s.classify
+      class_def = <<-end_eval
+        class #{class_name} < ActiveEnum::Base
+        end
+      end_eval
+      eval(class_def, TOPLEVEL_BINDING)
+      new_enum = Module.const_get(class_name)
+      new_enum.class_eval(&block)
+    end
+  end
+
+  def self.define(&block)
+    raise "Define requires block" unless block_given?
+    Configuration.new.instance_eval(&block)
+  end
+
+end

data/lib/active_enum/acts_as_enum.rb

@@ -0,0 +1,57 @@
+module ActiveEnum
+
+  module ActsAsEnum
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def acts_as_enum(options={})
+        class_inheritable_accessor :active_enum_options
+        self.active_enum_options = options.reverse_merge(:name_column => 'name')
+        named_scope :enum_values,
+                      :select     => "#{primary_key}, #{active_enum_options[:name_column]}",
+                      :conditions => active_enum_options[:conditions],
+                      :order      => active_enum_options[:order]
+      end
+
+      def ids
+        enum_values.map {|v| v.id }
+      end
+
+      def names
+        enum_values.map {|v| v.send(active_enum_options[:name_column]) }
+      end
+
+      def to_select
+        enum_values.map {|v| [v.send(active_enum_options[:name_column]), v.id] }
+      end
+
+      def [](index)
+        if index.is_a?(Fixnum)
+          v = lookup_by_id(index)
+          v.send(active_enum_options[:name_column]) unless v.blank?
+        else
+          v = lookup_by_name(index)
+          v.id unless v.blank?
+        end
+      end
+
+      private
+
+      def lookup_by_id(index)
+        enum_values.find_by_id(index)
+      end
+
+      def lookup_by_name(index)
+        enum_values.find(:first, :conditions => ["#{active_enum_options[:name_column]} like ?", index.to_s])
+      end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send :include, ActiveEnum::ActsAsEnum

data/lib/active_enum/base.rb

@@ -0,0 +1,76 @@
+module ActiveEnum
+  class DuplicateValue < StandardError; end
+
+  class Base
+
+    class << self
+      
+      def inherited(subclass)
+        ActiveEnum.enum_classes << subclass
+      end
+
+      # :id => 1, :title => 'Foo'
+      # :title => 'Foo'
+      #
+      def value(enum_value={})
+        @values ||= [] 
+
+        id = enum_value[:id] || next_id
+        check_duplicate(id, enum_value[:name])
+
+        @values << [id, enum_value[:name]]
+        @values.sort! {|a,b| a[0] <=> b[0] }
+      end
+
+      def all
+        @values || []
+      end
+
+      def ids
+        @values.map {|v| v[0] }
+      end
+
+      def names
+        @values.map {|v| v[1] }
+      end
+
+      def to_select
+        @values.map {|v| [v[1], v[0]] }
+      end
+
+      def [](index)
+        if index.is_a?(Fixnum)
+          row = lookup_by_id(index)
+          row[1] if row
+        else
+          row = lookup_by_name(index)
+          row[0] if row
+        end
+      end
+
+      private
+
+      def lookup_by_id(index)
+        @values.assoc(index)
+      end
+
+      def lookup_by_name(index)
+        @values.rassoc(index.to_s) || @values.rassoc(index.to_s.titleize)
+      end
+      
+      def next_id
+        (ids.max || 0) + 1
+      end
+
+      def check_duplicate(id, name)
+        if lookup_by_id(id)
+          raise ActiveEnum::DuplicateValue, "The id #{id} is already defined for #{self} enum."
+        elsif lookup_by_name(name)
+          raise ActiveEnum::DuplicateValue, "The name #{name} is already defined for #{self} enum."
+        end
+      end
+
+    end
+
+  end
+end

data/lib/active_enum/extensions.rb

@@ -0,0 +1,130 @@
+module ActiveEnum
+  class EnumNotFound < StandardError; end
+
+  module Extensions
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_inheritable_accessor :enumerated_attributes
+      base.enumerated_attributes = {}
+    end
+
+    module ClassMethods
+
+      # Declare an attribute to be enumerated by an enum class
+      # 
+      #   class Person < ActiveRecord::Base
+      #     enumerate :sex, :with => Sex
+      #     enumerate :sex # implies a Sex enum class exists
+      #
+      #     # Pass a block to create implicit enum class as ModelAttribute e.g. PersonSex 
+      #     enumerate :sex do
+      #       value :id => 1, :name => 'Male'
+      #     end
+      #
+      def enumerate(attribute, options={}, &block)
+        attribute = attribute.to_sym
+        if block_given?
+          enum_name = "#{self.to_s.underscore}_#{attribute}"
+          ActiveEnum.define { enum(enum_name, &block) }
+          enum = enum_name.classify.constantize
+        else
+          enum = options[:with] || attribute.to_s.classify.constantize
+        end
+
+        self.enumerated_attributes[attribute] = enum
+
+        define_active_enum_read_method(attribute)
+        define_active_enum_write_method(attribute)
+        define_active_enum_question_method(attribute)
+      rescue NameError => e
+        raise e unless e.message =~ /uninitialized constant/
+        raise ActiveEnum::EnumNotFound, "Enum class could not be found for attribute '#{attribute}' in class #{self}. Specify the enum class using the :with option."
+      end
+
+      def enum_for(attribute)
+        self.enumerated_attributes[attribute.to_sym]
+      end
+
+      # Define read method to allow an argument for the enum component
+      #
+      #   user.sex
+      #   user.sex(:id)
+      #   user.sex(:name)
+      #   user.sex(:enum)
+      #
+      def define_active_enum_read_method(attribute)
+        unless instance_method_already_implemented?(attribute)
+          define_read_method(attribute, attribute.to_s, columns_hash[attribute.to_s])
+        end
+
+        old_method = "#{attribute}_without_enum"
+        define_method("#{attribute}_with_enum") do |*arg|
+          arg = arg.first
+          value = send(old_method)
+
+          enum = self.class.enum_for(attribute)
+          case arg
+          when :id
+            value if enum[value]
+          when :name
+            enum[value]
+          when :enum
+            enum
+          else
+            ActiveEnum.use_name_as_value ? enum[value] : value
+          end
+        end
+
+        alias_method_chain attribute, :enum
+      end
+
+      # Define write method to also handle enum value
+      #
+      #   user.sex = 1
+      #   user.sex = :male
+      #
+      def define_active_enum_write_method(attribute)
+        unless instance_method_already_implemented?("#{attribute}=")
+          define_write_method(attribute)
+        end
+
+        old_method = "#{attribute}_without_enum="
+        define_method("#{attribute}_with_enum=") do |arg|
+          enum = self.class.enum_for(attribute)
+          if arg.is_a?(Symbol)
+            value = enum[arg]
+            send(old_method, value)
+          else
+            send(old_method, arg)
+          end
+        end
+
+        alias_method_chain "#{attribute}=".to_sym, :enum
+      end
+
+      # Define question method to check enum value against attribute value
+      #
+      #   user.sex?(:male)
+      #
+      def define_active_enum_question_method(attribute)
+        define_question_method(attribute) unless instance_method_already_implemented?("#{attribute}?")
+
+        old_method = "#{attribute}_without_enum?"
+        define_method("#{attribute}_with_enum?") do |*arg|
+          arg = arg.first
+          if arg
+            send(attribute) == self.class.enum_for(attribute)[arg]
+          else
+            send(old_method)
+          end
+        end
+        alias_method_chain "#{attribute}?".to_sym, :enum
+      end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send :include, ActiveEnum::Extensions

data/lib/active_enum/version.rb

@@ -0,0 +1,3 @@
+module ActiveEnum
+  VERSION = '0.3.0'
+end

data/spec/active_enum/acts_as_enum_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class Person < ActiveRecord::Base
+  acts_as_enum :name_column => 'first_name'
+end
+
+describe ActiveEnum::ActsAsEnum do
+  before(:all) do
+    @person = Person.create!(:first_name => 'Dave', :last_name => 'Smith')
+  end
+
+  it 'return name column value when passing id to [] method' do
+    Person[@person.id].should == @person.first_name
+  end
+
+  it 'return id column value when passing string name to [] method' do
+    Person['Dave'].should == @person.id
+    Person['dave'].should == @person.id
+  end
+
+  it 'return id column value when passing symbol name to [] method' do
+    Person[:dave].should == @person.id
+  end
+
+  it 'should return array for select helpers from to_select' do
+    Person.to_select.should == [[@person.first_name, @person.id]]
+  end
+end

data/spec/active_enum/base_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ActiveEnum::Base do
+  it 'should return empty array from :all method when no values defined' do
+    ActiveEnum.enum_classes = []
+    class NewEnum < ActiveEnum::Base
+    end
+    ActiveEnum.enum_classes.should == [NewEnum]
+  end
+
+  it 'should return empty array from :all method when no values defined' do
+    define_enum.all.should == []
+  end
+
+  it 'should allow me to define a value with an id and name' do
+    enum = define_enum do
+      value :id => 1, :name => 'Name'
+    end
+    enum.all.should == [[1,'Name']]
+  end
+
+  it 'should allow me to define a value with a name only' do
+    enum = define_enum do
+      value :name => 'Name'
+    end
+    enum.all.should == [[1,'Name']]
+  end
+
+  it 'should increment value ids when defined without ids' do
+    enum = define_enum do
+      value :name => 'Name 1'
+      value :name => 'Name 2'
+    end
+    enum.all.should == [[1,'Name 1'], [2, 'Name 2']]
+  end
+
+  it 'should raise error is the id is a duplicate' do
+    lambda do
+      define_enum do
+        value :id => 1, :name => 'Name 1'
+        value :id => 1, :name => 'Name 2'
+      end
+    end.should raise_error(ActiveEnum::DuplicateValue)
+  end
+
+  it 'should raise error is the name is a duplicate' do
+    lambda do
+      define_enum do
+        value :id => 1, :name => 'Name'
+        value :id => 2, :name => 'Name'
+      end
+    end.should raise_error(ActiveEnum::DuplicateValue)
+  end
+
+  it 'should return sorted values by id from :all' do
+    enum = define_enum do
+      value :id => 2, :name => 'Name 2'
+      value :id => 1, :name => 'Name 1'
+    end
+    enum.all.first[0].should == 1
+  end
+
+  it 'should return array of ids' do
+    enum = define_enum do
+      value :id => 1, :name => 'Name 1'
+      value :id => 2, :name => 'Name 2'
+    end
+    enum.ids.should == [1,2]
+  end
+
+  it 'should return array of names' do
+    enum = define_enum do
+      value :id => 1, :name => 'Name 1'
+      value :id => 2, :name => 'Name 2'
+    end
+    enum.names.should == ['Name 1', 'Name 2']
+  end
+
+  describe "element reference method" do
+
+    it 'should return name when given an id' do
+      enum = define_enum do
+        value :id => 1, :name => 'Name 1'
+        value :id => 2, :name => 'Name 2'
+      end
+      enum[1].should == 'Name 1'
+    end
+
+    it 'should return id when given a name' do
+      enum = define_enum do
+        value :id => 1, :name => 'Name 1'
+        value :id => 2, :name => 'Name 2'
+      end
+      enum['Name 1'].should == 1
+    end
+
+    it 'should return id when given a symbol of the name' do
+      enum = define_enum do
+        value :id => 1, :name => 'Name 1'
+        value :id => 2, :name => 'Name 2'
+      end
+      enum[:Name_1].should == 1
+      enum[:name_1].should == 1
+    end
+
+  end
+
+  it 'should return array for select helpers from to_select' do
+    enum = define_enum do
+      value :id => 1, :name => 'Name 1'
+      value :id => 2, :name => 'Name 2'
+    end
+    enum.to_select.should == [['Name 1',1], ['Name 2',2]]
+  end
+
+  def define_enum(&block)
+    Class.new(ActiveEnum::Base, &block)
+  end
+
+end

data/spec/active_enum/extensions_spec.rb

@@ -0,0 +1,163 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class Sex < ActiveEnum::Base
+  value :id => 1, :name => 'Male'
+  value :id => 2, :name => 'Female'
+end
+
+describe ActiveEnum::Extensions do
+  before do
+    Person.class_eval do
+      enumerate :sex, :with => Sex
+    end
+    @person = Person.new(:sex =>1)
+  end
+
+  it 'should add class :enumerate method to ActiveRecord' do
+    ActiveRecord::Base.should respond_to(:enumerate)
+  end
+
+  it 'should add class :enum_for method to ActiveRecord' do
+    ActiveRecord::Base.should respond_to(:enum_for)
+  end
+
+  it 'should allow implicit enumeration class from attribute name' do
+    Person.class_eval do
+      enumerate :sex
+    end
+    Person.enum_for(:sex).should == Sex
+  end
+
+  it 'should allow implicit enumeration class from block' do
+    Person.class_eval do
+      enumerate :sex do
+        value :id => 1, :name => 'Male'
+      end
+    end
+    Person.enum_for(:sex).should == PersonSex
+  end
+
+  it 'should raise error if implicit enumeration class cannot be found' do
+    lambda do
+      Person.class_eval { enumerate :first_name }
+    end.should raise_error(ActiveEnum::EnumNotFound)
+  end
+
+  describe "attribute with value" do
+    it 'should return value with no arg' do
+      @person.sex.should == 1
+    end
+
+    it 'should return enum id for value' do
+      @person.sex(:id).should == 1
+    end
+
+    it 'should return enum name for value' do
+      @person.sex(:name).should == 'Male'
+    end
+
+    it 'should return enum class for attribute' do
+      @person.sex(:enum).should == Sex
+    end
+  end
+
+  describe "nil attribute value" do
+    before do
+      @person.sex = nil
+    end
+
+    it 'should return nil with no arg' do
+      @person.sex.should be_nil
+    end
+
+    it 'should return nil enum id' do
+      @person.sex(:id).should be_nil
+    end
+
+    it 'should return nil enum name' do
+      @person.sex(:name).should be_nil
+    end
+
+    it 'should return enum class for attribute' do
+      @person.sex(:enum).should == Sex
+    end
+  end
+
+  describe "attribute with undefined value" do
+    before do
+      @person.sex = -1
+    end
+
+    it 'should return value with no arg' do
+      @person.sex.should == -1
+    end
+
+    it 'should return nil enum id' do
+      @person.sex(:id).should be_nil
+    end
+
+    it 'should return nil enum name' do
+      @person.sex(:name).should be_nil
+    end
+
+    it 'should return enum class for attribute' do
+      @person.sex(:enum).should == Sex
+    end
+  end
+
+  describe "attribute question method" do
+    before do
+      @person.sex = 1
+    end
+
+    it 'should return normal value without arg' do
+      @person.sex?.should be_true
+      @person.sex = nil
+      @person.sex?.should be_false
+    end
+
+    it 'should return true if string name matches for id value' do
+      @person.sex?("Male").should be_true
+    end
+
+    it 'should return true if symbol name matches for id value' do
+      @person.sex?(:male).should be_true
+      @person.sex?(:Male).should be_true
+    end
+
+    it 'should return false if name does not match for id value' do
+      @person.sex?("Female").should be_false
+      @person.sex?(:female).should be_false
+      @person.sex?(:Female).should be_false
+    end
+  end
+
+  describe "assigning enum name symbol to attribute" do
+
+    it 'should store id value when valid enum name' do
+      @person.sex = :female
+      @person.sex.should == 2
+    end
+
+    it 'should store nil value when invalid enum name' do
+      @person.sex = :invalid
+      @person.sex.should == nil
+    end
+
+  end
+
+  describe "use enum name as attribute value" do
+    before(:all) do
+      ActiveEnum.use_name_as_value = true
+    end
+
+    it 'should return text name value for attribute' do
+      @person.sex.should == 'Male'
+    end
+
+    after(:all) do
+      ActiveEnum.use_name_as_value = false
+    end
+  end
+
+end

data/spec/active_enum_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Bulk enum definitions" do
+
+  it 'define enum constants using block' do
+    ActiveEnum.define do
+      enum(:foo) do
+        value :id => 1, :name => 'Foo 1'
+      end
+
+      enum(:bar) do
+        value :id => 1, :name => 'Bar 1'
+      end
+    end
+
+    Foo.all.should == [[1,'Foo 1']]
+    Bar.all.should == [[1,'Bar 1']]
+  end
+
+end

data/spec/schema.rb

@@ -0,0 +1,13 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :people, :force => true do |t|    
+    t.string   :first_name
+    t.string   :last_name
+    t.integer  :sex
+  end
+
+  create_table :sexes, :force => true do |t|
+    t.string :name
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'spec'))
+
+require 'rubygems'
+require 'spec/autorun'
+
+require 'active_record'
+require 'active_enum'
+
+RAILS_ROOT = File.dirname(__FILE__)
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
+
+require 'schema'
+
+class Person < ActiveRecord::Base; end
+
+module SpecHelper
+
+end
+
+Spec::Runner.configure do |config|
+  config.include SpecHelper
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: active_enum
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Adam Meehan
+autorequire: active_enum
+bindir: bin
+cert_chain: []
+
+date: 2009-11-05 00:00:00 +11:00
+default_executable: 
+dependencies: []
+
+description: Define enum classes in Rails and use them to enumerate ActiveRecord attributes
+email: adam.meehan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/active_enum.rb
+- lib/active_enum/base.rb
+- lib/active_enum/version.rb
+- lib/active_enum/extensions.rb
+- lib/active_enum/acts_as_enum.rb
+- spec/schema.rb
+- spec/active_enum_spec.rb
+- spec/spec_helper.rb
+- spec/active_enum/acts_as_enum_spec.rb
+- spec/active_enum/extensions_spec.rb
+- spec/active_enum/base_spec.rb
+has_rdoc: true
+homepage: http://github.com/adzap/active_enum
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: active_enum
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Define enum classes in Rails and use them to enumerate ActiveRecord attributes
+test_files: []
+