symbolize 4.2.0 → 4.3.0

data/README.rdoc

@@ -1,4 +1,4 @@
-= Symbolize attribute values
+= Symbolize (attribute values)
 
 This plugin introduces an easy way to use symbols for values of attributes.
 Symbolized attributes return a ruby symbol (or nil) as their value
@@ -11,15 +11,9 @@ and can be set using :symbols or "strings".
     gem install symbolize
 
 
-=== Mongoid
-
-    gem "symbolize", :require => "symbolize/mongoid"
-
-
-=== ActiveRecord
-
-    gem "symbolize", :require => "symbolize/active_record"
+=== Gemfile
 
+    gem "symbolize"
 
 
 == About
@@ -35,22 +29,27 @@ On schema DBs, the attribute should be a string (varchar) column.
 
 ActiveRecord:
 
-    class User < ActiveRecord::Base
+    class Contact < ActiveRecord::Base
 
-      symbolize :gender, :in => [:female, :male], :scopes => true
+      symbolize :kind, :in => [:im, :mobile, :email], :scopes => true
 
-    end
 
 Mongoid:
 
-    class User
+    require 'symbolize/mongoid'
 
-      include Mongoid::Document
+    class Contact
       include Mongoid::Symbolize
 
-      symbolize :gender, :in => [:female, :male], :scopes => true
+      symbolize :kind, :in => [:im, :mobile, :email], :scopes => true
+
+or just
+
+    class Contact
+      include Symbolize::Mongoid
+
+      symbolize :kind, :in => [:im, :mobile, :email], :scopes => true
 
-    end
 
 Other examples:
 
@@ -171,7 +170,7 @@ in new objects automatically. Mongoid only for now.
 
     symbolize :mood, :in => [:happy, :sad, :euphoric], :default => (MarvinDay ? :sad : :happy)
 
-    User.new.kind # It may print :happy
+    User.new.mood # It may print :happy
 
 
 == Rails Form Example
@@ -217,15 +216,3 @@ Run the adapter independently:
 This fork:
 http://github.com/nofxx/symbolize
 
-
-Forked from:
-http://github.com/nuxlli/activerecord_symbolize
-
-
-Initial work:
-I've been using this for quite some time and made it a rails plugin now. More
-background iinformation can be found at
-http://zargony.com/2007/09/07/symbolize-attribute-values-in-activerecord
-
-
-Copyright (c) 2007-2008 Andreas Neuhaus, released under the MIT license

data/lib/symbolize.rb

@@ -1,6 +1,7 @@
 module Symbolize
-  # Require a specific adapter
-  # symbolize/mongoid
-  # symbolize/active_record
-
+  autoload :ActiveRecord, 'symbolize/active_record'
+  autoload :Mongoid, 'symbolize/mongoid'
 end
+
+require 'symbolize/railtie' if defined? Rails
+

data/lib/symbolize/active_record.rb

@@ -1,7 +1,10 @@
+require 'active_support/concern'
+
 module Symbolize
-  def self.included base
-    base.extend(ClassMethods)
-  end
+end
+
+module Symbolize::ActiveRecord
+  extend ActiveSupport::Concern
 
   # Symbolize ActiveRecord attributes. Add
   #   symbolize :attr_name
@@ -51,7 +54,7 @@ module Symbolize
       configuration.update(attr_names.extract_options!)
 
       enum = configuration[:in] || configuration[:within]
-      i18n = configuration.delete(:i18n).nil? && !enum.instance_of?(Hash) && enum ? true : configuration[:i18n]
+      i18n = configuration.delete(:i18n) || (!enum.instance_of?(Hash) && enum)
       scopes  = configuration.delete :scopes
       methods = configuration.delete :methods
       capitalize = configuration.delete :capitalize
@@ -59,8 +62,6 @@ module Symbolize
       default_option = configuration.delete :default
 
       unless enum.nil?
-        # Little monkeypatching, <1.8 Hashes aren't ordered.
-        hsh = RUBY_VERSION > '1.9' || !defined?("ActiveSupport") ? Hash : ActiveSupport::OrderedHash
 
         attr_names.each do |attr_name|
           attr_name = attr_name.to_s
@@ -68,7 +69,7 @@ module Symbolize
           if enum.is_a?(Hash)
             values = enum
           else
-            values = hsh.new
+            values = ActiveSupport::OrderedHash.new
             enum.map do |val|
               key = val.respond_to?(:to_sym) ? val.to_sym : val
               values[key] = capitalize ? val.to_s.capitalize : val.to_s
@@ -85,22 +86,30 @@ module Symbolize
             "def self.get_#{const}; #{const.upcase}.map(&:reverse); end"
           end
           class_eval(ev)
+          class_eval "def self.#{attr_name}_enum; self.get_#{const}; end"
 
           if methods
             values.each do |value|
               key = value[0]
+
+              # It's a good idea to test for name collisions here and raise exceptions.
+              # However, the existing software with this kind of errors will start crashing,
+              # so I'd postpone this improvement until the next major version
+              # this way it will not affect those people who use ~> in their Gemfiles
+
+              # raise ArgumentError, "re-defined #{key}? method of #{self.name} class due to 'symbolize'" if method_defined?("#{key}?")
+
               define_method("#{key}?") do
-                self[attr_name].to_s == key.to_s
+                self.send(attr_name) == key.to_sym
               end
             end
           end
 
           if scopes
-            scope_comm = lambda { |*args| ActiveRecord::VERSION::MAJOR >= 3 ? scope(*args) : named_scope(*args)}
             values.each do |value|
               name = value[0]
               if name.respond_to?(:to_sym)
-                scope_comm.call name.to_sym, :conditions => { attr_name => name.to_s }
+                scope name.to_sym, :conditions => { attr_name => name.to_s }
                 # Figure out if this as another option, or default...
                 # scope_comm.call "not_#{attr_name}".to_sym, :conditions => { attr_name != name }
               end
@@ -156,8 +165,8 @@ module Symbolize
   # Return an attribute's i18n
   def read_i18n_attribute attr_name
     attr = read_attribute(attr_name)
-    return nil if attr.nil?
-    I18n.translate("activerecord.symbolizes.#{ActiveSupport::Inflector.underscore(self.class.model_name)}.#{attr_name}.#{attr}") #.to_sym rescue nila
+    t = I18n.translate("activerecord.symbolizes.#{self.class.model_name.underscore}.#{attr_name}.#{attr}") #.to_sym rescue nila
+    t.is_a?(Hash) ? nil : t
   end
 
   # Write a symbolized value. Watch out for booleans.
@@ -168,5 +177,3 @@ module Symbolize
     self[attr_name] = val #.to_s
   end
 end
-
-ActiveRecord::Base.send(:include, Symbolize)

data/lib/symbolize/mongoid.rb

@@ -1,8 +1,8 @@
+require 'active_support/concern'
+
 module Mongoid
   module Symbolize
-    def self.included base
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
     # Symbolize Mongoid attributes. Add:
     #   symbolize :attr_name
@@ -54,9 +54,10 @@ module Mongoid
         configuration.update(attr_names.extract_options!)
 
         enum = configuration[:in] || configuration[:within]
-        i18n = configuration.delete(:i18n).nil? && !enum.instance_of?(Hash) ? true : configuration[:i18n]
-        scopes  = configuration.delete :scopes
-        methods = configuration.delete :methods
+        i18n = configuration.delete(:i18n)
+        i18n = (!enum.instance_of?(Hash) && enum) if i18n.nil?
+        scopes      = configuration.delete :scopes
+        methods     = configuration.delete :methods
         capitalize  = configuration.delete :capitalize
         validation  = configuration.delete(:validate) != false
         field_type  = configuration.delete :type
@@ -71,11 +72,11 @@ module Mongoid
             #
             # Builds Mongoid 'field :name, type: type, :default'
             #
+            const       =  "#{attr_name}_values"
             mongo_opts  = ", :type => #{field_type || 'Symbol'}"
             mongo_opts += ", :default => :#{default_opt}" if default_opt
             class_eval("field :#{attr_name} #{mongo_opts}")
 
-            const =  "#{attr_name}_values"
             if enum.is_a?(Hash)
               values = enum
             else
@@ -96,31 +97,32 @@ module Mongoid
                    "def self.get_#{const}; #{const.upcase}.map(&:reverse); end"
                  end
             class_eval(ev)
+            class_eval "def self.#{attr_name}_enum; self.get_#{const}; end"
 
             if methods
-              values.each do |value|
-                define_method("#{value[0]}?") do
-                  self.send(attr_name) == value[0]
+              values.each do |k, v|
+                define_method("#{k}?") do
+                  self.send(attr_name) == k
                 end
               end
             end
 
             if scopes
-              scope_comm = lambda { |*args|  scope(*args)}
-              values.each do |value|
-                if value[0].respond_to?(:to_sym)
-                  scope_comm.call value[0].to_sym, where({ attr_name => value[0].to_sym })
+              values.each do |k, v|
+                if k.respond_to?(:to_sym)
+                  scope k.to_sym, where({ attr_name => k.to_sym })
                 end
               end
             end
 
             if validation
-              validation = "validates :#{attr_names.join(', :')}"
-              validation += ", :inclusion => { :in => #{values.keys.inspect} }"
-              validation += ", :allow_nil => true" if configuration[:allow_nil]
-              validation += ", :allow_blank => true" if configuration[:allow_blank]
-              class_eval validation
+              v = "validates :#{attr_names.join(', :')}"
+              v += ",:inclusion => { :in => #{values.keys.inspect} }"
+              v += ",:allow_nil => true"   if configuration[:allow_nil]
+              v += ",:allow_blank => true" if configuration[:allow_blank]
+              class_eval v
             end
+
           end
         end
 
@@ -130,8 +132,9 @@ module Mongoid
         attr_names.each do |attr_name|
           if i18n # memoize call to translate... good idea?
             define_method "#{attr_name}_text" do
-              return nil unless attr = read_attribute(attr_name)
-              I18n.t("mongoid.symbolizes.#{ActiveSupport::Inflector.underscore(self.class.model_name)}.#{attr_name}.#{attr}")
+              attr = read_attribute(attr_name)
+              return nil if attr.nil?
+              I18n.t("mongoid.symbolizes.#{self.class.model_name.underscore}.#{attr_name}.#{attr}")
             end
           elsif enum
             class_eval("def #{attr_name}_text; #{attr_name.to_s.upcase}_VALUES[#{attr_name}]; end")
@@ -145,3 +148,5 @@ module Mongoid
     end # ClassMethods
   end # Symbolize
 end # Mongoid
+
+# Symbolize::Mongoid = Mongoid::Symbolize

data/lib/symbolize/railtie.rb

@@ -1,15 +1,11 @@
 # Rails 3 initialization
 module Symbolize
-  # if defined? Rails::Railtie
-  #   require 'rails'
-  #   class Railtie < Rails::Railtie
-  #     initializer 'symbolize.insert_into_active_record' do
-  #       ActiveSupport.on_load :active_record do
-  #         ActiveRecord::Base.extend(Symbolize::ClassMethods)
-  #       end
-  #     end
-  #   end
-  # end
+  require 'rails'
+  class Railtie < Rails::Railtie
+    initializer 'symbolize.insert_into_active_record' do
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.send :include, Symbolize::ActiveRecord
+      end
+    end
+  end
 end
-
-

data/lib/symbolize/version.rb

@@ -1,3 +1,3 @@
 module Symbolize
-  VERSION = '4.2.0'
+  VERSION = '4.3.0'
 end

data/spec/db/001_create_testing_structure.rb

@@ -8,6 +8,9 @@ class CreateTestingStructure < ActiveRecord::Migration
       t.boolean :sex
       t.boolean :public
       t.boolean :cool
+      t.string :role
+      t.string :country, :default => "pt"
+      t.string :some_attr  # used in name collision tests
     end
     create_table :user_skills do |t|
       t.references :user

data/spec/locales/pt.yml

@@ -2,6 +2,16 @@ pt:
   activerecord:
     symbolizes:
       user:
+        role: reader
+        status:
+          active: Active
+          inactive: Inactive
+        gui:
+          cocoa: cocoa
+          gtk: gtk
+          qt: qt
+        country:
+          pt: Pt
         language:
           pt: Português
           en: Inglês

data/spec/spec_helper_ar.rb

@@ -2,8 +2,11 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 require 'active_record'
 require 'symbolize/active_record'
+ActiveRecord::Base.send :include, Symbolize::ActiveRecord # this is normally done by the railtie
+
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:") #'postgresql', :database => 'symbolize_test', :username => 'postgres')
 
+
 if ActiveRecord::VERSION::STRING >= "3.1"
   ActiveRecord::Migrator.migrate("spec/db")
 else

data/spec/spec_helper_mongoid.rb

@@ -3,15 +3,16 @@ require 'mongoid'
 require 'mongoid/version'
 
 Mongoid.configure do |config|
-  config.master = Mongo::Connection.new.db("symbolize_test")
-end
-
-Mongoid.database.collections.each do |collection|
-  unless collection.name =~ /^system\./
-    collection.remove
-  end
+  #config.master = Mongo::Connection.new.db("symbolize_test")
+  config.connect_to('symbolize_test')
 end
 
 puts "Running Mongoid #{Mongoid::VERSION}"
 
 require 'symbolize/mongoid'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Mongoid.purge!
+  end
+end

data/spec/symbolize/active_record_spec.rb

@@ -17,6 +17,9 @@ class User < ActiveRecord::Base
   symbolize :karma, :in => %w{ good bad ugly}, :methods => true, :i18n => false, :allow_nil => true
   symbolize :cool, :in => [true, false], :scopes => true
 
+  symbolize :role, :in => [:reader, :writer, :some_existing_attr], :i18n => false, :methods => true, :default => :reader
+  symbolize :country, :in => [:us, :gb, :pt, :ru], :capitalize => true, :i18n => false  # note: the default value is provided in db migration
+
   has_many :extras, :dependent => :destroy, :class_name => "UserExtra"
   has_many :access, :dependent => :destroy, :class_name => "UserAccess"
 end
@@ -52,67 +55,66 @@ describe "Symbolize" do
   it "should have a valid blueprint" do
     # Test records
     u = User.create(:name => 'Bob' , :other => :bar,:status => :inactive, :so => :mac, :gui => :gtk, :language => :en, :sex => false, :cool => false)
-    u.errors.messages.should eql({})
+    u.errors.messages.should be_blank
   end
 
   it "should work nice with default values from active model" do
     u = User.create(:name => 'Niu' , :other => :bar, :so => :mac, :gui => :gtk, :language => :en, :sex => false, :cool => false)
-    u.errors.messages.should eql({})
+    u.errors.messages.should be_blank
     u.status.should eql(:active)
     u.should be_active
   end
 
   describe "User Instantiated" do
-    before(:each) do
-      @user = User.create(:name => 'Anna', :other => :fo, :status => :active  , :so => :linux, :gui => :qt, :language => :pt, :sex => true, :cool => true)
-    end
-
-    it "test_symbolize_string" do
-      @user.status = 'inactive'
-      @user.status.should eql(:inactive)
+    subject {
+      User.create(:name => 'Anna', :other => :fo, :status => status, :so => so, :gui => :qt, :language => :pt, :sex => true, :cool => true)
+    }
+    let(:status) { :active }
+    let(:so) { :linux }
+
+    describe "test_symbolize_string" do
+      let(:status) { 'inactive' }
+      its(:status) { should == :inactive }
       #      @user.status_before_type_cast.should eql(:inactive)
       # @user.read_attribute(:status).should eql('inactive')
     end
 
-    it "test_symbolize_symbol" do
-      @user.status = :active
-      @user.status.should eql(:active)
-      @user.status_before_type_cast.should eql(:active)
+    describe "test_symbolize_symbol" do
+      its(:status) { should == :active }
+      its(:status_before_type_cast) { should == :active }
       # @user.read_attribute(:status).should eql('active')
     end
 
-    it "should work nice with numbers" do
-      @user.status = 43
-      @user.status.should_not be_nil
+    describe "should work nice with numbers" do
+      let(:status) { 43 }
+      its(:status) { should be_present }
       # @user.status_before_type_cast.should be_nil
       # @user.read_attribute(:status).should be_nil
     end
 
-    it "should acts nice with nil" do
-      @user.status = nil
-      @user.status.should be_nil
-      @user.status_before_type_cast.should be_nil
-      @user.read_attribute(:status).should be_nil
+    describe "should acts nice with nil" do
+      let(:status) { nil }
+      its(:status) { should be_nil }
+      its(:status_before_type_cast) { should be_nil }
+      it { subject.read_attribute(:status).should be_nil }
     end
 
-    it "should acts nice with blank" do
-      @user.status = ""
-      @user.status.should be_nil
-      @user.status_before_type_cast.should be_nil
-      @user.read_attribute(:status).should be_nil
+    describe "should acts nice with blank" do
+      let(:status) { "" }
+      its(:status) { should be_nil }
+      its(:status_before_type_cast) { should be_nil }
+      it { subject.read_attribute(:status).should be_nil }
     end
 
-    it "test_symbols_quoted_id" do
-      pending
-      @user.status = :active
-      @user.status.quoted_id.should eql("'active'")
+    describe "test_symbols_quoted_id" do
+      pending { subject.status.quoted_id.should eql("'active'") }
     end
 
     it "should not validates other" do
-      @user.other = nil
-      @user.should be_valid
-      @user.other = ""
-      @user.should be_valid
+      subject.other = nil
+      subject.should be_valid
+      subject.other = ""
+      subject.should be_valid
     end
 
     it "should get the correct values" do
@@ -120,8 +122,12 @@ describe "Symbolize" do
       User::STATUS_VALUES.should eql({:inactive=>"Inactive", :active=>"Active"})
     end
 
-    it "test_symbolize_humanize" do
-      @user.status_text.should eql("Active")
+    it "should get the values for RailsAdmin" do
+      User.status_enum.should eql([["Active", :active],["Inactive", :inactive]])
+    end
+
+    describe "test_symbolize_humanize" do
+      its(:status_text) { should eql("Active") }
     end
 
     it "should get the correct values" do
@@ -129,8 +135,8 @@ describe "Symbolize" do
       User::GUI_VALUES.should eql({:cocoa=>"cocoa", :qt=>"qt", :gtk=>"gtk"})
     end
 
-    it "test_symbolize_humanize" do
-      @user.gui_text.should eql("qt")
+    describe "test_symbolize_humanize" do
+      its(:gui_text) { should eql("qt") }
     end
 
     it "should get the correct values" do
@@ -138,58 +144,58 @@ describe "Symbolize" do
       User::SO_VALUES.should eql({:linux => "Linux", :mac => "Mac OS X", :win => "Videogame"})
     end
 
-    it "test_symbolize_humanize" do
-      @user.so_text.should eql("Linux")
+    describe "test_symbolize_humanize" do
+      its(:so_text) { should eql("Linux") }
     end
 
-    it "test_symbolize_humanize" do
-      @user.so = :mac
-      @user.so_text.should eql("Mac OS X")
+    describe "test_symbolize_humanize" do
+      let(:so) { :mac }
+      its(:so_text) { should eql("Mac OS X") }
     end
 
     it "should stringify" do
-      @user.other_text.should eql("fo")
-      @user.other = :foo
-      @user.other_text.should eql("foo")
+      subject.other_text.should eql("fo")
+      subject.other = :foo
+      subject.other_text.should eql("foo")
     end
 
-    it "should validate status" do
-      @user.status = nil
-      @user.should_not be_valid
-      @user.should have(1).errors
+    describe "should validate status" do
+      let(:status) { nil }
+      it { should_not be_valid }
+      it { should have(1).errors }
     end
 
     it "should not validate so" do
-      @user.so = nil
-      @user.should be_valid
+      subject.so = nil
+      subject.should be_valid
     end
 
     it "test_symbols_with_weird_chars_quoted_id" do
-      @user.status = :"weird'; chars"
-      @user.status_before_type_cast.should eql(:"weird'; chars")
+      subject.status = :"weird'; chars"
+      subject.status_before_type_cast.should eql(:"weird'; chars")
       #    assert_equal "weird'; chars", @user.read_attribute(:status)
       #   assert_equal "'weird''; chars'", @user.status.quoted_id
     end
 
     it "should work fine through relations" do
-      @user.extras.create(:key => :one)
+      subject.extras.create(:key => :one)
       UserExtra.first.key.should eql(:one)
     end
 
     it "should play fine with null db columns" do
-      new_extra = @user.extras.build
+      new_extra = subject.extras.build
       new_extra.should_not be_valid
     end
 
     it "should play fine with null db columns" do
-      new_extra = @user.extras.build
+      new_extra = subject.extras.build
       new_extra.should_not be_valid
     end
 
     describe "i18n" do
 
       it "should test i18n ones" do
-        @user.language_text.should eql("Português")
+        subject.language_text.should eql("Português")
       end
 
       it "should get the correct values" do
@@ -201,9 +207,9 @@ describe "Symbolize" do
       end
 
       it "should test boolean" do
-        @user.sex_text.should eql("Feminino")
-        @user.sex = false
-        @user.sex_text.should eql('Masculino')
+        subject.sex_text.should eql("Feminino")
+        subject.sex = false
+        subject.sex_text.should eql('Masculino')
       end
 
       it "should get the correct values" do
@@ -229,20 +235,20 @@ describe "Symbolize" do
     describe "Methods" do
 
       it "should play nice with other stuff" do
-        @user.karma.should be_nil
+        subject.karma.should be_nil
         User::KARMA_VALUES.should eql({:bad => "bad", :ugly => "ugly", :good => "good"})
       end
 
       it "should provide a boolean method" do
-        @user.should_not be_good
-        @user.karma = :ugly
-        @user.should be_ugly
+        subject.should_not be_good
+        subject.karma = :ugly
+        subject.should be_ugly
       end
 
       it "should work" do
-        @user.karma = "good"
-        @user.should be_good
-        @user.should_not be_bad
+        subject.karma = "good"
+        subject.should be_good
+        subject.should_not be_bad
       end
 
     end
@@ -250,21 +256,21 @@ describe "Symbolize" do
     describe "Methods" do
 
       it "is dirty if you change the attribute value" do
-        @user.language.should == :pt
-        @user.language_changed?.should be_false
+        subject.language.should == :pt
+        subject.language_changed?.should be_false
 
-        return_value = @user.language = :en
+        return_value = subject.language = :en
         return_value.should == :en
-        @user.language_changed?.should be_true
+        subject.language_changed?.should be_true
       end
 
       it "is not dirty if you set the attribute value to the same value" do
-        @user.language.should == :pt
-        @user.language_changed?.should be_false
+        subject.language.should == :pt
+        subject.language_changed?.should be_false
 
-        return_value = @user.language = :pt
+        return_value = subject.language = :pt
           return_value.should == :pt
-        @user.language_changed?.should be_false
+        subject.language_changed?.should be_false
       end
 
     end
@@ -353,4 +359,56 @@ describe "Symbolize" do
     # end
 
   end
+
+
+  describe ": Default Value" do
+    before(:each) do
+      @user = User.new(:name => 'Anna', :other => :fo, :status => :active  , :so => :linux, :gui => :qt, :language => :pt, :sex => true, :cool => true)
+    end
+
+    it "should be considered during validation" do
+      @user.valid?
+      @user.errors.full_messages.should == []
+    end
+
+    it "should be taken from the DB schema definition" do
+      @user.country.should == :pt
+      @user.country_text.should == "Pt"
+    end
+
+    it "should be applied to new, just saved, and reloaded objects, and also play fine with :methods option" do
+      @user.role.should == :reader
+      @user.role_text.should == "reader"
+      @user.should be_reader
+      @user.save!
+      @user.role.should == :reader
+      @user.should be_reader
+      @user.reload
+      @user.role.should == :reader
+      @user.should be_reader
+    end
+
+    it "should be overridable" do
+      @user.role = :writer
+      @user.role.should == :writer
+      @user.should be_writer
+      @user.save!
+      @user.role.should == :writer
+      @user.should be_writer
+      @user.reload
+      @user.role.should == :writer
+      @user.should be_writer
+    end
+
+    # This feature is for the next major version (b/o the compatibility problem)
+    pending "should detect name collision caused by ':methods => true' option" do
+      lambda {
+        User.class_eval do
+          # 'reader?' method is already defined, so the line below should raise an error
+          symbolize :some_attr, :in => [:reader, :guest], :methods => true
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+  end
 end

data/spec/symbolize/mongoid_spec.rb

@@ -9,8 +9,9 @@ class Person
   include Mongoid::Timestamps
 
   symbolize :other, :i18n => false
+
   symbolize :language, :in => [:pt, :en]
-  symbolize :sex, :type => Boolean, :scopes => true
+  symbolize :sex, :type => Boolean, :scopes => true, :i18n => true
   symbolize :status , :in => [:active, :inactive], :i18n => false, :capitalize => true, :scopes => true
   symbolize :so, :allow_blank => true, :in => {
     :linux => 'Linux',
@@ -131,6 +132,10 @@ describe "Symbolize" do
       Person::STATUS_VALUES.should eql({ inactive: "Inactive", active: "Active"})
     end
 
+    it "should get the values for RailsAdmin" do
+      Person.status_enum.should eql([["Active", :active],["Inactive", :inactive]])
+    end
+
     it "should have a human _text method" do
       person.status_text.should eql("Active")
     end
@@ -249,6 +254,15 @@ describe "Symbolize" do
         skill.kind_text.should be_nil
       end
 
+      it "should return the proper 'false' i18n if the attr value is false" do
+        person = Person.new(:sex => false)
+        person.sex_text.should == "Masculino"
+      end
+
+      it "should use i18n if i18n => true" do
+        person.sex_text.should eql("Feminino")
+      end
+
     end
 
     describe "Methods" do
@@ -276,10 +290,6 @@ describe "Symbolize" do
 
   describe "more tests on Right" do
 
-    it "should use default value on object build" do
-      Right.new.kind.should eql(:perm)
-    end
-
     it "should not interfer on create" do
       Right.create!(:name => "p7", :kind => :temp)
       Right.where(name: "p7").first.kind.should eql(:temp)
@@ -293,10 +303,11 @@ describe "Symbolize" do
 
     it "should work on create" do
       Right.create(:name => "p8")
-      Right.first(conditions: { name: "p8" }).kind.should eql(:perm)
+      Right.find_by(name: "p8").kind.should eql(:perm)
     end
 
     it "should work on edit" do
+      Right.create(:name => "p8")
       pm = Right.where(name: "p8").first
       pm.kind = :temp
       pm.save
@@ -305,6 +316,19 @@ describe "Symbolize" do
 
   end
 
+  describe "Default Values" do
+
+    it "should use default value on object build" do
+      Right.new.kind.should eql(:perm)
+    end
+
+    it "should use default value in string" do
+      Project.new.state.should eql('active')
+    end
+
+  end
+
+
   describe "Scopes" do
     it "should work under scope" do
       # Person.with_scope({ :status => :inactive }) do
@@ -330,7 +354,9 @@ describe "Symbolize" do
     end
 
     describe "dirty tracking / changed flag" do
+
       before do
+        Person.create!(:name => 'Anna', :other => :fo, :status => :active  , :so => :linux, :gui => :qt, :language => :pt, :sex => true, :cool => true)
         @anna = Person.where(name: 'Anna').first
       end
 
@@ -351,10 +377,9 @@ describe "Symbolize" do
         return_value.should == :pt
         @anna.language_changed?.should be_false
       end
-    end
 
+    end
 
   end
 
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: symbolize
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-31 00:00:00.000000000 Z
+date: 2013-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
-  requirement: &16099800 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,15 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *16099800
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &16097600 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,21 +37,31 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *16097600
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &16110420 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 3.1.0
   type: :development
   prerelease: false
-  version_requirements: *16110420
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &16107460 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +69,15 @@ dependencies:
         version: 1.5.0
   type: :development
   prerelease: false
-  version_requirements: *16107460
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &16106020 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +85,15 @@ dependencies:
         version: 1.3.0
   type: :development
   prerelease: false
-  version_requirements: *16106020
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &16121220 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,18 +101,28 @@ dependencies:
         version: 0.12.2
   type: :development
   prerelease: false
-  version_requirements: *16121220
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.2
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &16119380 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.2.1
   type: :development
   prerelease: false
-  version_requirements: *16119380
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.1
 description: ActiveRecord/Mongoid enums with i18n
 email: x@nofxx.com
 executables: []
@@ -102,7 +137,6 @@ files:
 - spec/spec_helper_ar.rb
 - spec/locales/en.yml
 - spec/locales/pt.yml
-- spec/symbolize_spec.rb
 - spec/spec_helper_mongoid.rb
 - spec/spec_helper.rb
 - spec/symbolize/mongoid_spec.rb
@@ -124,7 +158,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4056837590363536346
+      hash: -669350637973584292
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -133,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Object enums with i18n in AR or Mongoid

data/spec/symbolize_spec.rb

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.dirname(__FILE__) + '/spec_helper'
-
-
-describe "Symbolize" do
-
-
-end