classy_enum 3.5.0 → 4.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d42689788d2614aa9bc9c81ef05920c064b88cb3
-  data.tar.gz: 01cf9ada7b577004ddbe61565df1423fd93e62a5
+  metadata.gz: 461b3c90498c65da6f580b4f0b2fd794eb28a832
+  data.tar.gz: 02b9a83c3337c4af82268c9e2ed48b18dc23f217
 SHA512:
-  metadata.gz: f5cbe7b796bd2967172d963aac361b76fb505f879a2a85fd4f991cce8626373d9f3255c9271c946b355749e75099a328bb7afabc5f20b8ec0f2230344e51bd78
-  data.tar.gz: 348a62ab03bfb9db36ed18cf306368ad9b941d86f51dbd6fb4148fdf868d6058a9d8853cf7844768a219480c7426f9f8ebd26e0f2256f0dd5e4975664354d877
+  metadata.gz: 3c438e006bef648f25c0217a752d1a8b9d8057afd720e0580dc09d10321bb970a81bdc9c369a07b5637a7b12586abfb58559d021c8f3d3ff98bc0fa897546b93
+  data.tar.gz: 4f8b082c843c9fbbbf27f36b39cc691c75984f13400bba0cf557a4a8c64b6a3a05cc69a46dd881241490ee519ebdb5dc60f15ebd070dde7825a62fdfa62a5c21

data/.travis.yml

@@ -2,13 +2,9 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.1
+  - 2.1.3
 gemfile:
-  - gemfiles/Gemfile.rails-3.0.x
-  - gemfiles/Gemfile.rails-3.1.x
   - gemfiles/Gemfile.rails-3.2.x
   - gemfiles/Gemfile.rails-4.0.x
-matrix:
-  exclude:
-    - rvm: 1.8.7
-      gemfile: gemfiles/Gemfile.rails-4.0.x
+  - gemfiles/Gemfile.rails-4.1.x
+  - gemfiles/Gemfile.rails-4.2.x

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # ClassyEnum Changelog
 
+## 4.0.0 (Unreleased)
+
+* [BREAKING] Removes support for Ruby 1.8.7
+* [BREAKING] Removes support for Rails 3.0.x and 3.1.x
+* [BREAKING] Active Record models must explicitly include ClassyEnum::ActiveRecord now
+* [BREAKING] Removed use of null objects. Blank values are now returned as is from Enum.build.
+* [BREAKING] Removed serialize_as_json option. #as_json should be overriden in ClassyEnum::Base subclasses instead.
+* [BREAKING] Removed allow_blank option from Enum.build. This was used internally for legacy reasons and is no longer needed.
+* [BREAKING] Fixes support for ActiveModel::Dirty. Now dirty attribute methods always return enum class instance (instead of string).
+* Prefer 'class_name' over 'enum' as optional class name argument
+
 ## 3.5.0
 
 * Fixes long standing issue with default values not being persisted to

data/README.md

@@ -11,9 +11,9 @@ This README is also available in a [user-friendly DocumentUp format](http://beer
 
 ## Rails & Ruby Versions Supported
 
-*Rails:* 3.0.x - 4.0.x
+*Rails:* 3.2.x - 4.1.x
 
-*Ruby:* 1.8.7, 1.9.2, 1.9.3 and 2.0.0
+*Ruby:* 1.9.2, 1.9.3, 2.0.0 and 2.1.0
 
 ## Installation
 
@@ -104,10 +104,12 @@ end
 NOTE: Alternatively, you may use an enum type if your database supports it. See
 [this issue](https://github.com/beerlington/classy_enum/issues/12) for more information.
 
-Then in my model I've added a line that calls `classy_enum_attr` with a single argument representing the enum I want to associate with my model. I am also delegating the `#send_email?` method to my Priority enum class.
+Then in my model I've included `ClassyEnum::ActiveRecord` and added a line that calls `classy_enum_attr` with a single argument representing the enum I want to associate with my model. I am also delegating the `#send_email?` method to my Priority enum class.
 
 ```ruby
 class Alarm < ActiveRecord::Base
+  include ClassyEnum::ActiveRecord
+
   classy_enum_attr :priority
 
   delegate :send_email?, to: :priority
@@ -134,11 +136,13 @@ The enum field works like any other model attribute. It can be mass-assigned usi
 
 #### What if your enum class name is not the same as your model's attribute name?
 
-Just provide an optional `enum` or `class_name` argument to declare the attribute name. In this case, the model's attribute is called *alarm_priority*.
+Just provide an optional `class_name` argument to declare the enum's class name. In this case, the model's attribute is called *alarm_priority*.
 
 ```ruby
 class Alarm < ActiveRecord::Base
-  classy_enum_attr :alarm_priority, enum: 'Priority'
+  include ClassyEnum::ActiveRecord
+
+  classy_enum_attr :alarm_priority, class_name: 'Priority'
 end
 
 @alarm = Alarm.create(alarm_priority: :medium)
@@ -177,7 +181,7 @@ I18n.locale = :es
 
 ## Using Enum as a Collection
 
-ClassyEnum::Base extends the [Enumerable module](http://ruby-doc.org/core-1.9.3/Enumerable.html)
+ClassyEnum::Base extends the [Enumerable module](http://ruby-doc.org/core-2.1.3/Enumerable.html)
 which provides several traversal and searching methods. This can
 be useful for situations where you are working with the collection,
 as opposed to the attributes on an Active Record object.
@@ -198,8 +202,7 @@ Priority.map { |p| p.to_s } # => ["low", "medium", "high"]
 Priority.find(&:send_email?) # => Priority::High.new
 
 # Find the priorities that are lower than Priority::High
-high_priority = Priority::High.new
-Priority.select {|p| p < high_priority } # => [Priority::Low.new, Priority::Medium.new]
+Priority.select {|p| p < :high } # => [Priority::Low.new, Priority::Medium.new]
 
 # Iterate over each priority:
 Priority.each do |priority|
@@ -217,6 +220,8 @@ so:
 
 ```ruby
 class Alarm < ActiveRecord::Base
+  include ClassyEnum::ActiveRecord
+
   classy_enum_attr :priority, default: 'medium'
 end
 
@@ -229,6 +234,8 @@ runtime.
 
 ```ruby
 class Alarm < ActiveRecord::Base
+  include ClassyEnum::ActiveRecord
+
   classy_enum_attr :priority, default: ->(enum){ enum.max }
 end
 
@@ -287,26 +294,6 @@ In the above examples, high priority alarms are only emailed if the owning alarm
 @alarm.send_email? # => false
 ```
 
-## Serializing as JSON
-
-By default, the enum will be serialized as a string representing the value:
-
-```ruby
-@alarm = Alarm.create(priority: :high, enabled: true)
-@alarm.to_json.should == "{\"alarm\":{\"priority\":\"high\"}}"
-```
-
-This behavior can be overridden by using the `serialize_as_json: true` option in your Active Record model:
-
-```ruby
-class Alarm < ActiveRecord::Base
-  classy_enum_attr :priority, serialize_as_json: true
-end
-
-@alarm = Alarm.create(priority: :high, enabled: true)
-@alarm.to_json.should == "{\"alarm\":{\"priority\":{}}}"
-```
-
 ## Model Validation
 
 An Active Record validator `validates_inclusion_of :field, in: ENUM` is automatically added to your model when you use `classy_enum_attr`.
@@ -324,6 +311,8 @@ To allow nil or blank values, you can pass in `:allow_nil` and `:allow_blank` as
 
 ```ruby
 class Alarm < ActiveRecord::Base
+  include ClassyEnum::ActiveRecord
+
   classy_enum_attr :priority, allow_nil: true
 end
 
@@ -334,8 +323,7 @@ end
 ## Form Usage
 
 ClassyEnum includes a `select_options` helper method to generate an array of enum options
-that can be used by Rails' form builders such as SimpleForm and
-Formtastic.
+that can be used by Rails' form builders such as SimpleForm and Formtastic.
 
 ```erb
 # SimpleForm
@@ -346,19 +334,6 @@ Formtastic.
 <% end %>
 ```
 
-```erb
-# Formtastic
-
-<%= semantic_form_for @alarm do |f| %>
-  <%= f.input :priority, as: :select, collection: Priority.select_options %>
-  <%= f.button :submit %>
-<% end %>
-```
-
-Built-in Formtastic support has been removed as of ClassyEnum 2.0. It is still
-available but needs to be enabled manually. To enable support visit
-[the wiki](https://github.com/beerlington/classy_enum/wiki/Formtastic-Support)
-
 ## Copyright
 
 Copyright (c) 2010-2014 [Peter Brown](https://github.com/beerlington). See LICENSE for details.

data/classy_enum.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = ClassyEnum::VERSION
 
-  gem.add_dependency('activerecord', '>= 3.0')
+  gem.add_dependency('activerecord', '>= 3.2')
 
   gem.add_development_dependency('rspec', '>= 2.11')
   gem.add_development_dependency('sqlite3', '>= 1.3')

data/gemfiles/Gemfile.rails-4.1.x

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem 'rails', '~> 4.1.0'
+gem 'rspec-rails', '~> 2.11'
+gem 'sqlite3'
+gem 'json', '~> 1.7'

data/gemfiles/Gemfile.rails-4.2.x

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem 'rails', '~> 4.2.0.beta'
+gem 'rspec-rails', '~> 2.11'
+gem 'sqlite3'
+gem 'json', '~> 1.7'

data/lib/classy_enum/active_record.rb

@@ -28,58 +28,82 @@ module ClassyEnum
   end
 
   module ActiveRecord
+    def self.included(klass)
+      klass.extend self
+    end
 
     # Class macro used to associate an enum with an attribute on an ActiveRecord model.
-    # This method is automatically added to all ActiveRecord models when the classy_enum gem
-    # is installed. Accepts an argument for the enum class to be associated with
+    # This method is added to an ActiveRecord model when ClassEnum::ActiveRecord
+    # is included. Accepts an argument for the enum class to be associated with
     # the model. ActiveRecord validation is automatically added to ensure
     # that a value is one of its pre-defined enum members.
     #
     # ==== Example
     #  # Associate an enum Priority with Alarm model's priority attribute
     #  class Alarm < ActiveRecord::Base
+    #    include ClassyEnum::ActiveRecord
+    #
     #    classy_enum_attr :priority
     #  end
-    #
+
     #  # Associate an enum Priority with Alarm model's alarm_priority attribute
-    #  classy_enum_attr :alarm_priority, :enum => 'Priority'
+    #  classy_enum_attr :alarm_priority, class_name: 'Priority'
     #
     #  # Allow enum value to be nil
-    #  classy_enum_attr :priority, :allow_nil => true
+    #  classy_enum_attr :priority, allow_nil: true
     #
     #  # Allow enum value to be blank
-    #  classy_enum_attr :priority, :allow_blank => true
+    #  classy_enum_attr :priority, allow_blank: true
     #
     #  # Specifying a default enum value
-    #  classy_enum_attr :priority, :default => 'low'
+    #  classy_enum_attr :priority, default: 'low'
     def classy_enum_attr(attribute, options={})
-      enum              = (options[:enum] || options[:class_name] || attribute).to_s.camelize.constantize
+      enum              = (options[:class_name] || options[:enum] || attribute).to_s.camelize.constantize
       allow_blank       = options[:allow_blank] || false
       allow_nil         = options[:allow_nil] || false
-      serialize_as_json = options[:serialize_as_json] || false
       default           = ClassyEnum._normalize_default(options[:default], enum)
 
       # Add ActiveRecord validation to ensure it won't be saved unless it's an option
       validates_inclusion_of attribute,
-        :in          => enum,
-        :allow_blank => allow_blank,
-        :allow_nil   => allow_nil
-
-      # Define getter method that returns a ClassyEnum instance
-      define_method attribute do
-        enum.build(read_attribute(attribute),
-                   :owner             => self,
-                   :serialize_as_json => serialize_as_json,
-                   :allow_blank       => (allow_blank || allow_nil)
-                  )
-      end
+        in:          enum,
+        allow_blank: allow_blank,
+        allow_nil:   allow_nil
+
+      # Use a module so that the reader methods can be overridden in classes and
+      # use super to get the enum value.
+      mod = Module.new do
+
+        # Define getter method that returns a ClassyEnum instance
+        define_method attribute do
+          enum.build(read_attribute(attribute), owner: self)
+        end
 
-      # Define setter method that accepts string, symbol, instance or class for member
-      define_method "#{attribute}=" do |value|
-        value = ClassyEnum._normalize_value(value, default, (allow_nil || allow_blank))
-        super(value)
+        # Define setter method that accepts string, symbol, instance or class for member
+        define_method "#{attribute}=" do |value|
+          value = ClassyEnum._normalize_value(value, default, (allow_nil || allow_blank))
+          super(value)
+        end
+
+        define_method :save_changed_attribute do |attr_name, arg|
+          if attribute.to_s == attr_name.to_s && !attribute_changed?(attr_name)
+            arg = enum.build(arg)
+            current_value = clone_attribute_value(:read_attribute, attr_name)
+
+            if arg != current_value
+              if respond_to?(:set_attribute_was, true)
+                set_attribute_was(attr_name, enum.build(arg, owner: self))
+              else
+                changed_attributes[attr_name] = enum.build(current_value, owner: self)
+              end
+            end
+          else
+            super(attr_name, arg)
+          end
+        end
       end
 
+      include mod
+
       # Initialize the object with the default value if it is present
       # because this will let you store the default value in the
       # database and make it searchable.
@@ -97,7 +121,3 @@ module ClassyEnum
 
   end
 end
-
-if defined?(ActiveRecord::Base)
-  ActiveRecord::Base.send :extend, ClassyEnum::ActiveRecord
-end

data/lib/classy_enum/base.rb

@@ -8,7 +8,7 @@ module ClassyEnum
     include Translation
     include Collection
 
-    attr_accessor :owner, :serialize_as_json, :allow_blank
+    attr_accessor :owner, :allow_blank
 
     def base_class
       self.class.base_class
@@ -24,8 +24,6 @@ module ClassyEnum
       end
 
       def inherited(klass)
-        return if klass.anonymous?
-
         if self == ClassyEnum::Base
           klass.base_class = klass
         else
@@ -35,32 +33,6 @@ module ClassyEnum
             raise SubclassNameError, "subclass must be namespaced with #{base_class.name}::"
           end
 
-          # Add visit_EnumMember methods to support validates_uniqueness_of with enum field
-          # This is due to a bug in Rails where it uses the method result as opposed to the
-          # database value for validation scopes. A fix will be released in Rails 4, but
-          # this will remain until Rails 3.x is no longer prevalent.
-          if defined?(Arel::Visitors::ToSql)
-            visitor_method = "visit_#{klass.name.split('::').join('_')}"
-
-            Arel::Visitors::ToSql.class_eval do
-              define_method visitor_method, lambda {|*values|
-                values[0] = values[0].to_s
-                begin
-                  quoted(*values)
-                rescue NoMethodError
-                  quote(*values)
-                end
-              }
-            end
-
-            Arel::Visitors::DepthFirst.class_eval do
-              define_method visitor_method, lambda {|*values|
-                values[0] = values[0].to_s
-                terminal(*values)
-              }
-            end
-          end
-
           # Convert from MyEnumClass::NumberTwo to :number_two
           enum = klass.name.split('::').last.underscore.to_sym
 
@@ -88,18 +60,12 @@ module ClassyEnum
       def build(value, options={})
         object = find(value)
 
-        if object.nil? || (options[:allow_blank] && object.nil?)
-          if value.blank?
-            object = build_null_object(value)
-          else
-            return value
-          end
+        if object.nil?
+          value
+        else
+          object.owner = options[:owner]
+          object
         end
-
-        object.owner = options[:owner]
-        object.serialize_as_json = options[:serialize_as_json]
-        object.allow_blank = options[:allow_blank]
-        object
       end
 
       # DSL setter method for overriding reference to enum owner (ActiveRecord model)
@@ -116,20 +82,8 @@ module ClassyEnum
       #    end
       #  end
       def owner(owner)
-        define_method owner, lambda { @owner }
-      end
-
-      private
-
-      # Subclass the base class and make it behave like the value that it is
-      def build_null_object(value)
-        Class.new(base_class) {
-          @option = value
-          @index = 0
-          delegate :blank?, :nil?, :to => :option
-        }.new
+        define_method owner, -> { @owner }
       end
     end
-
   end
 end

data/lib/classy_enum/collection.rb

@@ -21,6 +21,8 @@ module ClassyEnum
     def <=> other
       if other.is_a?(Symbol) || other.is_a?(String)
         other = self.class.find(other)
+      elsif other.is_a?(Class)
+        other = other.new
       end
 
       index <=> other.index

data/lib/classy_enum/conversion.rb

@@ -58,11 +58,7 @@ module ClassyEnum
 
     # Overrides as_json to remove owner reference recursion issues
     def as_json(options=nil)
-      return to_s unless serialize_as_json
-      json = super(options)
-      json.delete('owner')
-      json.delete('serialize_as_json')
-      json
+      to_s
     end
 
     private

data/lib/classy_enum/predicate.rb

@@ -4,7 +4,7 @@ module ClassyEnum
     # Define attribute methods like two?
     def self.define_predicate_method(klass, enum)
       klass.base_class.class_eval do
-        define_method "#{enum}?", lambda { attribute?(enum) }
+        define_method "#{enum}?", -> { attribute?(enum) }
       end
     end
 
@@ -22,10 +22,12 @@ module ClassyEnum
     #
     #  # Create an ActiveRecord class using the Breed enum
     #  class Dog < ActiveRecord::Base
+    #    include ClassyEnum::ActiveRecord
+    #
     #    classy_enum_attr :breed
     #  end
     #
-    #  @dog = Dog.new(:breed => :snoop)
+    #  @dog = Dog.new(breed: :snoop)
     #  @dog.breed.snoop? # => true
     #  @dog.breed.golden_retriever? # => false
     def attribute?(attribute)

data/lib/classy_enum/translation.rb

@@ -26,7 +26,7 @@ module ClassyEnum
     #
     #  Priority::Low.new.text # => 'Bajo'
     def text
-      I18n.translate to_s, :scope => i18n_scope, :default => to_s.titleize
+      I18n.translate to_s, scope: i18n_scope, default: to_s.titleize
     end
 
     private

data/lib/classy_enum/version.rb

@@ -1,3 +1,3 @@
 module ClassyEnum
-  VERSION = "3.5.0"
+  VERSION = "4.0.0.beta1"
 end

data/lib/generators/classy_enum/classy_enum_generator.rb

@@ -1,8 +1,8 @@
 class ClassyEnumGenerator < Rails::Generators::NamedBase
   desc "Generate a ClassyEnum definition in app/enums/"
 
-  argument :name, :type => :string, :required => true, :banner => 'EnumName'
-  argument :values, :type => :array, :default => [], :banner => 'value1 value2 value3 etc...'
+  argument :name, type: :string, required: true, banner: 'EnumName'
+  argument :values, type: :array, default: [], banner: 'value1 value2 value3 etc...'
 
   source_root File.expand_path("../templates", __FILE__)
 

data/lib/generators/rspec/classy_enum_generator.rb

@@ -3,8 +3,8 @@ module Rspec
     class ClassyEnumGenerator < Rails::Generators::NamedBase
       desc "Generate a ClassyEnum spec in spec/enums/"
 
-      argument :name, :type => :string, :required => true, :banner => 'EnumName'
-      argument :values, :type => :array, :default => [], :banner => 'value1 value2 value3 etc...'
+      argument :name, type: :string, required: true, banner: 'EnumName'
+      argument :values, type: :array, default: [], banner: 'value1 value2 value3 etc...'
 
       source_root File.expand_path("../templates", __FILE__)
 

data/lib/generators/test_unit/classy_enum_generator.rb

@@ -3,8 +3,8 @@ module TestUnit
     class ClassyEnumGenerator < Rails::Generators::NamedBase
       desc "Generate a ClassyEnum test in test/enums/"
 
-      argument :name, :type => :string, :required => true, :banner => 'EnumName'
-      argument :values, :type => :array, :default => [], :banner => 'value1 value2 value3 etc...'
+      argument :name, type: :string, required: true, banner: 'EnumName'
+      argument :values, type: :array, default: [], banner: 'value1 value2 value3 etc...'
 
       source_root File.expand_path("../templates", __FILE__)
 

data/spec/classy_enum/active_record_spec.rb

@@ -1,7 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :dogs, :force => true do |t|
+ActiveRecord::Schema.define(version: 1) do
+  self.verbose = false
+
+  create_table :dogs, force: true do |t|
     t.string :breed
     t.string :other_breed
     t.string :color
@@ -9,7 +11,7 @@ ActiveRecord::Schema.define(:version => 1) do
     t.integer :age
   end
 
-  create_table :cats, :force => true do |t|
+  create_table :cats, force: true do |t|
     t.string :breed
     t.string :other_breed
     t.string :another_breed
@@ -38,31 +40,33 @@ class CatBreed::Bengal < CatBreed; end
 class CatBreed::Birman < CatBreed; end
 class CatBreed::Persian < CatBreed; end
 
-class Dog < ActiveRecord::Base; end
+class Dog < ActiveRecord::Base
+  include ClassyEnum::ActiveRecord
+end
 
 class DefaultDog < Dog
   classy_enum_attr :breed
 end
 
 class AllowBlankBreedDog < Dog
-  classy_enum_attr :breed, :allow_blank => true
+  classy_enum_attr :breed, allow_blank: true
 end
 
 class AllowNilBreedDog < Dog
-  classy_enum_attr :breed, :allow_nil => true
+  classy_enum_attr :breed, allow_nil: true
 end
 
 class OtherDog < Dog
-  classy_enum_attr :other_breed, :class_name => 'Breed'
+  classy_enum_attr :other_breed, class_name: 'Breed'
 end
 
 describe DefaultDog do
-  specify { DefaultDog.new(:breed => nil).should_not be_valid }
-  specify { DefaultDog.new(:breed => '').should_not be_valid }
+  specify { DefaultDog.new(breed: nil).should_not be_valid }
+  specify { DefaultDog.new(breed: '').should_not be_valid }
 
   [:golden_retriever, 'golden_retriever', Breed::GoldenRetriever.new, Breed::GoldenRetriever].each do |option|
     context "with a valid breed option" do
-      subject { DefaultDog.new(:breed => option) }
+      subject { DefaultDog.new(breed: option) }
       it { should be_valid }
       its(:breed) { should be_a(Breed::GoldenRetriever) }
       its('breed.allow_blank') { should be_false }
@@ -75,8 +79,80 @@ describe DefaultDog do
     end
   end
 
+  if ::ActiveRecord::VERSION::MAJOR == 4 && ::ActiveRecord::VERSION::MINOR > 0
+    context "works with ActiveModel's attributes" do
+      subject { DefaultDog.create(breed: :golden_retriever) }
+      let(:old_breed) { Breed::GoldenRetriever.new }
+
+      it "sets changed_attributes to enum object" do
+        subject.breed = :snoop
+        subject.changed_attributes[:breed].should eq(old_breed)
+      end
+
+      it "sets changes to array" do
+        subject.breed = :snoop
+        subject.changes[:breed].should eq([old_breed, :snoop])
+      end
+
+      it "works with attribute_changed?" do
+        subject.breed = :snoop
+        subject.breed_was.should eq(old_breed)
+        subject.breed_changed?.should be_true
+
+        if subject.respond_to? :attribute_changed?
+          subject.attribute_changed?(:breed, to: Breed::Snoop.new).should be_true
+          subject.breed_changed?(
+            from: Breed::GoldenRetriever.new,
+            to: Breed::Snoop.new
+          ).should be_true
+        end
+      end
+
+      it "returns enum object for *_was" do
+        subject.breed = :snoop
+        subject.breed_was.golden_retriever?.should be_true
+      end
+
+      it "reverts changes" do
+        subject.breed = :snoop
+        subject.breed_changed?.should be_true
+        subject.breed = old_breed
+        subject.breed_changed?.should be_false
+      end
+
+      it "does not track the same value" do
+        subject.breed = :golden_retriever
+        subject.breed_changed?.should be_false
+      end
+
+      it "retains changes with multiple assignments" do
+        subject.breed = :snoop
+        subject.breed_changed?.should be_true
+        subject.breed = :husky
+        subject.breed_changed?.should be_true
+      end
+
+      it "allows tracks changes when nil is allowed" do
+        dog = AllowNilBreedDog.create(breed: :snoop)
+        dog.breed = nil
+        dog.save!
+        dog.breed = :snoop
+        dog.breed_changed?.should be_true
+        dog.breed = nil
+        dog.breed_changed?.should be_false
+      end
+
+      it "restores breed (Rails 4.2+)" do
+        if subject.respond_to?(:restore_breed)
+          subject.restore_breed!
+          subject.breed.should eq(:golden_retriever)
+        end
+      end
+    end
+  end
+
   context "with invalid breed options" do
-    subject { DefaultDog.new(:breed => :fake_breed) }
+    subject { DefaultDog.new(breed: :fake_breed) }
     it { should_not be_valid }
     it 'has an error on :breed' do
       subject.valid?
@@ -86,17 +162,16 @@ describe DefaultDog do
 end
 
 describe "A ClassyEnum that allows blanks" do
-  specify { AllowBlankBreedDog.new(:breed => nil).should be_valid }
-  specify { AllowBlankBreedDog.new(:breed => '').should be_valid }
+  specify { AllowBlankBreedDog.new(breed: nil).should be_valid }
+  specify { AllowBlankBreedDog.new(breed: '').should be_valid }
 
   context "with valid breed options" do
-    subject { AllowBlankBreedDog.new(:breed => :golden_retriever) }
+    subject { AllowBlankBreedDog.new(breed: :golden_retriever) }
     it { should be_valid }
-    its('breed.allow_blank') { should be_true }
   end
 
   context "with invalid breed options" do
-    subject { AllowBlankBreedDog.new(:breed => :fake_breed) }
+    subject { AllowBlankBreedDog.new(breed: :fake_breed) }
     it { should_not be_valid }
     it 'has an error on :breed' do
       subject.valid?
@@ -106,17 +181,16 @@ describe "A ClassyEnum that allows blanks" do
 end
 
 describe "A ClassyEnum that allows nils" do
-  specify { AllowNilBreedDog.new(:breed => nil).should be_valid }
-  specify { AllowNilBreedDog.new(:breed => '').should_not be_valid }
+  specify { AllowNilBreedDog.new(breed: nil).should be_valid }
+  specify { AllowNilBreedDog.new(breed: '').should_not be_valid }
 
   context "with valid breed options" do
-    subject { AllowNilBreedDog.new(:breed => :golden_retriever) }
+    subject { AllowNilBreedDog.new(breed: :golden_retriever) }
     it { should be_valid }
-    its('breed.allow_blank') { should be_true }
   end
 
   context "with invalid breed options" do
-    subject { AllowNilBreedDog.new(:breed => :fake_breed) }
+    subject { AllowNilBreedDog.new(breed: :fake_breed) }
     it { should_not be_valid }
     it 'has an error on :breed' do
       subject.valid?
@@ -126,24 +200,24 @@ describe "A ClassyEnum that allows nils" do
 end
 
 describe "A ClassyEnum that has a different field name than the enum" do
-  subject { OtherDog.new(:other_breed => :snoop) }
+  subject { OtherDog.new(other_breed: :snoop) }
   its(:other_breed) { should be_a(Breed::Snoop) }
 end
 
 class ActiveDog < Dog
   classy_enum_attr :color
-  validates_uniqueness_of :name, :scope => :color
-  scope :goldens, lambda { where(:breed => Breed.build('golden_retriever')) }
+  validates_uniqueness_of :name, scope: :color
+  scope :goldens, -> { where(breed: Breed.build('golden_retriever').to_s) }
 end
 
 describe ActiveDog do
   context 'uniqueness on name' do
-    subject { ActiveDog.new(:name => 'Kitteh', :breed => :golden_retriever, :color => :black) }
+    subject { ActiveDog.new(name: 'Kitteh', breed: :golden_retriever, color: :black) }
     it { should be_valid }
 
     context 'with existing kitteh' do
       before do
-        ActiveDog.create!(:name => 'Kitteh', :breed => :husky, :color => :black)
+        ActiveDog.create!(name: 'Kitteh', breed: :husky, color: :black)
       end
 
       it 'has an error on :name' do
@@ -154,8 +228,8 @@ describe ActiveDog do
   end
 
   context 'scopes' do
-    let!(:golden) { ActiveDog.create!(:name => 'Sebastian', :breed => :golden_retriever, :color => :white) }
-    let!(:husky) { ActiveDog.create!(:name => 'Sirius', :breed => :husky, :color => :black) }
+    let!(:golden) { ActiveDog.create!(name: 'Sebastian', breed: :golden_retriever, color: :white) }
+    let!(:husky) { ActiveDog.create!(name: 'Sirius', breed: :husky, color: :black) }
 
     after { ActiveDog.destroy_all }
 
@@ -176,7 +250,7 @@ describe ActiveDog do
 end
 
 class DefaultValueDog < Dog
-  classy_enum_attr :breed, :default => :snoop
+  classy_enum_attr :breed, default: :snoop
 end
 
 describe DefaultValueDog do
@@ -184,7 +258,7 @@ describe DefaultValueDog do
 end
 
 class DynamicDefaultValueDog < Dog
-  classy_enum_attr :breed, :default => lambda { |enum| enum.max }
+  classy_enum_attr :breed, default: ->(enum) { enum.max }
 end
 
 describe DynamicDefaultValueDog do
@@ -194,32 +268,35 @@ end
 describe Dog, 'with invalid default value' do
   it 'raises error with invalid default' do
     expect {
-      Class.new(Dog) { classy_enum_attr :breed, :default => :nope }
+      Class.new(Dog) { classy_enum_attr :breed, default: :nope }
     }.to raise_error(ClassyEnum::InvalidDefault)
   end
 end
 
 class Cat < ActiveRecord::Base
+  include ClassyEnum::ActiveRecord
 end
 
 class DefaultCat < Cat
-  classy_enum_attr :breed, :enum => 'CatBreed'
-  classy_enum_attr :other_breed, :enum => 'CatBreed', :default => 'persian'
+  classy_enum_attr :breed, class_name: 'CatBreed'
+  classy_enum_attr :other_breed, class_name: 'CatBreed', default: 'persian'
   attr_accessor :color
-  delegate :breed_color, :to => :breed
+  delegate :breed_color, to: :breed
 end
 
 class OtherCat < Cat
-  classy_enum_attr :breed, :enum => 'CatBreed', :serialize_as_json => true
-  classy_enum_attr :other_breed, :enum => 'CatBreed', :default => 'persian', :allow_nil => true
-  classy_enum_attr :another_breed, :enum => 'CatBreed', :default => 'persian', :allow_blank => true
+  classy_enum_attr :breed, class_name: 'CatBreed'
+  classy_enum_attr :other_breed, class_name: 'CatBreed', default: 'persian', allow_nil: true
+
+  # Use enum option to ensure the tests are covering it somewhere
+  classy_enum_attr :another_breed, enum: 'CatBreed', default: 'persian', allow_blank: true
   attr_accessor :color
-  delegate :breed_color, :to => :breed
+  delegate :breed_color, to: :breed
 end
 
 describe DefaultCat do
-  let(:abyssian) { DefaultCat.new(:breed => :abyssian, :color => 'black') }
-  let(:persian) { OtherCat.new(:breed => :persian, :color => 'white') }
+  let(:abyssian) { DefaultCat.new(breed: :abyssian, color: 'black') }
+  let(:persian) { OtherCat.new(breed: :persian, color: 'white') }
 
   it 'should delegate breed color to breed with an ownership reference' do
     abyssian.breed_color { should eql('black Abyssian') }
@@ -227,31 +304,31 @@ describe DefaultCat do
   end
 
   it 'persists the default, when set to nil' do
-    cat = DefaultCat.create(:breed => :abyssian)
-    expect(DefaultCat.where(:other_breed => 'persian')).to include(cat)
+    cat = DefaultCat.create(breed: :abyssian)
+    expect(DefaultCat.where(other_breed: 'persian')).to include(cat)
   end
 
   it 'uses the default if explictly set to nil and does not allow nil' do
-    abyssian.update_attributes!(:other_breed => nil)
-    DefaultCat.where(:other_breed => 'persian').should include(abyssian)
+    abyssian.update_attributes!(other_breed: nil)
+    DefaultCat.where(other_breed: 'persian').should include(abyssian)
     DefaultCat.last.other_breed.should == 'persian'
   end
 
   it 'uses the default if explictly set to blank and does not allow blank' do
-    abyssian.update_attributes!(:other_breed => '')
-    DefaultCat.where(:other_breed => 'persian').should include(abyssian)
+    abyssian.update_attributes!(other_breed: '')
+    DefaultCat.where(other_breed: 'persian').should include(abyssian)
     DefaultCat.last.other_breed.should == 'persian'
   end
 
   it 'allows nil even with a default' do
-    persian.update_attributes!(:other_breed => nil)
-    OtherCat.where(:other_breed => nil).count.should eql(1)
+    persian.update_attributes!(other_breed: nil)
+    OtherCat.where(other_breed: nil).count.should eql(1)
     OtherCat.last.other_breed.should be_nil
   end
 
   it 'allows blank even with a default' do
-    persian.update_attributes!(:another_breed => '')
-    OtherCat.where(:another_breed => '').count.should eql(1)
+    persian.update_attributes!(another_breed: '')
+    OtherCat.where(another_breed: '').count.should eql(1)
     OtherCat.last.another_breed.should be_blank
     OtherCat.last.another_breed.should_not be_nil
   end

data/spec/classy_enum/base_spec.rb

@@ -29,16 +29,12 @@ describe ClassyEnum::Base do
 
     context 'nil' do
       subject { ClassyEnumBase.build(nil) }
-      it { should be_a(ClassyEnumBase) }
-      it { should be_nil }
-      it { should be_blank }
+      it { should eq(nil) }
     end
 
     context 'empty string' do
       subject { ClassyEnumBase.build('') }
-      it { should be_a(ClassyEnumBase) }
-      it { should_not be_nil }
-      it { should be_blank }
+      it { should eq('') }
     end
   end
 
@@ -50,7 +46,7 @@ describe ClassyEnum::Base do
 
   context 'Subclass naming' do
     it 'should raise an error when invalid' do
-      lambda {
+      -> {
         class WrongSublcassName < ClassyEnumBase; end
       }.should raise_error(ClassyEnum::SubclassNameError)
     end
@@ -66,9 +62,3 @@ describe ClassyEnum::Base do
     end
   end
 end
-
-describe ClassyEnum::Base, 'Arel visitor' do
-  specify do
-    Arel::Visitors::ToSql.instance_methods.map(&:to_sym).should include(:'visit_ClassyEnumBase_One', :'visit_ClassyEnumBase_Two')
-  end
-end

data/spec/classy_enum/collection_spec.rb

@@ -23,6 +23,7 @@ describe ClassyEnum::Collection do
   context '.map' do
     it 'should behave like an enumerable' do
       enum.map(&:to_s).should == %w(one two three)
+      enum.select {|e| e < :three }.should include(:one, :two)
     end
   end
 
@@ -34,6 +35,7 @@ describe ClassyEnum::Collection do
 
   context '#<=> (equality)' do
     its(:first) { should == ClassyEnumCollection::One.new }
+    its(:first) { should == ClassyEnumCollection::One }
     its(:first) { should == :one }
     its(:first) { should == 'one' }
     its(:first) { should_not == :two }

data/spec/classy_enum/conversion_spec.rb

@@ -31,25 +31,7 @@ describe ClassyEnum::Conversion do
   end
 
   context '#as_json' do
-    context 'serialize_as_json is false' do
-      specify { ClassyEnumConversion::One.new.as_json.should == 'one' }
-      specify { ClassyEnumConversion::Two.new.as_json.should == 'two' }
-    end
-
-    context 'serialize_as_json is true' do
-      specify do
-        enum = ClassyEnumConversion::One.new
-        enum.serialize_as_json = true
-        enum.instance_variable_set('@key', 'value')
-        enum.as_json.should == {'key' => 'value' }
-      end
-
-      specify do
-        enum = ClassyEnumConversion::One.new
-        enum.serialize_as_json = true
-        enum.instance_variable_set('@key', 'value')
-        enum.as_json.should == {'key' => 'value' }
-      end
-    end
+    specify { ClassyEnumConversion::One.new.as_json.should == 'one' }
+    specify { ClassyEnumConversion::Two.new.as_json.should == 'two' }
   end
 end

data/spec/classy_enum/translation_spec.rb

@@ -13,8 +13,9 @@ describe ClassyEnum::Translation do
 
   before do
     I18n.reload!
-    I18n.backend.store_translations :en, :classy_enum => {:classy_enum_translation => {:one => 'One!', :two => 'Two!' } }
-    I18n.backend.store_translations :es, :classy_enum => {:classy_enum_translation => {:one => 'Uno', :two => 'Dos' } }
+    I18n.available_locales = ['en', 'es']
+    I18n.backend.store_translations :en, classy_enum: {classy_enum_translation: {one: 'One!', two: 'Two!' } }
+    I18n.backend.store_translations :es, classy_enum: {classy_enum_translation: {one: 'Uno', two: 'Dos' } }
   end
 
   context '#text' do

data/spec/classy_enum_spec.rb

@@ -45,7 +45,7 @@ describe ClassyEnum do
     end
 
     it 'allows a proc' do
-      value = lambda {|enum| enum.max }
+      value = ->(enum) { enum.max }
       default = ClassyEnum._normalize_default(value, enum)
       default.should == enum.max
     end

data/spec/spec_helper.rb

@@ -5,7 +5,9 @@ require 'rubygems'
 require 'active_record'
 require 'classy_enum'
 
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+I18n.enforce_available_locales = true
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
 
 RSpec.configure do |config|
   config.color_enabled = true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: classy_enum
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 4.0.0.beta1
 platform: ruby
 authors:
 - Peter Brown
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-15 00:00:00.000000000 Z
+date: 2014-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -81,10 +81,10 @@ files:
 - README.md
 - Rakefile
 - classy_enum.gemspec
-- gemfiles/Gemfile.rails-3.0.x
-- gemfiles/Gemfile.rails-3.1.x
 - gemfiles/Gemfile.rails-3.2.x
 - gemfiles/Gemfile.rails-4.0.x
+- gemfiles/Gemfile.rails-4.1.x
+- gemfiles/Gemfile.rails-4.2.x
 - init.rb
 - lib/classy_enum.rb
 - lib/classy_enum/active_record.rb
@@ -124,9 +124,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2

data/gemfiles/Gemfile.rails-3.0.x

@@ -1,6 +0,0 @@
-source :rubygems
-
-gem 'rails', '~> 3.0.0'
-gem 'rspec-rails', '~> 2.11.0'
-gem 'sqlite3-ruby', :require => 'sqlite3'
-gem 'json', '~> 1.6.5'

data/gemfiles/Gemfile.rails-3.1.x

@@ -1,6 +0,0 @@
-source :rubygems
-
-gem 'rails', '~> 3.1.0'
-gem 'rspec-rails', '~> 2.11.0'
-gem 'sqlite3'
-gem 'json', '~> 1.6.5'