active_enum 0.9.12 → 1.0.0.pre

data/spec/active_enum/base_spec.rb

@@ -4,7 +4,7 @@ describe ActiveEnum::Base do
 
   describe ".store" do
     it 'should load the storage class instance using the storage setting' do
-      ActiveEnum::Base.send(:store).should be_instance_of(ActiveEnum::Storage::MemoryStore)
+      expect(ActiveEnum::Base.send(:store)).to be_instance_of(ActiveEnum::Storage::MemoryStore)
     end
   end
 
@@ -12,7 +12,7 @@ describe ActiveEnum::Base do
     it 'should return all enum classes defined use class definition' do
       ActiveEnum.enum_classes = []
       class NewEnum < ActiveEnum::Base; end
-      ActiveEnum.enum_classes.should == [NewEnum]
+      expect(ActiveEnum.enum_classes).to eq([NewEnum])
     end
 
     it 'should return all enum classes defined using define block' do
@@ -20,13 +20,13 @@ describe ActiveEnum::Base do
       ActiveEnum.define do
         enum(:bulk_new_enum) { }
       end
-      ActiveEnum.enum_classes.should == [BulkNewEnum]
+      expect(ActiveEnum.enum_classes).to eq([BulkNewEnum])
     end
   end
 
   describe ".all" do
     it 'should return an empty array when no values defined' do
-      define_enum.all.should == []
+      expect(define_enum.all).to eq([])
     end
 
     it 'should return an array of arrays with all values defined as [id, name]' do
@@ -34,7 +34,7 @@ describe ActiveEnum::Base do
         value :name => 'Name 1'
         value :name => 'Name 2'
       end
-      enum.all.should == [[1,'Name 1'], [2, 'Name 2']]
+      expect(enum.all).to eq([[1,'Name 1'], [2, 'Name 2']])
     end
   end
 
@@ -43,28 +43,28 @@ describe ActiveEnum::Base do
       enum = define_enum do
         value :id => 1, :name => 'Name'
       end
-      enum.all.should == [[1,'Name']]
+      expect(enum.all).to eq([[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']]
+      expect(enum.all).to eq([[1,'Name']])
     end
 
     it 'should allow me to define a value as hash with id as key and name as value' do
       enum = define_enum do
         value 1 => 'Name'
       end
-      enum.all.should == [[1,'Name']]
+      expect(enum.all).to eq([[1,'Name']])
     end
 
     it 'should allow to define meta data value with extra key value pairs' do
       enum = define_enum do
         value :id => 1, :name => 'Name', :description => 'extra'
       end
-      enum.all.should == [[1,'Name',{:description => 'extra'}]]
+      expect(enum.all).to eq([[1,'Name',{:description => 'extra'}]])
     end
 
     it 'should increment value ids when defined without ids' do
@@ -72,7 +72,7 @@ describe ActiveEnum::Base do
         value :name => 'Name 1'
         value :name => 'Name 2'
       end
-      enum.all.should == [[1,'Name 1'], [2, 'Name 2']]
+      expect(enum.all).to eq([[1,'Name 1'], [2, 'Name 2']])
     end
 
     it 'should raise error if the id is a duplicate' do
@@ -99,14 +99,14 @@ describe ActiveEnum::Base do
       enum = define_enum do
         value :id => 1, :name => 'Name', :description => 'extra'
       end
-      enum.meta(1).should == {:description => 'extra'}
+      expect(enum.meta(1)).to eq({:description => 'extra'})
     end
 
     it 'should return empty hash for index with no meta defined' do
       enum = define_enum do
         value :id => 1, :name => 'Name'
       end
-      enum.meta(1).should == {}
+      expect(enum.meta(1)).to eq({})
     end
 
   end
@@ -117,7 +117,7 @@ describe ActiveEnum::Base do
         value :id => 2, :name => 'Name 2'
         value :id => 1, :name => 'Name 1'
       end
-      enum.all.should == [[1,'Name 1'], [2, 'Name 2']]
+      expect(enum.all).to eq([[1,'Name 1'], [2, 'Name 2']])
     end
 
     it 'should return sorted values by id using order setting' do
@@ -126,7 +126,7 @@ describe ActiveEnum::Base do
         value :id => 1, :name => 'Name 1'
         value :id => 2, :name => 'Name 2'
       end
-      enum.all.should == [[2, 'Name 2'], [1,'Name 1']]
+      expect(enum.all).to eq([[2, 'Name 2'], [1,'Name 1']])
     end
 
     it 'should return sorted values by id using order setting' do
@@ -136,7 +136,7 @@ describe ActiveEnum::Base do
         value :id => 1, :name => 'Name 1'
         value :id => 2, :name => 'Name 2'
       end
-      enum.all.should == [[3,'Name 3'], [1,'Name 1'], [2, 'Name 2']]
+      expect(enum.all).to eq([[3,'Name 3'], [1,'Name 1'], [2, 'Name 2']])
     end
   end
 
@@ -146,7 +146,7 @@ describe ActiveEnum::Base do
         value :id => 1, :name => 'Name 1'
         value :id => 2, :name => 'Name 2'
       end
-      enum.ids.should == [1,2]
+      expect(enum.ids).to eq([1,2])
     end
   end
 
@@ -156,7 +156,7 @@ describe ActiveEnum::Base do
         value :id => 1, :name => 'Name 1'
         value :id => 2, :name => 'Name 2'
       end
-      enum.names.should == ['Name 1', 'Name 2']
+      expect(enum.names).to eq(['Name 1', 'Name 2'])
     end
   end
 
@@ -169,16 +169,38 @@ describe ActiveEnum::Base do
     }
 
     it 'should return name when given an id' do
-      enum[1].should == 'Name 1'
+      expect(enum[1]).to eq('Name 1')
     end
 
     it 'should return id when given a name' do
-      enum['Name 1'].should == 1
+      expect(enum['Name 1']).to eq(1)
     end
 
     it 'should return id when given a symbol of the name' do
-      enum[:Name_1].should == 1
-      enum[:name_1].should == 1
+      expect(enum[:Name_1]).to eq(1)
+      expect(enum[:name_1]).to eq(1)
+    end
+
+    context "for missing value" do
+      it "should return nil for missing id" do
+        expect(enum['Not a value']).to eq nil
+      end
+
+      it "should return nil for missing name" do
+        expect(enum[0]).to eq nil
+      end
+
+      context "with raise_on_not_found" do
+        with_config :raise_on_not_found, true
+
+        it "should raise ActiveEnum::NotFound for missing id" do
+          expect { enum['Not a value'] }.to raise_error(ActiveEnum::NotFound)
+        end
+
+        it "should raise ActiveEnum::NotFound for missing name" do
+          expect { enum[0] }.to raise_error(ActiveEnum::NotFound)
+        end
+      end
     end
   end
 
@@ -191,19 +213,19 @@ describe ActiveEnum::Base do
     }
 
     it "should return true if value is a fixnum and matches an id" do
-      enum.include?(1).should be_true
+      expect(enum.include?(1)).to be_truthy
     end
 
     it "should return false if value is a fixnum and does not match an id" do
-      enum.include?(3).should be_false
+      expect(enum.include?(3)).to be_falsey
     end
 
     it "should return true if value is a string and matches a name" do
-      enum.include?('Name 1').should be_true
+      expect(enum.include?('Name 1')).to be_truthy
     end
 
     it "should return false if value is a string and does not match a name" do
-      enum.include?('No match').should be_false
+      expect(enum.include?('No match')).to be_falsey
     end
   end
 
@@ -213,7 +235,7 @@ describe ActiveEnum::Base do
         value :id => 1, :name => 'Name 1'
         value :id => 2, :name => 'Name 2'
       end
-      enum.to_select.should == [['Name 1',1], ['Name 2',2]]
+      expect(enum.to_select).to eq([['Name 1',1], ['Name 2',2]])
     end
 
     it 'should return array sorted using order setting' do
@@ -222,7 +244,7 @@ describe ActiveEnum::Base do
         value :id => 1, :name => 'Name 1'
         value :id => 2, :name => 'Name 2'
       end
-      enum.to_select.should == [['Name 2',2], ['Name 1',1]]
+      expect(enum.to_select).to eq([['Name 2',2], ['Name 1',1]])
     end
   end
 

data/spec/active_enum/extensions_spec.rb

@@ -13,45 +13,45 @@ describe ActiveEnum::Extensions do
   end
 
   it 'should add class :enumerate method to ActiveRecord' do
-    ActiveRecord::Base.should respond_to(:enumerate)
+    expect(ActiveRecord::Base).to respond_to(:enumerate)
   end
 
   it 'should add class :active_enum_for method to ActiveRecord' do
-    ActiveRecord::Base.should respond_to(:active_enum_for)
+    expect(ActiveRecord::Base).to respond_to(:active_enum_for)
   end
 
   it 'should allow multiple attributes to be enumerated with same enum' do
     Person.enumerate :attending, :staying, :with => Accepted
 
-    Person.active_enum_for(:attending).should == Accepted
-    Person.active_enum_for(:staying).should == Accepted
+    expect(Person.active_enum_for(:attending)).to eq(Accepted)
+    expect(Person.active_enum_for(:staying)).to eq(Accepted)
   end
 
   it 'should allow multiple attributes to be enumerated with different enums' do
     Person.enumerate :sex, :with => Sex
     Person.enumerate :attending, :with => Accepted
 
-    Person.active_enum_for(:sex).should == Sex 
-    Person.active_enum_for(:attending).should == Accepted
+    expect(Person.active_enum_for(:sex)).to eq(Sex) 
+    expect(Person.active_enum_for(:attending)).to eq(Accepted)
   end
 
   it 'should allow implicit enumeration class from attribute name' do
     Person.enumerate :sex
 
-    Person.active_enum_for(:sex).should == Sex
+    expect(Person.active_enum_for(:sex)).to eq(Sex)
   end
 
   it 'should create enum namespaced enum class from block' do
     Person.enumerate :sex do
       value :id => 1, :name => 'Male'
     end
-    Person.active_enum_for(:sex).should == ::Person::Sex
+    expect(Person.active_enum_for(:sex)).to eq(::Person::Sex)
   end
 
   it 'should raise error if implicit enumeration class cannot be found' do
     expect {
       Person.enumerate :first_name
-    }.should raise_error(ActiveEnum::EnumNotFound)
+    }.to raise_error(ActiveEnum::EnumNotFound)
   end
 
   context "attribute" do
@@ -65,19 +65,19 @@ describe ActiveEnum::Extensions do
 
     context "with value" do
       it 'should return value with no arg' do
-        person.sex.should == 1
+        expect(person.sex).to eq(1)
       end
 
       it 'should return enum id for value' do
-        person.sex(:id).should == 1
+        expect(person.sex(:id)).to eq(1)
       end
 
       it 'should return enum name for value' do
-        person.sex(:name).should == 'Male'
+        expect(person.sex(:name)).to eq('Male')
       end
 
       it 'should return enum class for attribute' do
-        person.sex(:enum).should == Sex
+        expect(person.sex(:enum)).to eq(Sex)
       end
     end
 
@@ -85,19 +85,27 @@ describe ActiveEnum::Extensions do
       let(:person) { Person.new(:sex => nil) }
 
       it 'should return nil with no arg' do
-        person.sex.should be_nil
+        expect(person.sex).to be_nil
       end
 
       it 'should return nil enum id' do
-        person.sex(:id).should be_nil
+        expect(person.sex(:id)).to be_nil
       end
 
       it 'should return nil enum name' do
-        person.sex(:name).should be_nil
+        expect(person.sex(:name)).to be_nil
       end
 
       it 'should return enum class for attribute' do
-        person.sex(:enum).should == Sex
+        expect(person.sex(:enum)).to eq(Sex)
+      end
+
+      context "and raise_on_not_found" do
+        with_config :raise_on_not_found, true
+
+        it "should not raise error when attribute is nil" do
+          expect { person.sex(:id) }.to_not raise_error
+        end
       end
     end
 
@@ -105,19 +113,19 @@ describe ActiveEnum::Extensions do
       let(:person) { Person.new(:sex => -1) }
 
       it 'should return value with no arg' do
-        person.sex.should == -1
+        expect(person.sex).to eq(-1)
       end
 
       it 'should return nil enum id' do
-        person.sex(:id).should be_nil
+        expect(person.sex(:id)).to be_nil
       end
 
       it 'should return nil enum name' do
-        person.sex(:name).should be_nil
+        expect(person.sex(:name)).to be_nil
       end
 
       it 'should return enum class for attribute' do
-        person.sex(:enum).should == Sex
+        expect(person.sex(:enum)).to eq(Sex)
       end
     end
 
@@ -134,39 +142,39 @@ describe ActiveEnum::Extensions do
       end
 
       it 'should return meta value for existing key' do
-        person.sex(:description).should == 'Man'
+        expect(person.sex(:description)).to eq('Man')
       end
 
       it 'should return nil for missing meta value' do
-        person.sex(:nonexistent).should be_nil
+        expect(person.sex(:nonexistent)).to be_nil
       end
 
       it 'should return nil for missing index' do
         person.sex = nil
-        person.sex(:description).should be_nil
+        expect(person.sex(:description)).to be_nil
       end
     end
 
     context "question method" do
       it 'should return normal value without arg' do
-        person.sex?.should be_true
+        expect(person.sex?).to be_truthy
         person.sex = nil
-        person.sex?.should be_false
+        expect(person.sex?).to be_falsey
       end
 
       it 'should return true if string name matches for id value' do
-        person.sex?("Male").should be_true
+        expect(person.sex?("Male")).to be_truthy
       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
+        expect(person.sex?(:male)).to be_truthy
+        expect(person.sex?(:Male)).to be_truthy
       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
+        expect(person.sex?("Female")).to be_falsey
+        expect(person.sex?(:female)).to be_falsey
+        expect(person.sex?(:Female)).to be_falsey
       end
     end
 
@@ -174,12 +182,12 @@ describe ActiveEnum::Extensions do
 
       it 'should store id value when valid enum name' do
         person.sex = :female
-        person.sex.should == 2
+        expect(person.sex).to eq(2)
       end
 
       it 'should store nil value when invalid enum name' do
         person.sex = :invalid
-        person.sex.should == nil
+        expect(person.sex).to eq(nil)
       end
 
     end
@@ -195,7 +203,11 @@ describe ActiveEnum::Extensions do
       end 
 
       it 'should return text name value for attribute' do
-        person.sex.should == 'Male'
+        expect(person.sex).to eq('Male')
+      end
+
+      it 'should return true for boolean match' do
+        expect(person.sex?(:male)).to be_truthy
       end
 
       after(:all) { ActiveEnum.use_name_as_value = false }

data/spec/active_enum/form_helpers/simple_form_spec.rb

@@ -7,7 +7,7 @@ describe ActiveEnum::FormHelpers::SimpleForm, :type => :helper do
   include SimpleForm::ActionViewExtensions::FormHelper
 
   before do
-    controller.stub!(:action_name).and_return('new')
+    allow(controller).to receive(:action_name).and_return('new')
     reset_class Person do
       enumerate :sex do
         value :id => 1, :name => 'Male'
@@ -20,25 +20,25 @@ describe ActiveEnum::FormHelpers::SimpleForm, :type => :helper do
     output = simple_form_for(Person.new, :url => people_path) do |f|
       concat f.input(:sex)
     end
-    output.should have_selector('select#person_sex')
-    output.should have_xpath('//option[@value=1]', :content => 'Male')
-    output.should have_xpath('//option[@value=2]', :content => 'Female')
+    expect(output).to have_selector('select#person_sex')
+    expect(output).to have_xpath('//option[@value=1]', :text => 'Male')
+    expect(output).to have_xpath('//option[@value=2]', :text => 'Female')
   end
 
   it "should use explicit :enum input type" do
     output = simple_form_for(Person.new, :url => people_path) do |f|
       concat f.input(:sex, :as => :enum)
     end
-    output.should have_selector('select#person_sex')
-    output.should have_xpath('//option[@value=1]', :content => 'Male')
-    output.should have_xpath('//option[@value=2]', :content => 'Female')
+    expect(output).to have_selector('select#person_sex')
+    expect(output).to have_xpath('//option[@value=1]', :text => 'Male')
+    expect(output).to have_xpath('//option[@value=2]', :text => 'Female')
   end
 
   it "should not use enum input type if :as option indicates other type" do
     output = simple_form_for(Person.new, :url => people_path) do |f|
       concat f.input(:sex, :as => :string)
     end
-    output.should have_selector('input#person_sex')
+    expect(output).to have_selector('input#person_sex')
   end
 
   it "should raise error if attribute for enum input is not enumerated" do
@@ -46,28 +46,28 @@ describe ActiveEnum::FormHelpers::SimpleForm, :type => :helper do
       simple_form_for(Person.new, :url => people_path) do |f|
         f.input(:attending, :as => :enum)
       end
-    }.should raise_error "Attribute 'attending' has no enum class"
+    }.to raise_error "Attribute 'attending' has no enum class"
   end
 
   it "should not use enum input type if class does not support ActiveEnum" do
     output = simple_form_for(NotActiveRecord.new, :as => :not_active_record, :url => people_path) do |f|
       concat f.input(:name)
     end
-    output.should have_selector('input#not_active_record_name')
+    expect(output).to have_selector('input#not_active_record_name')
   end
 
   it "should allow non-enum fields to use default input determination" do
     output = simple_form_for(Person.new, :url => people_path) do |f|
       concat f.input(:first_name)
     end
-    output.should have_selector('input#person_first_name')
+    expect(output).to have_selector('input#person_first_name')
   end
 
   it "should allow models without enumerated attributes to behave normally" do
     output = simple_form_for(NoEnumPerson.new, :url => people_path) do |f|
       concat f.input(:first_name)
     end
-    output.should have_selector('input#no_enum_person_first_name')
+    expect(output).to have_selector('input#no_enum_person_first_name')
   end
 
   def people_path