classy_enum 2.3.0 → 3.0.0

data/spec/classy_enum/active_record_spec.rb

@@ -0,0 +1,156 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class Breed < ClassyEnum::Base; end
+class Breed::GoldenRetriever < Breed; end
+class Breed::Snoop < Breed; end
+class Breed::Husky < Breed; end
+
+class Color < ClassyEnum::Base; end
+class Color::White < Color; end;
+class Color::Black < Color; end;
+
+class CatBreed < ClassyEnum::Base
+  owner :cat
+
+  def breed_color
+    "#{cat.color} #{self}"
+  end
+end
+
+class CatBreed::Abyssian < CatBreed; end
+class CatBreed::Bengal < CatBreed; end
+class CatBreed::Birman < CatBreed; end
+class CatBreed::Persian < CatBreed; end
+
+class Dog < ActiveRecord::Base
+  classy_enum_attr :breed
+end
+
+class AllowBlankBreedDog < ActiveRecord::Base
+  classy_enum_attr :breed, :allow_blank => true
+end
+
+class AllowNilBreedDog < ActiveRecord::Base
+  classy_enum_attr :breed, :allow_nil => true
+end
+
+class OtherDog < ActiveRecord::Base
+  classy_enum_attr :other_breed, :enum => 'Breed'
+end
+
+describe Dog do
+  specify { Dog.new(:breed => nil).should_not be_valid }
+  specify { Dog.new(:breed => '').should_not be_valid }
+
+  context "with valid breed options" do
+    subject { Dog.new(:breed => :golden_retriever) }
+    it { should be_valid }
+    its(:breed) { should be_a(Breed::GoldenRetriever) }
+    its('breed.allow_blank') { should be_false }
+  end
+
+  context "with invalid breed options" do
+    subject { Dog.new(:breed => :fake_breed) }
+    it { should_not be_valid }
+    it { should have(1).error_on(:breed) }
+  end
+end
+
+describe "A ClassyEnum that allows blanks" do
+  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) }
+    it { should be_valid }
+    its('breed.allow_blank') { should be_true }
+  end
+
+  context "with invalid breed options" do
+    subject { AllowBlankBreedDog.new(:breed => :fake_breed) }
+    it { should_not be_valid }
+    it { should have(1).error_on(:breed) }
+  end
+end
+
+describe "A ClassyEnum that allows nils" do
+  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) }
+    it { should be_valid }
+    its('breed.allow_blank') { should be_true }
+  end
+
+  context "with invalid breed options" do
+    subject { AllowNilBreedDog.new(:breed => :fake_breed) }
+    it { should_not be_valid }
+    it { should have(1).error_on(:breed) }
+  end
+end
+
+describe "A ClassyEnum that has a different field name than the enum" do
+  subject { OtherDog.new(:other_breed => :snoop) }
+  its(:other_breed) { should be_a(Breed::Snoop) }
+end
+
+class ActiveDog < ActiveRecord::Base
+  classy_enum_attr :color
+  validates_uniqueness_of :name, :scope => :color
+  scope :goldens, where(:breed => 'golden_retriever')
+end
+
+describe ActiveDog do
+  context 'uniqueness on name' do
+    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)
+      end
+
+      it { should have(1).error_on(:name) }
+    end
+  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) }
+
+    after { ActiveDog.destroy_all }
+
+    it 'should know all dogs' do
+      ActiveDog.all.should include(golden, husky)
+    end
+
+    it 'should have a working scope' do
+      ActiveDog.goldens.should include(golden)
+      ActiveDog.goldens.should_not include(husky)
+    end
+  end
+
+end
+
+class Cat < ActiveRecord::Base
+  classy_enum_attr :breed, :enum => 'CatBreed'
+  attr_accessor :color
+  delegate :breed_color, :to => :breed
+end
+
+class OtherCat < ActiveRecord::Base
+  classy_enum_attr :breed, :enum => 'CatBreed', :serialize_as_json => true
+  attr_accessor :color
+  delegate :breed_color, :to => :breed
+end
+
+describe Cat do
+  let(:abyssian) { Cat.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') }
+    persian.breed_color { should eql('white Persian') }
+  end
+end

data/spec/classy_enum/base_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ClassyEnumBase < ClassyEnum::Base
+end
+
+class ClassyEnumBase::One < ClassyEnumBase
+end
+
+class ClassyEnumBase::Two < ClassyEnumBase
+end
+
+describe ClassyEnum::Base do
+  context '.build' do
+    context 'invalid option' do
+      it 'should return the option' do
+        ClassyEnumBase.build(:invalid_option).should == :invalid_option
+      end
+    end
+
+    context 'string option' do
+      subject { ClassyEnumBase.build("one") }
+      it { should be_a(ClassyEnumBase::One) }
+    end
+
+    context 'symbol option' do
+      subject { ClassyEnumBase.build(:two) }
+      it { should be_a(ClassyEnumBase::Two) }
+    end
+  end
+
+  context '#new' do
+    subject { ClassyEnumBase::One }
+    its(:new) { should be_a(ClassyEnumBase::One) }
+    its(:new) { should == ClassyEnumBase::One.new  }
+  end
+
+  context 'Subclass naming' do
+    it 'should raise an error when invalid' do
+      lambda {
+        class WrongSublcassName < ClassyEnumBase; end
+      }.should raise_error(ClassyEnum::SubclassNameError)
+    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

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ClassyEnumCollection < ClassyEnum::Base
+end
+
+class ClassyEnumCollection::One < ClassyEnumCollection
+end
+
+class ClassyEnumCollection::Two < ClassyEnumCollection
+end
+
+class ClassyEnumCollection::Three < ClassyEnumCollection
+end
+
+describe ClassyEnum::Collection do
+  subject { ClassyEnumCollection }
+
+  its(:enum_options) { should == [ClassyEnumCollection::One, ClassyEnumCollection::Two, ClassyEnumCollection::Three] }
+  its(:all) { should == [ClassyEnumCollection::One.new, ClassyEnumCollection::Two.new, ClassyEnumCollection::Three.new] }
+  its(:select_options) { should == [['One', 'one'],['Two', 'two'], ['Three', 'three']] }
+end
+
+describe ClassyEnum::Collection, Comparable do
+  let(:one) { ClassyEnumCollection::One.new }
+  let(:two) { ClassyEnumCollection::Two.new }
+  let(:three) { ClassyEnumCollection::Three.new }
+
+  subject { [one, three, two] }
+  its(:sort) { should eql([one, two, three]) }
+  its(:max) { should eql(three) }
+  its(:min) { should eql(one) }
+end

data/spec/classy_enum/conversion_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ClassyEnumConversion < ClassyEnum::Base
+end
+
+class ClassyEnumConversion::One < ClassyEnumConversion
+end
+
+class ClassyEnumConversion::Two < ClassyEnumConversion
+end
+
+describe ClassyEnum::Conversion do
+  context '#to_i' do
+    specify { ClassyEnumConversion::One.new.to_i.should == 1 }
+    specify { ClassyEnumConversion::Two.new.to_i.should == 2 }
+  end
+
+  context '#index' do
+    specify { ClassyEnumConversion::One.new.index.should == 1 }
+    specify { ClassyEnumConversion::Two.new.index.should == 2 }
+  end
+
+  context '#to_s' do
+    specify { ClassyEnumConversion::One.new.to_s.should == 'one' }
+    specify { ClassyEnumConversion::Two.new.to_s.should == 'two' }
+  end
+
+  context '#to_sym' do
+    specify { ClassyEnumConversion::One.new.to_sym.should == :one }
+    specify { ClassyEnumConversion::Two.new.to_sym.should == :two }
+  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
+  end
+end

data/spec/classy_enum/predicate_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ClassyEnumPredicate < ClassyEnum::Base
+end
+
+class ClassyEnumPredicate::One < ClassyEnumPredicate
+end
+
+class ClassyEnumPredicate::Two < ClassyEnumPredicate
+end
+
+describe ClassyEnum::Predicate do
+  context '#attribute?' do
+    specify { ClassyEnumPredicate::One.new.should be_one }
+    specify { ClassyEnumPredicate::One.new.should_not be_two }
+    specify { ClassyEnumPredicate::Two.new.should_not be_one }
+    specify { ClassyEnumPredicate::Two.new.should be_two }
+  end
+end

data/spec/classy_enum_inheritance_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class ProjectTier < ClassyEnum::Base
+  class_attribute :inherited_properties
+end
+
+class ProjectTier::One < ProjectTier
+  self.inherited_properties = [1,2,3]
+end
+
+class ProjectTier::Two < ProjectTier::One
+  self.inherited_properties += [4,5,6]
+end
+
+describe 'Classy Enum inheritance' do
+  it 'should inherit from the previous class' do
+    ProjectTier::One.inherited_properties.should == [1,2,3]
+    ProjectTier::Two.inherited_properties.should == [1,2,3,4,5,6]
+  end
+
+  it 'should instantiate the subclass' do
+    ProjectTier::Two.build(:two).should == ProjectTier::Two.new
+  end
+
+  it 'should have the right index' do
+    ProjectTier::Two.new.index.should == 2
+  end
+end

data/spec/spec_helper.rb

@@ -46,32 +46,3 @@ ActiveRecord::Schema.define(:version => 1) do
     t.string :breed
   end
 end
-
-class Breed < ClassyEnum::Base
-  enum_classes :golden_retriever, :snoop, :husky
-end
-
-class BreedGoldenRetriever < Breed
-end
-
-class BreedSnoop < Breed
-end
-
-class BreedHusky < Breed
-end
-
-class Dog < ActiveRecord::Base
-  classy_enum_attr :breed
-end
-
-class AllowBlankBreedDog < ActiveRecord::Base
-  classy_enum_attr :breed, :allow_blank => true
-end
-
-class AllowNilBreedDog < ActiveRecord::Base
-  classy_enum_attr :breed, :allow_nil => true
-end
-
-class OtherDog < ActiveRecord::Base
-  classy_enum_attr :other_breed, :enum => :breed
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: classy_enum
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 3.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: 2.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: 2.11.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -95,17 +95,20 @@ files:
 - gemfiles/Gemfile.rails-3.2.x
 - init.rb
 - lib/classy_enum.rb
-- lib/classy_enum/attributes.rb
+- lib/classy_enum/active_record.rb
 - lib/classy_enum/base.rb
-- lib/classy_enum/class_methods.rb
-- lib/classy_enum/instance_methods.rb
+- lib/classy_enum/collection.rb
+- lib/classy_enum/conversion.rb
+- lib/classy_enum/predicate.rb
 - lib/classy_enum/version.rb
 - lib/generators/classy_enum/classy_enum_generator.rb
 - lib/generators/classy_enum/templates/enum.rb
-- spec/active_record_spec.rb
-- spec/classy_enum_attributes_spec.rb
-- spec/classy_enum_owner_reference_spec.rb
-- spec/classy_enum_spec.rb
+- spec/classy_enum/active_record_spec.rb
+- spec/classy_enum/base_spec.rb
+- spec/classy_enum/collection_spec.rb
+- spec/classy_enum/conversion_spec.rb
+- spec/classy_enum/predicate_spec.rb
+- spec/classy_enum_inheritance_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/beerlington/classy_enum
 licenses: []
@@ -121,7 +124,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2001790811310918278
+      hash: 3644506881692123531
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -130,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2001790811310918278
+      hash: 3644506881692123531
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -138,8 +141,10 @@ signing_key:
 specification_version: 3
 summary: A class based enumerator utility for Ruby on Rails
 test_files:
-- spec/active_record_spec.rb
-- spec/classy_enum_attributes_spec.rb
-- spec/classy_enum_owner_reference_spec.rb
-- spec/classy_enum_spec.rb
+- spec/classy_enum/active_record_spec.rb
+- spec/classy_enum/base_spec.rb
+- spec/classy_enum/collection_spec.rb
+- spec/classy_enum/conversion_spec.rb
+- spec/classy_enum/predicate_spec.rb
+- spec/classy_enum_inheritance_spec.rb
 - spec/spec_helper.rb

data/lib/classy_enum/attributes.rb

@@ -1,72 +0,0 @@
-module ClassyEnum
-  module Attributes
-
-    # 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
-    # the model. If the enum class name is different than the field name, then an optional
-    # field name can be passed. 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
-    #    classy_enum_attr :priority
-    #  end
-    #
-    #  # Associate an enum Priority with Alarm model's alarm_priority attribute
-    #  class Alarm < ActiveRecord::Base
-    #    classy_enum_attr :alarm_priority, :enum => :priority
-    #  end
-    def classy_enum_attr(*args)
-      options = args.extract_options!
-
-      attribute = args[0]
-
-      enum = options[:enum] || attribute
-      allow_blank = options[:allow_blank] || false
-      allow_nil = options[:allow_nil] || false
-      serialize_as_json = options[:serialize_as_json] || false
-
-      reader_method = attribute.to_s
-
-      if options.has_key? :suffix
-        ActiveSupport::Deprecation.warn(':suffix option for classy_enum_attr is deprecated, and will be removed in ClassyEnum 3.0.', caller)
-        reader_method += "_#{options[:suffix]}"
-      end
-
-      klass = enum.to_s.camelize.constantize
-
-      valid_attributes = reader_method == attribute.to_s ? klass.all : klass.all.map(&:to_s)
-
-      self.instance_eval do
-
-        # Add ActiveRecord validation to ensure it won't be saved unless it's an option
-        validates_inclusion_of attribute,
-          :in => valid_attributes,
-          :message => "must be one of #{klass.valid_options}",
-          :allow_blank => allow_blank,
-          :allow_nil => allow_nil
-
-        # Define getter method that returns a ClassyEnum instance
-        define_method reader_method do
-          klass.build(read_attribute(attribute), :owner => self, :serialize_as_json => serialize_as_json)
-        end
-
-        # Define setter method that accepts either string or symbol for member
-        define_method "#{attribute}=" do |value|
-          value = value.to_s unless value.nil?
-          super(value)
-        end
-
-        # Store the enum options so it can be later retrieved by Formtastic
-        define_method "#{attribute}_options" do
-          {:enum => enum, :allow_blank => allow_blank}
-        end
-
-      end
-
-    end
-
-  end
-end

data/lib/classy_enum/class_methods.rb

@@ -1,141 +0,0 @@
-module ClassyEnum
-  module ClassMethods
-
-    # Macro for defining enum members within a ClassyEnum class.
-    # Accepts an array of symbols or strings which are converted to
-    # ClassyEnum members as descents of their parent class.
-    #
-    # ==== Example
-    #  # Define an enum called Priority with three child classes
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  The child classes will be defined with the following constants:
-    #  PriorityLow, PriorityMedium, and PriorityHigh
-    #
-    #  These child classes can be instantiated with either:
-    #  Priority.build(:low) or PriorityLow.new
-    #
-    def enum_classes(*enums)
-      ActiveSupport::Deprecation.warn('enum_classes is deprecated, and will be removed in ClassyEnum 3.0. It is no longer needed.', caller)
-
-      self.class_eval do
-        class_attribute :enum_options, :base_class
-
-        self.enum_options = enums.map(&:to_sym)
-        self.base_class = self
-
-        # # Use ActiveModel::AttributeMethods to define attribute? methods
-        attribute_method_suffix '?'
-        define_attribute_methods enums
-      end
-    end
-
-    def inherited(klass)
-      return if self == ClassyEnum::Base
-
-      # Add visit_EnumMember methods to support validates_uniqueness_of with enum field
-      Arel::Visitors::ToSql.class_eval do
-        define_method "visit_#{klass.name}", lambda {|value| quote(value.to_s) }
-      end
-
-      if klass.name.start_with? "#{base_class.name}::"
-        enum = klass.name.split('::').last.underscore.to_sym
-      else
-        ActiveSupport::Deprecation.warn("The enum class name #{klass} is deprecated. ClassyEnum 3.0 will require subclasses to use the parent class as a namespace. Change it to #{base_class}::#{klass.name.gsub(base_class.name, '')}", caller)
-        enum = klass.name.gsub(klass.base_class.name, '').underscore.to_sym
-      end
-
-      index = self.enum_options.index(enum) + 1
-
-      klass.class_eval do
-        @index = index
-        @option = enum
-
-        attr_accessor :owner, :serialize_as_json
-      end
-    end
-
-    # Build a new ClassyEnum child instance
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  Priority.build(:low) # => PriorityLow.new
-    def build(value, options={})
-      return value if value.blank?
-      return TypeError.new("Valid #{self} options are #{self.valid_options}") unless self.enum_options.include? value.to_sym
-
-      # Temp hack until 3.0 to allow both namespaced and non-namespaced classes
-      begin
-        klass = "#{self}::#{value.to_s.camelize}".constantize
-      rescue NameError
-        klass = "#{self}#{value.to_s.camelize}".constantize
-      end
-
-      object = klass.new
-      object.owner = options[:owner]
-      object.serialize_as_json = options[:serialize_as_json]
-      object
-    end
-
-    def find(value, options={})
-      ActiveSupport::Deprecation.warn("find is deprecated, and will be removed in ClassyEnum 3.0. Use build(:member) instead.", caller)
-      build(value, options)
-    end
-
-    # Returns an array of all instantiated enums
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  Priority.all # => [PriorityLow.new, PriorityMedium.new, PriorityHigh.new]
-    def all
-      self.enum_options.map {|e| build(e) }
-    end
-
-    # Returns a 2D array for Rails select helper options.
-    # Also used internally for Formtastic support
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :really_high
-    #  end
-    #
-    #  Priority.select_options # => [["Low", "low"], ["Really High", "really_high"]]
-    def select_options
-      all.map {|e| [e.name, e.to_s] }
-    end
-
-    # Returns a comma separated list of valid enum options.
-    # Also used internally for ActiveRecord model validation error messages
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  Priority.valid_options # => "low, medium, high"
-    def valid_options
-      ActiveSupport::Deprecation.warn("valid_options is deprecated, and will be removed in ClassyEnum 3.0. Use all.join(', ') instead.", caller)
-      self.enum_options.map(&:to_s).join(', ')
-    end
-
-    private
-
-    # DSL setter method for reference to enum owner
-    def owner(owner)
-      define_method owner, lambda { @owner }
-    end
-
-  end
-end