magic_enum 0.9.0 → 1.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cdd3250404ebdecd1fdb9aeb525cfdc5bbdf8a94
+  data.tar.gz: 6df523ae0550f389ef112b0d9d598d8e477819a8
+SHA512:
+  metadata.gz: 80c0eefee215b74e86e003ebf4962fa4f35a513309197f10ecab2822ad574c84bbcc0da3e11ddfed334f9e205033188a56a0090c1956ea100b1fd7c7aeb43d93
+  data.tar.gz: a42a06ade03d296c9fb75cf46e42c06ad1c0d58f4cb9e28778bfbfacb60c1bdbbb114fb59c79e438fc5e0702ae644c7368d0d3763f3d59f6f7fa1a270495b30a

data/.gitignore

@@ -5,3 +5,4 @@
 Gemfile.lock
 doc
 pkg
+*.gem

data/.travis.yml

@@ -29,3 +29,4 @@ matrix:
 notifications:
   recipients:
     - kpumuk@kpumuk.info
+    - alexey@kovyrin.net

data/CHANGELOG.md

@@ -0,0 +1,81 @@
+## 1.0.0 (in development)
+
+Features:
+
+  - Added "enum_value" (returns value) instance method in addition to "enum_name" (returns stringified enum key)
+  - Added class methods "enum_value" (returns value by key) and "enum_by_value" (returns key by value)
+  - Performance improvement: use `class_eval` with string instead of blocks
+
+Bugfixes:
+
+  - Fixed const naming: use `SIMPLE_STATUSES` and `SIMPLE_STATUSES_INVERTED` instead of `SimpleStatuses` and `SimpleStatusesInverted`
+
+## 0.9.0 (August 8, 2013)
+
+Bugfixes:
+
+  - Allow `nil` values
+  - Updated specs to RSpec 1.2 syntax
+
+Features:
+
+  - Rails 4.0.0 support
+
+## 0.0.3 (January 29, 2012)
+
+Features:
+
+  - Files re-organization
+
+## 0.0.2 (January 29, 2012)
+
+Features:
+
+  - Rails < 3.3 support
+
+## 0.0.1 (January 29, 2012)
+
+Features:
+
+  - First gem version
+
+## 0.0.0 (January 16, 2009)
+
+Features:
+
+  - Setter method symbolizes strings
+
+Bugfixes:
+
+  - Added tests for named scopes
+
+## 0.0.0 (September 21, 2008)
+
+Features:
+
+  - Added a special named scope "of_name", which accepts symbol
+  - Added scope extensions
+
+## 0.0.0 (September 1, 2008)
+
+Features:
+
+  - Setter method accepts integer values in addition to symbols
+
+## 0.0.0 (August 30, 2008)
+
+Features:
+
+  - Added support of named scopes
+
+## 0.0.0 (August 30, 2008)
+
+Features:
+
+  - Added support of named scopes
+
+## 0.0.0 (May 12, 2008)
+
+Features:
+
+  - Basic ENUM functionality

data/README.md

@@ -0,0 +1,103 @@
+# MagicEnum
+
+[![Travis-CI build status](https://secure.travis-ci.org/kovyrin/magic-enum.png)](http://travis-ci.org/kovyrin/magic-enum)
+
+MagicEnum is a simple ActiveRecord plugin that makes it easier to maintain ENUM-like attributes in your models.
+
+Examples:
+
+    STATUSES = {
+      :draft     => 0,
+      :published => 1,
+      :approved  => 2,
+    }
+    define_enum :status
+
+## Please note: breaking changes in 1.0.0
+
+Before version 1.0.0, the hash with ENUM values was camel-cased. We decided to change it to more rubyish upper-cased constant names. If you're upgrading from pre-1.0.0, please
+change you constants accordingly. Examples:
+
+    Statuses => STATUSES
+    SimpleStatuses => SIMPLE_STATUSES
+
+Name of inverted hash was changed as well:
+
+    StatusesInverted => STATUSES_INVERTED
+    SimpleStatusesInverted => SIMPLE_STATUSES_INVERTED
+
+## How to Use
+
+Before using `define_enum`, you should define constant with ENUM options.
+Constant name would be pluralized enum attribute name (e.g. `SIMPLE_STATUSES`
+`simple_status` enum). Additional constant named like `YOUR_ENUM_INVERTED`
+would be created automatically and would contain inverted hash.
+
+**Please note**: `nil` and `0` are not the same values!
+
+You could specify additional options:
+
+* `:default` — value which will be used when current state of ENUM attribute is invalid or wrong value received. If it has not been specified, min value of the ENUM would be used. Could be specified as a symbol;
+* `:raise_on_invalid` — if `true` an exception would be raised on invalid enum value received. If it is `false`, default value would be used instead of wrong one;
+* `:simple_accessors` — if `true`, additional methods for each ENUM value would be defined in form `value?`. Methods returns `true` when ENUM attribute has corresponding value;
+* `:enum` — string with name of the ENUM hash;
+* `:named_scopes` — whether to generate named scopes for values of ENUM (pluralized key names). In addition to per-key named scope, `of_name` scope will be generated, which accepts a symbol corresponding to ENUM value.
+
+Look the following example:
+
+    STATUSES = {
+      :unknown   => 0,
+      :draft     => 1,
+      :published => 2,
+      :approved  => 3,
+    }
+    define_enum :status, :default => 1, :raise_on_invalid => true, :simple_accessors => true
+
+This example is identical to:
+
+    STATUSES = {
+      :unknown   => 0,
+      :draft     => 1,
+      :published => 2,
+      :approved  => 3,
+    }
+    STATUSES_INVERTED = STATUSES.invert
+
+    def self.status_value(status)
+      STATUSES[status]
+    end
+
+    def self.status_by_value(value)
+      STATUSES_INVERTED[value]
+    end
+
+    def status
+      self.class.status_by_value(self[:status]) || self.class.status_by_value(1)
+    end
+
+    def status=(value)
+      raise ArgumentError, "Invalid value \"#{value}\" for :status attribute of the #{self.class} model" unless STATUSES.key?(value)
+      self[:status] = STATUSES[value]
+    end
+
+    def unknown?
+      status == :unknown
+    end
+
+    def draft?
+      status == :draft
+    end
+
+    def published?
+      status == :published
+    end
+
+    def approved?
+      status == :approved
+    end
+
+## Who are the authors?
+
+This plugin was originally developed for [BestTechVideos project](http://www.bestechvideos.com) by [Dmytro Shteflyuk](http://kpumuk.info)
+and later cleaned up in Scribd repository and released to the public by [Oleksiy Kovyrin](http://kovyrin.net). All the code in this package is released under
+the MIT license. For more details, see the LICENSE file.

data/lib/magic_enum/class_methods.rb

@@ -2,10 +2,10 @@ module MagicEnum
   module ClassMethods
     # Method used to define ENUM attributes in your model. Examples:
     #
-    #   Statuses = {
-    #     :draft => 0,
+    #   STATUSES = {
+    #     :draft     => 0,
     #     :published => 1,
-    #     :approved => 2
+    #     :approved  => 2,
     #   }
     #   define_enum :status
     #
@@ -31,31 +31,39 @@ module MagicEnum
     #
     # Look the following example:
     #
-    #   Statuses = {
-    #     :unknown => 0,
-    #     :draft => 1,
+    #   STATUSES = {
+    #     :unknown   => 0,
+    #     :draft     => 1,
     #     :published => 2,
-    #     :approved => 3
+    #     :approved  => 3,
     #   }
     #   define_enum :status, :default => 1, :raise_on_invalid => true, :simple_accessors => true
     #
     # This example is identical to:
     #
-    #   Statuses = {
-    #     :unknown => 0,
-    #     :draft => 1,
+    #   STATUSES = {
+    #     :unknown   => 0,
+    #     :draft     => 1,
     #     :published => 2,
-    #     :approved => 3
+    #     :approved  => 3,
     #   }
-    #   StatusesInverted = Statuses.invert
+    #   STATUSES_INVERTED = STATUSES.invert
+    #
+    #   def self.status_value(status)
+    #     STATUSES[status]
+    #   end
+    #
+    #   def self.status_by_value(value)
+    #     STATUSES_INVERTED[value]
+    #   end
     #
     #   def status
-    #     return StatusesInverted[self[:status].to_i] || StatusesInverted[1]
+    #     self.class.status_by_value(self[:status]) || self.class.status_by_value(1)
     #   end
     #
     #   def status=(value)
-    #     raise ArgumentError, "Invalid value \"#{value}\" for :status attribute of the #{self.class} model" if Statuses[value].nil?
-    #     self[:status] = Statuses[value]
+    #     raise ArgumentError, "Invalid value \"#{value}\" for :status attribute of the #{self.class} model" unless STATUSES.key?(value)
+    #     self[:status] = STATUSES[value]
     #   end
     #
     #   def unknown?
@@ -75,65 +83,82 @@ module MagicEnum
     #   end
     #
     def define_enum(name, opts = {})
-      default_opts = {  :raise_on_invalid => false,
-                        :simple_accessors => false,
-                        :named_scopes => false,
-                        :scope_extensions => false
-                        }
-      opts = default_opts.merge(opts)
+      opts = opts.reverse_merge({
+        :raise_on_invalid => false,
+        :simple_accessors => false,
+        :named_scopes     => false,
+        :scope_extensions => false,
+      })
       name = name.to_sym
 
-      # bug in Rails 1.2.2
-      opts[:enum] = name.to_s.pluralize.classify.pluralize unless opts[:enum]
+      opts[:enum] ||= name.to_s.pluralize.upcase
       enum = opts[:enum]
-      enum_inverted = "#{enum}Inverted"
-
-      opts[:default] = const_get(enum).values.sort do |a, b|
-        if a.nil? and b.nil?
-          0
-        elsif a.nil?
-          -1
-        elsif b.nil?
-          1
-        else
-          a <=> b
+      enum_inverted = "#{enum}_INVERTED"
+      enum_value = const_get(enum)
+
+      if opts.key?(:default)
+        opts[:default] = enum_value[opts[:default]] if opts[:default].is_a?(Symbol)
+      else
+        opts[:default] = enum_value.values.sort do |a, b|
+          if a.nil? and b.nil?
+            0
+          elsif a.nil?
+            -1
+          elsif b.nil?
+            1
+          else
+            a <=> b
+          end
+        end.first
+      end
+
+      const_set(enum_inverted, enum_value.invert)
+
+      class_eval <<-RUBY
+        def self.#{name}_value(name)
+          name = name.to_sym if name.is_a?(String)
+          #{enum}[name]
         end
-      end.first unless opts.key?(:default)
 
-      const_set(enum_inverted, const_get(enum).invert)
+        def self.#{name}_by_value(value)
+          #{enum_inverted}[value]
+        end
 
-      define_method name do
-        self.class.const_get(enum_inverted)[self[name]] || self.class.const_get(enum_inverted)[opts[:default]]
-      end
+        def #{name}
+          self.class.#{name}_by_value(self[:#{name}]) || self.class.#{name}_by_value(#{opts[:default].inspect})
+        end
 
-      define_method "#{name}_name" do
-        send(name).to_s
-      end
+        def #{name}_name
+          self.#{name}.to_s
+        end
 
-      define_method "#{name}=" do |value|
-        value = value.to_sym if value.is_a?(String)
-        if value.is_a?(Integer)
-          raise ArgumentError, "Invalid value \"#{value}\" for :#{name} attribute of the #{self.class} model" if opts[:raise_on_invalid] and !self.class.const_get(enum_inverted).key?(value)
-          self[name] = value
-        else
-          raise ArgumentError, "Invalid value \"#{value}\" for :#{name} attribute of the #{self.class} model" if opts[:raise_on_invalid] and !self.class.const_get(enum).key?(value)
-          self[name] = self.class.const_get(enum)[value] || opts[:default]
+        def #{name}_value
+          self[:#{name}] || #{opts[:default].inspect}
         end
-      end
 
-      if opts[:simple_accessors]
-        const_get(enum).keys.each do |key|
-          define_method "#{key}?" do
-            send(name) == key
+        def #{name}=(value)
+          value = value.to_sym if value.is_a?(String)
+          if value.is_a?(Integer)
+            raise ArgumentError, "Invalid value \\"\#{value}\\" for :#{name} attribute of the #{self.name} model" if #{!!opts[:raise_on_invalid]} and !#{enum_inverted}.key?(value)
+            self[:#{name}] = value
+          else
+            raise ArgumentError, "Invalid value \\"\#{value}\\" for :#{name} attribute of the #{self.name} model" if #{!!opts[:raise_on_invalid]} and !#{enum}.key?(value)
+            self[:#{name}] = self.class.#{name}_value(value) || #{opts[:default].inspect}
           end
         end
+      RUBY
+
+      if opts[:simple_accessors]
+        enum_value.keys.each do |key|
+          class_eval "def #{key}?() #{name} == :#{key} end"
+        end
       end
 
       # Create named scopes for each enum value
       if opts[:named_scopes]
         scope_definition_method = respond_to?(:named_scope) ? :named_scope : :scope
 
-        const_get(enum).each do |key, value|
+        enum_value.keys.each do |key|
           define_enum_scope(enum, key.to_s.pluralize, name, key, opts[:scope_extensions])
         end
 

data/lib/magic_enum/version.rb

@@ -1,10 +1,10 @@
 # Version info
 module MagicEnum
   module Version
-    MAJOR = 0
-    MINOR = 9
+    MAJOR = 1
+    MINOR = 0
     PATCH = 0
-    BUILD = nil
+    BUILD = 'beta1'
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end

data/magic_enum.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
 
   s.files            = `git ls-files`.split("\n")
   s.require_paths    = [ 'lib' ]
-  s.extra_rdoc_files = [ 'LICENSE', 'README.rdoc' ]
+  s.extra_rdoc_files = [ 'LICENSE', 'README.md' ]
 
   # Dependencies
   s.add_dependency 'activerecord'

data/spec/magic_enum_spec.rb

@@ -4,7 +4,7 @@ require 'magic_enum'
 module MagicEnumHelper
   class TestModelBase
     extend MagicEnum::ClassMethods
-    Statuses = { :unknown => 0, :draft => 1, :published => 2 }
+    STATUSES = { :unknown => 0, :draft => 1, :published => 2 }
 
     def [](attr_name)
       @status
@@ -27,69 +27,85 @@ describe 'Model with magic enum' do
     @model = TestModelSimple.new
   end
 
+  it 'should define helper class methods' do
+    expect(TestModelSimple.status_value(:draft)).to eq(1)
+    expect(TestModelSimple.status_value('draft')).to eq(1)
+    expect(TestModelSimple.status_value(:invalid)).to be_nil
+
+    expect(TestModelSimple.status_by_value(1)).to eq(:draft)
+    expect(TestModelSimple.status_by_value(-1)).to be_nil
+  end
+
   it 'should define methods to get and set enum field' do
-    TestModelSimple.should be_method_defined(:status)
-    TestModelSimple.should be_method_defined(:status=)
+    expect(TestModelSimple.method_defined?(:status)).to be_true
+    expect(TestModelSimple.method_defined?(:status=)).to be_true
+    expect(TestModelSimple.method_defined?(:status_name)).to be_true
+    expect(TestModelSimple.method_defined?(:status_value)).to be_true
   end
 
   it 'should store enum value using [] operation on model' do
     @model.status = :draft
-    @model[:status].should == 1
-    @model.status.should == :draft
+    expect(@model[:status]).to eq(1)
+    expect(@model.status).to eq(:draft)
     @model.status = :unknown
-    @model[:status].should == 0
-    @model.status.should == :unknown
+    expect(@model[:status]).to eq(0)
+    expect(@model.status).to eq(:unknown)
   end
 
   it 'should store enum value if key is given as string' do
     @model.status = 'draft'
-    @model[:status].should == 1
-    @model.status.should == :draft
+    expect(@model[:status]).to eq(1)
+    expect(@model.status).to eq(:draft)
     @model.status = 'unknown'
-    @model[:status].should == 0
-    @model.status.should == :unknown
+    expect(@model[:status]).to eq(0)
+    expect(@model.status).to eq(:unknown)
   end
 
   it 'should store enum value if key is given as integer equivalent' do
     @model.status = 1
-    @model[:status].should == 1
-    @model.status.should == :draft
+    expect(@model[:status]).to eq(1)
+    expect(@model.status).to eq(:draft)
     @model.status = 0
-    @model[:status].should == 0
-    @model.status.should == :unknown
+    expect(@model[:status]).to eq(0)
+    expect(@model.status).to eq(:unknown)
   end
 
   it 'should not define simple accessors by default' do
-    @model.should_not respond_to(:unknown?)
-    @model.should_not respond_to(:draft?)
-    @model.should_not respond_to(:published?)
+    expect(@model).to_not respond_to(:unknown?)
+    expect(@model).to_not respond_to(:draft?)
+    expect(@model).to_not respond_to(:published?)
   end
 
   it 'should not raise error when invalid value received' do
-    lambda { @model.status = :invalid }.should_not raise_error
+    expect { @model.status = :invalid }.to_not raise_error
   end
 
   it 'should use default value 0 when invalid value received or current state invalid' do
     @model[:status] = -1
-    @model.status.should == :unknown
+    expect(@model.status).to eq(:unknown)
     @model.status = :published
-    @model.status.should == :published
+    expect(@model.status).to eq(:published)
     @model.status = :invalid
-    @model[:status].should == 0
-    @model.status.should == :unknown
+    expect(@model[:status]).to eq(0)
+    expect(@model.status).to eq(:unknown)
   end
 
   it 'should return string value when _name method called' do
-    @model.status_name.should == 'unknown'
+    expect(@model.status_name).to eq('unknown')
+    @model.status = :published
+    expect(@model.status_name).to eq('published')
+  end
+
+  it 'should return value when _value method called' do
+    expect(@model.status_value).to eq(0)
     @model.status = :published
-    @model.status_name.should == 'published'
+    expect(@model.status_value).to eq(2)
   end
 
   it 'should not define named scopes by default' do
     TestModelSimple.should_not_receive(:named_scope)
     TestModelSimple.should_not_receive(:scope)
   end
-
 end
 
 describe 'Model with magic enum and default value specified' do
@@ -105,22 +121,54 @@ describe 'Model with magic enum and default value specified' do
 
   it 'should use default value when current state is invalid' do
     @model[:status] = -1
-    @model.status.should == :published
+    expect(@model.status).to eq(:published)
+  end
+
+  it 'should use default value when invalid value received' do
+    @model.status = nil
+    expect(@model.status).to eq(:published)
+    @model.status = :invalid
+    expect(@model.status).to eq(:published)
+    expect(@model[:status]).to eq(2)
+  end
+
+  it 'should not interpret nil in the same way as 0' do
+    expect(@model[:status]).to be_nil
+    expect(@model.status).to eq(:published)
+    @model[:status] = 0
+    expect(@model.status).to eq(:unknown)
+  end
+end
+
+describe 'Model with magic enum and default value specified as a symbol' do
+  include MagicEnumHelper
+
+  class TestModelWithDefault < MagicEnumHelper::TestModelBase
+    define_enum :status, :default => :published
+  end
+
+  before do
+    @model = TestModelWithDefault.new
+  end
+
+  it 'should use default value when current state is invalid' do
+    @model[:status] = -1
+    expect(@model.status).to eq(:published)
   end
 
   it 'should use default value when invalid value received' do
     @model.status = nil
-    @model.status.should == :published
+    expect(@model.status).to eq(:published)
     @model.status = :invalid
-    @model.status.should == :published
-    @model[:status].should == 2
+    expect(@model.status).to eq(:published)
+    expect(@model[:status]).to eq(2)
   end
 
   it 'should not interpret nil in the same way as 0' do
-    @model[:status].should be_nil
-    @model.status.should == :published
+    expect(@model[:status]).to be_nil
+    expect(@model.status).to eq(:published)
     @model[:status] = 0
-    @model.status.should == :unknown
+    expect(@model.status).to eq(:unknown)
   end
 end
 
@@ -128,7 +176,7 @@ describe 'Model with magic enum and default value specified as nil' do
   include MagicEnumHelper
 
   class TestModelWithDefaultNil < MagicEnumHelper::TestModelBase
-    SimpleStatuses = { :unknown => 0, :draft => 1, :published => 2, :simple => nil }
+    SIMPLE_STATUSES = { :unknown => 0, :draft => 1, :published => 2, :simple => nil }
     define_enum :simple_status, :default => nil
   end
 
@@ -138,22 +186,22 @@ describe 'Model with magic enum and default value specified as nil' do
 
   it 'should use default value when current state is invalid' do
     @model[:simple_status] = -1
-    @model.simple_status.should == :simple
+    expect(@model.simple_status).to eq(:simple)
   end
 
   it 'should use default value when invalid value received' do
     @model.simple_status = nil
-    @model.simple_status.should == :simple
+    expect(@model.simple_status).to eq(:simple)
     @model.simple_status = :invalid
-    @model.simple_status.should == :simple
-    @model[:simple_status].should be_nil
+    expect(@model.simple_status).to eq(:simple)
+    expect(@model[:simple_status]).to be_nil
   end
 
   it 'should not interpret nil in the same way as 0' do
-    @model[:simple_status].should be_nil
-    @model.simple_status.should == :simple
+    expect(@model[:simple_status]).to be_nil
+    expect(@model.simple_status).to eq(:simple)
     @model[:simple_status] = 0
-    @model.simple_status.should == :unknown
+    expect(@model.simple_status).to eq(:unknown)
   end
 end
 
@@ -170,36 +218,36 @@ describe 'Model with magic enum and raise_on_invalid option specified' do
 
   context 'with symbol value' do
     it 'should not raise error when valid value received' do
-      lambda { @model.status = :draft }.should_not raise_error
+      expect { @model.status = :draft }.to_not raise_error
     end
 
     it 'should raise error when invalid value received' do
-      lambda { @model.status = :invalid }.should raise_error(ArgumentError)
+      expect { @model.status = :invalid }.to raise_error(ArgumentError)
     end
 
     it 'should show error description when invalid value received' do
       begin
         @model.status = :invalid
       rescue => e
-        e.message.should == 'Invalid value "invalid" for :status attribute of the TestModelWithRaiseOnInvalid model'
+        expect(e.message).to eq('Invalid value "invalid" for :status attribute of the TestModelWithRaiseOnInvalid model')
       end
     end
   end
 
   context 'with integer value' do
     it 'should not raise error when valid value received' do
-      lambda { @model.status = 1 }.should_not raise_error
+      expect { @model.status = 1 }.to_not raise_error
     end
 
     it 'should raise error when invalid value received' do
-      lambda { @model.status = 4 }.should raise_error(ArgumentError)
+      expect { @model.status = 4 }.to raise_error(ArgumentError)
     end
 
     it 'should show error description when invalid value received' do
       begin
         @model.status = 4
       rescue => e
-        e.message.should == 'Invalid value "4" for :status attribute of the TestModelWithRaiseOnInvalid model'
+        expect(e.message).to eq('Invalid value "4" for :status attribute of the TestModelWithRaiseOnInvalid model')
       end
     end
   end
@@ -218,9 +266,9 @@ describe 'Model with magic enum and simple_accessors option specified' do
   end
 
   it 'should define simple accessors by default' do
-    @model.should respond_to(:unknown?)
-    @model.should respond_to(:draft?)
-    @model.should respond_to(:published?)
+    expect(@model).to respond_to(:unknown?)
+    expect(@model).to respond_to(:draft?)
+    expect(@model).to respond_to(:published?)
   end
 end
 
@@ -228,15 +276,15 @@ describe 'Model with magic enum and named_scopes option specified' do
   include MagicEnumHelper
 
   class TestModelWithNamedScopes < ActiveRecord::Base
-    Statuses = { :unknown => 0, :draft => 1, :published => 2 }
+    STATUSES = { :unknown => 0, :draft => 1, :published => 2 }
     define_enum :status, :named_scopes => true
   end
 
   it 'should define named_scopes' do
-    TestModelWithNamedScopes.should respond_to(:unknowns)
-    TestModelWithNamedScopes.should respond_to(:drafts)
-    TestModelWithNamedScopes.should respond_to(:publisheds)
-    TestModelWithNamedScopes.should respond_to(:of_status)
+    expect(TestModelWithNamedScopes).to respond_to(:unknowns)
+    expect(TestModelWithNamedScopes).to respond_to(:drafts)
+    expect(TestModelWithNamedScopes).to respond_to(:publisheds)
+    expect(TestModelWithNamedScopes).to respond_to(:of_status)
   end
 end
 
@@ -257,21 +305,21 @@ describe 'Model with magic enum and enum option specified' do
 
   it 'should use custom enum' do
     @model.status = :user
-    @model.status.should == :user
-    @model[:status].should == 'u'
+    expect(@model.status).to eq(:user)
+    expect(@model[:status]).to eq('u')
     @model.status = :admin
-    @model.status.should == :admin
-    @model[:status].should == 'a'
+    expect(@model.status).to eq(:admin)
+    expect(@model[:status]).to eq('a')
   end
 
   it 'should use option with min value as default' do
     @model.status = :invalid
-    @model.status.should == :admin
+    expect(@model.status).to eq(:admin)
   end
 end
 
 describe 'ActiveRecord::Base class' do
   it 'should include MagicEnum methods' do
-    ActiveRecord::Base.should respond_to(:define_enum)
+    expect(ActiveRecord::Base).to respond_to(:define_enum)
   end
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: magic_enum
 version: !ruby/object:Gem::Version
-  version: 0.9.0
-  prerelease: 
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Dmytro Shteflyuk
@@ -10,86 +9,76 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-08 00:00:00.000000000 Z
+date: 2013-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: MagicEnum is a simple ActiveRecord plugin that makes it easier to maintain
@@ -99,13 +88,14 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
-- README.rdoc
+- README.md
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - lib/magic_enum.rb
 - lib/magic_enum/class_methods.rb
@@ -114,28 +104,27 @@ files:
 - spec/magic_enum_spec.rb
 homepage: https://github.com/kovyrin/magic-enum
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --charset=UTF-8
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.1.9
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ActiveRecord plugin that makes it easier to maintain ENUM-like attributes
   in your models
 test_files: []

data/README.rdoc

@@ -1,79 +0,0 @@
-= MagicEnum
-
-MagicEnum is a simple ActiveRecord plugin that makes it easier to maintain ENUM-like attributes in your models.
-
-Examples:
-
-   Statuses = {
-     :draft => 0,
-     :published => 1,
-     :approved => 2
-   }
-   define_enum :status
-
-== How to Use
- 
-Before using <tt>define_enum</tt>, you should define constant with ENUM options.
-Constant name would be pluralized enum attribute name. Additional constant named
-like YourEnumInverted would be created automatically and would contain
-inverted hash.
- 
-<b>Please note</b>: nil and 0 are not the same values!
- 
-You could specify additional options:
-
-* <tt>:default</tt> - value which will be used when current state of ENUM attribute is invalid or wrong value received. If it has not been specified, min value of the ENUM would be used.
-* <tt>:raise_on_invalid</tt> - if +true+ an exception would be raised on invalid enum value received. If it is +false+, default value would be used instead of wrong one.
-* <tt>:simple_accessors</tt> - if +true+, additional methods for each ENUM value would be defined in form value?. Methods returns +true+ when ENUM attribute has corresponding value.
-* <tt>:enum</tt> - string with name of the ENUM hash.
- 
-Look the following example:
- 
-   Statuses = {
-     :unknown => 0,
-     :draft => 1,
-     :published => 2,
-     :approved => 3
-   }
-   define_enum :status, :default => 1, :raise_on_invalid => true, :simple_accessors => true
-   
-This example is identical to:
- 
-   Statuses = {
-     :unknown => 0,
-     :draft => 1,
-     :published => 2,
-     :approved => 3
-   }
-   StatusesInverted = Statuses.invert
-   
-   def status
-     return StatusesInverted[self[:status].to_i] || StatusesInverted[1]
-   end
-   
-   def status=(value)
-     raise ArgumentError, "Invalid value \"#{value}\" for :status attribute of the #{self.class} model" if Statuses[value].nil?
-     self[:status] = Statuses[value]
-   end
-   
-   def unknown?
-     status == :unknown
-   end
-   
-   def draft?
-     status == :draft
-   end
-   
-   def published?
-     status == :published
-   end
-   
-   def approved?
-     status == :approved
-   end
-
-== Who are the authors?
-
-This plugin was originally developed for BestTechVideos project (http://www.bestechvideos.com) by Dmytro Shteflyuk (http://kpumuk.info)
-and later cleaned up in Scribd repository and released to the public by Oleksiy Kovyrin. All the code in this package is released under
-the MIT license. For more details, see the LICENSE file.