enumerate_it 0.7.5 → 0.7.6

data/README.rdoc

@@ -145,16 +145,6 @@ This will create:
 
 NOTE: The :create_scopes option can only be used for Rails.version >= 3.0.0. 
 
-* If you pass the :create_scopes option as 'true', it will create a scope method for each enumeration option (this option defaults to false):
-
-  class Person < ActiveRecord::Base
-    has_enumeration_for :relationship_status, :with => RelationshipStatus, :create_scopes => true
-  end
-
-  Person.married.to_sql # => SELECT "people".* FROM "people" WHERE "people"."relationship_status" = 1
-
-NOTE: The :create_scopes option can only be used for Rails.version >= 3.0.0. 
-
 * If your class can manage validations and responds to :validates_inclusion_of, it will create this validation:
 
    class Person < ActiveRecord::Base

data/lib/enumerate_it.rb

@@ -126,6 +126,16 @@
 #  p.married? #=> true
 #  p.divorced? #=> false
 #
+# - If you pass the :create_scopes option as 'true', it will create a scope method for each enumeration option (this option defaults to false):
+# 
+#   class Person < ActiveRecord::Base
+#     has_enumeration_for :relationship_status, :with => RelationshipStatus, :create_scopes => true
+#   end
+# 
+#   Person.married.to_sql # => SELECT "people".* FROM "people" WHERE "people"."relationship_status" = 1
+# 
+# NOTE: The :create_scopes option can only be used for Rails.version >= 3.0.0. 
+#
 # - If your class can manage validations and responds to :validates_inclusion_of, it will create this
 # validation:
 #
@@ -275,12 +285,8 @@ module EnumerateIt
 
     def create_scopes(klass, attribute_name)
       klass.enumeration.keys.each do |option|
-        if defined?(Rails) 
-          if Rails.version >= "3.0.0"
-            scope option, where(attribute_name => klass.enumeration[option].first)
-          else
-            raise StandardError, "EnumerateIt cannot create scopes if Rails.version < 3.0.0"
-          end
+        if respond_to? :scope
+          scope option, where(attribute_name => klass.enumeration[option].first)
         end
       end
     end

data/lib/version.rb

@@ -1,4 +1,4 @@
 module EnumerateIt
-  VERSION = "0.7.5"
+  VERSION = "0.7.6"
 end
 

data/spec/enumerate_it_spec.rb

@@ -135,146 +135,132 @@ describe EnumerateIt do
       TestClass.send(:has_enumeration_for, :foobar, :with => TestEnumeration, :create_scopes => true)
     end
 
-    context "when using Rails" do
-      before { module Rails; end }
-
-      context "with version >= 3.0.0" do
-        before do
-          module Rails
-            def self.version; "3.0.0"; end
-          end
-
-          class TestClass
-            def self.where(whatever); end
-            def self.scope(name, whatever); end
-          end
-
-          setup_enumeration
+    context "if the hosting class responds to :scope" do
+      before do
+        class TestClass
+          def self.where(whatever); end
+          def self.scope(name, whatever); end
         end
 
-        it "creates a scope for each enumeration value" do
-          TestEnumeration.enumeration do |symbol, pair|
-            TestClass.should respond_to(symbol)
-          end
-        end
+        setup_enumeration
+      end
 
-        it "when called, the scopes create the correct query" do          
-          TestEnumeration.enumeration do |symbol, pair|
-            TestClass.should_receive(:where).with(:foobar => pair.firs)
-            TestClass.send symbol
-          end
+      it "creates a scope for each enumeration value" do
+        TestEnumeration.enumeration do |symbol, pair|
+          TestClass.should respond_to(symbol)
         end
       end
 
-      context "with version < 3.0.0" do
-        before :each do
-          module Rails
-            def self.version; "2.3.9"; end
-          end
+      it "when called, the scopes create the correct query" do          
+        TestEnumeration.enumeration do |symbol, pair|
+          TestClass.should_receive(:where).with(:foobar => pair.firs)
+          TestClass.send symbol
         end
+      end
+    end
 
-        it "raises an error telling that scopes creation are ony supported for Rails >= 3.0.0" do
-          expect { 
-            setup_enumeration
-          }.to raise_error("EnumerateIt cannot create scopes if Rails.version < 3.0.0")
-        end        
+    context "when the hosting class do not respond to :scope" do
+      it "raises no errors" do
+        expect {
+          setup_enumeration
+        }.to_not raise_error
       end
     end
   end
+end
 
-  describe EnumerateIt::Base do
-    it "creates constants for each enumeration value" do
-      [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2, TestEnumeration::VALUE_3].each_with_index do |constant, idx|
-        constant.should == (idx + 1).to_s
-      end
+describe EnumerateIt::Base do
+  it "creates constants for each enumeration value" do
+    [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2, TestEnumeration::VALUE_3].each_with_index do |constant, idx|
+      constant.should == (idx + 1).to_s
     end
+  end
 
-    it "creates a method that returns the allowed values in the enumeration's class" do
-      TestEnumeration.list.should == ['1', '2', '3']
+  it "creates a method that returns the allowed values in the enumeration's class" do
+    TestEnumeration.list.should == ['1', '2', '3']
+  end
+
+  it "creates a method that returns the enumeration specification" do
+    TestEnumeration.enumeration.should == {
+      :value_1 => ['1', 'Hey, I am 1!'],
+      :value_2 => ['2', 'Hey, I am 2!'],
+      :value_3 => ['3', 'Hey, I am 3!']
+    }
+  end
+
+  describe ".to_a" do
+    it "returns an array with the values and human representations" do
+      TestEnumeration.to_a.should == [['Hey, I am 1!', '1'], ['Hey, I am 2!', '2'], ['Hey, I am 3!', '3']]
     end
 
-    it "creates a method that returns the enumeration specification" do
-      TestEnumeration.enumeration.should == {
-        :value_1 => ['1', 'Hey, I am 1!'],
-        :value_2 => ['2', 'Hey, I am 2!'],
-        :value_3 => ['3', 'Hey, I am 3!']
-      }
+    it "translates the available values" do
+      TestEnumerationWithoutArray.to_a.should == [['First Value', '1'], ['Value Two', '2']]
+      I18n.locale = :pt
+      TestEnumerationWithoutArray.to_a.should == [['Primeiro Valor', '1'], ['Value Two', '2']]
     end
 
-    describe ".to_a" do
-      it "returns an array with the values and human representations" do
-        TestEnumeration.to_a.should == [['Hey, I am 1!', '1'], ['Hey, I am 2!', '2'], ['Hey, I am 3!', '3']]
-      end
+    it "can be extended from the enumeration class" do
+      TestEnumerationWithExtendedBehaviour.to_a.should == [['Second', '2'],['First','1']]
+    end
+  end
 
-      it "translates the available values" do
-        TestEnumerationWithoutArray.to_a.should == [['First Value', '1'], ['Value Two', '2']]
-        I18n.locale = :pt
-        TestEnumerationWithoutArray.to_a.should == [['Primeiro Valor', '1'], ['Value Two', '2']]
-      end
+  describe ".t" do
+    it "translates a given value" do
+      I18n.locale = :pt
+      TestEnumerationWithoutArray.t('1').should == 'Primeiro Valor'
+    end
+  end
 
-      it "can be extended from the enumeration class" do
-        TestEnumerationWithExtendedBehaviour.to_a.should == [['Second', '2'],['First','1']]
-      end
+  describe "#to_range" do
+    it "returns a Range object containing the enumeration's value interval" do
+      TestEnumeration.to_range.should == ("1".."3")
     end
+  end
 
-    describe ".t" do
-      it "translates a given value" do
-        I18n.locale = :pt
-        TestEnumerationWithoutArray.t('1').should == 'Primeiro Valor'
-      end
+  describe ".values_for" do
+    it "returns an array with the corresponding values for a string array representing some of the enumeration's values" do
+      TestEnumeration.values_for(%w(VALUE_1 VALUE_2)).should == [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2]
     end
+  end
 
-    describe "#to_range" do
-      it "returns a Range object containing the enumeration's value interval" do
-        TestEnumeration.to_range.should == ("1".."3")
+  context "when included in ActiveRecord::Base" do
+    before :each do
+      class ActiveRecordStub
+        attr_accessor :bla
+
+        class << self
+          def validates_inclusion_of(options); true; end
+          def validates_presence_of; true; end
+        end
       end
+
+      ActiveRecordStub.stub!(:validates_inclusion_of).and_return(true)
+      ActiveRecordStub.send :include, EnumerateIt
     end
 
-    describe ".values_for" do
-      it "returns an array with the corresponding values for a string array representing some of the enumeration's values" do
-        TestEnumeration.values_for(%w(VALUE_1 VALUE_2)).should == [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2]
+    it "creates a validation for inclusion" do
+      ActiveRecordStub.should_receive(:validates_inclusion_of).with(:bla, :in => TestEnumeration.list, :allow_blank => true)
+      class ActiveRecordStub
+        has_enumeration_for :bla, :with => TestEnumeration
       end
     end
 
-    context "when included in ActiveRecord::Base" do
+    context "using the :required option" do
       before :each do
-        class ActiveRecordStub
-          attr_accessor :bla
-
-          class << self
-            def validates_inclusion_of(options); true; end
-            def validates_presence_of; true; end
-          end
-        end
-
-        ActiveRecordStub.stub!(:validates_inclusion_of).and_return(true)
-        ActiveRecordStub.send :include, EnumerateIt
+        ActiveRecordStub.stub!(:validates_presence_of).and_return(true)
       end
 
-      it "creates a validation for inclusion" do
-        ActiveRecordStub.should_receive(:validates_inclusion_of).with(:bla, :in => TestEnumeration.list, :allow_blank => true)
+      it "creates a validation for presence" do
+        ActiveRecordStub.should_receive(:validates_presence_of)
         class ActiveRecordStub
-          has_enumeration_for :bla, :with => TestEnumeration
+          has_enumeration_for :bla, :with => TestEnumeration, :required => true
         end
       end
 
-      context "using the :required option" do
-        before :each do
-          ActiveRecordStub.stub!(:validates_presence_of).and_return(true)
-        end
-
-        it "creates a validation for presence" do
-          ActiveRecordStub.should_receive(:validates_presence_of)
-          class ActiveRecordStub
-            has_enumeration_for :bla, :with => TestEnumeration, :required => true
-          end
-        end
-
-        it "do not require the attribute by default" do
-          ActiveRecordStub.should_not_receive(:validates_presence_of)
-          class ActiveRecordStub
-            has_enumeration_for :bla, :with => TestEnumeration
-          end
+      it "do not require the attribute by default" do
+        ActiveRecordStub.should_not_receive(:validates_presence_of)
+        class ActiveRecordStub
+          has_enumeration_for :bla, :with => TestEnumeration
         end
       end
     end

metadata

@@ -2,7 +2,7 @@
 name: enumerate_it
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.7.5
+  version: 0.7.6
 platform: ruby
 authors: 
 - "C\xC3\xA1ssio Marques"