symbolize 4.0.2 → 4.0.3

data/README.rdoc

@@ -1,6 +1,7 @@
 = 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
+This plugin introduces an easy way to use symbols for values of attributes.
+Symbolized attributes return a ruby symbol (or nil) as their value
 and can be set using :symbols or "strings".
 
 == Install
@@ -23,28 +24,21 @@ and can be set using :symbols or "strings".
 
 == About
 
-Simply add "symbolize :attr_name" to your model class, and the specified
-attribute will return symbol values and can be set using smbols (setting
-string values will still work, which is important when using forms).
-
-On SQL-based DBs, an attribute to symbolize should be a string (varchar) column in the database.
+Just use "symbolize :attribute" in your model, and the specified
+attribute will return symbol values and can be set using symbols
+(setting string values works, which is important when using forms).
 
+On schema DBs, the attribute should be a string (varchar) column.
 
 
 == Usage
 
-Add "symbolize :attr_name" to your model class. You may also want to add
-validates_inclusion_of to restrict the possible values (just like an enum).
 
-    # ActiveRecord
     class User < ActiveRecord::Base
-
-    # Mongoid
-    class User
-      include Mongoid::Document
-      include Mongoid::Symbolize
+      or Mongoid::Document
 
       symbolize :gender, :in => [:female, :male], :scopes => true
+
       symbolize :so, :in => {
         :linux   => "Linux",
         :mac     => "Mac OS X"
@@ -60,17 +54,18 @@ validates_inclusion_of to restrict the possible values (just like an enum).
       symbolize :angry, :in => [true, false], :scopes => true
 
       # Don`t validate
-      symbolize :lang, :in => [:ruby, :c, :erlang], :validate => false
+      symbolize :lang, :in => [:ruby, :js, :c, :erlang], :validate => false
 
       # Default
-      symbolize :kind, :in => [:admin, :manager, :user], :default => :admin
-  end
+      symbolize :kind, :in => [:admin, :manager, :user], :default => :user
+
+    end
 
 
 === in/within
 
-The values allowed on the enum field, you can provide a hash with
-{:value => "Human text"} or an array of keys to be i18n eval (or not).
+The values allowed on the enum field, you can provide a hash like
+{:value => "Human text"} or an array of keys to run i18n on.
 Booleans are also supported. See below.
 
 allow_(blank|nil): What you expect.
@@ -108,6 +103,8 @@ Its possible to use boolean fields also.
 If you don`t provide a hash with values, it will try i18n:
 
     activerecord:
+    or
+    mongoid:
       attributes:
         user:
           enums:
@@ -119,20 +116,27 @@ If you don`t provide a hash with values, it will try i18n:
               female: Girl
               male: Boy
 
+
 You can skip i18n lookup with :i18n => false
-  symbolize :gender, :in => [:female, :male], :i18n => false
 
+    symbolize :style, :in => [:rock, :punk, :funk, :jazz], :i18n => false
 
-=== scopes (BETA)
+
+=== scopes
 
 If you provide the scopes option, some fancy named scopes will be added:
-In our User example, gender has this option, so you can do:
+In our User example, gender has male/female options, so you can do:
+
+    # AR
+    User.male    # => User.all(:conditions => { :gender => :male })
+
+    # Mongoid
+    User.female  # => User.where({ :gender => :female })
 
-    User.female => User.find(:all, :conditions => { :gender => :female })
 
 You can chain named scopes as well:
 
-    User.female.mac => User.find(:all, :conditions => { :gender => :female, :so => :mac })
+    User.female.mac => User.all :conditions => { :gender => :female, :so => :mac }
 
 For boolean colums you can use
 
@@ -142,50 +146,36 @@ For boolean colums you can use
     ( or with_[attribute] and without_[attribute] )
 
 
-=== default (BETA)
-
-As the name suggest, the symbol you choose as default will be set in new objects automatically.
-
-     User.new.kind # Will print :admin
-
+=== default
 
-== Examples
+As the name suggest, the symbol you choose as default will be set
+in new objects automatically. Mongoid only for now.
 
-  u = User.find_by_name('Anna')   # => #<User Anna>
-  u.gender                        # => :female
+    symbolize :mood, :in => [:happy, :sad, :euphoric], :default => (MarvinDay ? :sad : :happy)
 
-  u = User.find_by_gender(:male)  # => #<User Bob>
-  u.gender                        # => :male
+    User.new.kind # It may print :happy
 
-  u = User.find(:all, :conditions => { :gender => :female })
-  u = User.female
-
-  u = User.new(:name => 'ET', :gender => :unknown)
-  u.save                          # => validation fails
 
 == Rails Form Example
 
+You may call `Class.get_<attribute>_values` anywhere to get a nice array.
+Works nice with dropdowns. Examples:
+
     class Coffee
       symbolize :genetic, :in => [:arabica, :robusta, :blend]
     end
 
-    form_for(@coffee) do |f|
+    - form_for(@coffee) do |f|
       = f.label :genetic
       = f.select :genetic, Coffee.get_genetic_values
 
-== Model Helpers
-
-
-You may call `Class.get_attr_values` anywhere to get a nice array.
-Works nice with dropdowns. Examples:
-
-
 Somewhere on a view:
 
     = select_tag :kind, Coffee.get_genetic_values
 
 
-== View Helpers
+== View Helpers (DEPRECATED)
+
 
   <% form_for @user do |f| %>
     <%= f.radio_sym "gender" %>
@@ -193,40 +183,7 @@ Somewhere on a view:
     <%= f.select_sym "so" %>
     <!-- Fixed order -->
     <%= f.select_sym "office" %>
-  <% end %>
-
-  output:
-
-  <form action="users/1" method="post">
-    <div style="margin:0;padding:0">...</div>
-    <label>Female <input id="user_gender_female" name="user[gender]" type="radio" value="female"></label>
-    <label>Male <input checked="checked" id="user_gender_male" name="user[gender]" type="radio" value="male" ></label>
-    <!-- Alphabetic order -->
-    <select id="user_so" name="post[so]">
-      <option value="linux" selected="selected">Linux</option>
-      <option value="mac">Mac OS X</option>
-      <option value="windows">Windows XP</option>
-    </select>
-    <!-- Fixed order -->
-    <select id="user_office" name="post[office]">
-      <option value="kde" selected="selected">Koffice</option>
-      <option value="ms">Microsoft Office</option>
-      <option value="open">Open Office</option>
-    </select>
-  </form>
-
-
-
-=== Plugin:
-
-Try at your own risk.
-
-  rails plugin install git://github.com/nofxx/symbolize.git
-
-
-== Rails 3.1 (beta)
-
-Specs pass with rails 3, but a scope :public == fail.
+  <%end>
 
 
 == Specs

data/Rakefile

@@ -1,24 +1,33 @@
-require 'rubygems'
-require 'rake'
-#require 'spec/rake/spectask'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "symbolize"
-    gem.summary = "Object enums with i18n in AR or Mongoid"
-    gem.description = "ActiveRecord/Mongoid enums with i18n"
-    gem.email = "x@nofxx.com"
-    gem.homepage = "http://github.com/nofxx/symbolize"
-    gem.authors = ["Marcos Piccinini"]
-    gem.add_development_dependency "rspec"
-    gem.add_development_dependency "sqlite3"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+require "rspec"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
 end
 
+task :default => [:spec]
+
+# require 'rubygems'
+# require 'rake'
+# #require 'spec/rake/spectask'
+
+# begin
+#   require 'jeweler'
+#   Jeweler::Tasks.new do |gem|
+#     gem.name = "symbolize"
+#     gem.summary = "Object enums with i18n in AR or Mongoid"
+#     gem.description = "ActiveRecord/Mongoid enums with i18n"
+#     gem.email = "x@nofxx.com"
+#     gem.homepage = "http://github.com/nofxx/symbolize"
+#     gem.authors = ["Marcos Piccinini"]
+#     gem.add_development_dependency "rspec"
+#     gem.add_development_dependency "sqlite3"
+#     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+#   end
+# rescue LoadError
+#   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+# end
+
 # Spec::Rake::SpecTask.new(:spec) do |spec|
 #   spec.libs << 'lib' << 'spec'
 #   spec.spec_files = FileList['spec/**/*_spec.rb']
@@ -39,17 +48,17 @@ end
 #   rdoc.rdoc_files.include('README')
 #   rdoc.rdoc_files.include('lib/**/*.rb')
 # end
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION.yml')
-    config = YAML.load(File.read('VERSION.yml'))
-    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
-  else
-    version = ""
-  end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "symbolize #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+# require 'rdoc/task'
+# Rake::RDocTask.new do |rdoc|
+#   if File.exist?('VERSION.yml')
+#     config = YAML.load(File.read('VERSION.yml'))
+#     version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+#   else
+#     version = ""
+#   end
+
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title = "symbolize #{version}"
+#   rdoc.rdoc_files.include('README*')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end

data/lib/symbolize/active_record.rb

@@ -89,8 +89,9 @@ module Symbolize
 
           if methods
             values.each do |value|
-              define_method("#{value[0]}?") do
-                self.send(attr_name) == value[0]
+              key = value[0]
+              define_method("#{key}?") do
+                self[attr_name] == key
               end
             end
           end
@@ -111,10 +112,14 @@ module Symbolize
               end
             end
           end
-        end
 
-        if validation
-          class_eval "validates_inclusion_of :#{attr_names.join(', :')}, #{configuration.inspect}"
+          if validation
+            validation = "validates_inclusion_of :#{attr_names.join(', :')}"
+            validation += ", :in => #{values.keys.inspect}"
+            validation += ", :allow_nil => true" if configuration[:allow_nil]
+            validation += ", :allow_blank => true" if configuration[:allow_blank]
+            class_eval validation
+          end
         end
       end
 
@@ -170,25 +175,4 @@ module Symbolize
   end
 end
 
-# The Symbol class is extended by method quoted_id which returns a string.
-# The idea behind this is, that symbols are converted to plain strings
-# when being quoted by ActiveRecord::ConnectionAdapters::Quoting#quote.
-# This makes it possible to work with symbolized attibutes in sql conditions.
-# E.g. validates_uniqueness_of could not use :scope with a symbolized
-# attribute, because AR quotes it to YAML:
-#  "... AND status = '--- :active\n'"
-# Having support for quoted_id in Symbol, makes AR quoting symbols correctly:
-#  "... AND status = 'active'"
-# NOTE: Normally quoted_id should be implemented as a singleton method
-#       only used on symbols returned by read_and_symbolize_attribute,
-#       but unfortunately this is not possible since Symbol is an immediate
-#       value and therefore does not support singleton methods.
-# class Symbol
-#   def quoted_id
-#     # A symbol can contain almost every character (even a backslash or an
-#     # apostrophe), so make sure to properly quote the string value here.
-#     "'#{ActiveRecord::Base.connection.quote_string(self.to_s)}'"
-#   end
-# end
-
-ActiveRecord::Base.send(:include, Symbolize) if ActiveRecord::VERSION::MAJOR >= 3
+ActiveRecord::Base.send(:include, Symbolize)

data/lib/symbolize/mongoid.rb

@@ -63,16 +63,16 @@ module Mongoid
         default_opt = 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
+            # attr_name = attr_name.to_s
 
-            # Builds Mongoid 'field :name, type: type, :default
-            type    = ", type: Symbol"
-            default = ", default: :#{default_opt}" if default_opt
-            class_eval("field :#{attr_name} #{type} #{default}")
+            #
+            # Builds Mongoid 'field :name, type: type, :default'
+            #
+            mongo_opts  = ", :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)
@@ -108,65 +108,39 @@ module Mongoid
               scope_comm = lambda { |*args|  scope(*args)}
               values.each do |value|
                 if value[0].respond_to?(:to_sym)
-                  scope_comm.call value[0].to_sym, :conditions => { attr_name => value[0].to_sym }
+                  scope_comm.call value[0].to_sym, where({ attr_name => value[0].to_sym })
                 end
               end
             end
 
             if validation
-              class_eval "validates_inclusion_of :#{attr_names.join(', :')}, #{configuration.inspect}"
+              validation = "validates_inclusion_of :#{attr_names.join(', :')}"
+              validation += ", :in => #{values.keys.inspect}"
+              validation += ", :allow_nil => true" if configuration[:allow_nil]
+              validation += ", :allow_blank => true" if configuration[:allow_blank]
+              class_eval validation
             end
           end
         end
 
+        #
+        # Creates <attribute>_text helper, human text for attribute.
+        #
         attr_names.each do |attr_name|
-
-          # if default_option
-          #   class_eval("def #{attr_name}; read_and_symbolize_attribute('#{attr_name}') || :#{default_option}; end")
-          #   class_eval("def #{attr_name}= (value); write_symbolized_attribute('#{attr_name}', value); end")
-          #   class_eval("def set_default_for_attr_#{attr_name}; self[:#{attr_name}] ||= :#{default_option}; end")
-          #   class_eval("before_save :set_default_for_attr_#{attr_name}")
-          # else
-          #   class_eval("def #{attr_name}; read_and_symbolize_attribute('#{attr_name}'); end")
-          #   class_eval("def #{attr_name}= (value); write_symbolized_attribute('#{attr_name}', value); end")
-          # end
-          if i18n
-            class_eval("def #{attr_name}_text; read_i18n_attribute('#{attr_name}'); end")
+          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.attributes.#{ActiveSupport::Inflector.underscore(self.class)}.enums.#{attr_name}.#{attr}")
+            end
           elsif enum
             class_eval("def #{attr_name}_text; #{attr_name.to_s.upcase}_VALUES[#{attr_name}]; end")
           else
             class_eval("def #{attr_name}_text; #{attr_name}.to_s; end")
           end
         end
-      end
-    end
-
-    # String becomes symbol, booleans string and nil nil.
-    # def symbolize_attribute attr
-    #   case attr
-    #   when String then attr.empty? ? nil : attr.to_sym
-    #   when Symbol, TrueClass, FalseClass, Numeric then attr
-    #   else nil
-    #   end
-    # end
-
-    # # Return an attribute's value as a symbol or nil
-    # def read_and_symbolize_attribute attr_name
-    #   symbolize_attribute self[attr_name]
-    # end
 
-    # Return an attribute's i18n
-    def read_i18n_attribute attr_name
-      return nil unless attr = read_attribute(attr_name)
-      I18n.translate("mongoid.attributes.#{ActiveSupport::Inflector.underscore(self.class)}.enums.#{attr_name}.#{attr}") #.to_sym rescue nila
-    end
-
-    # # Write a symbolized value. Watch out for booleans.
-    # def write_symbolized_attribute attr_name, value
-    #   val = { "true" => true, "false" => false }[value]
-    #   val = symbolize_attribute(value) if val.nil?
+      end
 
-    #   self[attr_name] = val #.to_s # rails 3.1 fix
-    # end
-  end
-end
+    end # ClassMethods
+  end # Symbolize
+end # Mongoid

data/lib/symbolize/version.rb

@@ -0,0 +1,3 @@
+module Symbolize
+  VERSION = '4.0.3'
+end

data/spec/locales/pt.yml

@@ -14,9 +14,9 @@ pt:
           kind:
             magic: Mágica
             agility: Agilidade
-  models:
+  mongoid:
     attributes:
-      user:
+      person:
         enums:
           language:
             pt: Português
@@ -24,7 +24,7 @@ pt:
           sex:
             "true": Feminino
             "false": Masculino
-      user_skill:
+      person_skill:
         enums:
           kind:
             magic: Mágica

data/spec/spec_helper.rb

@@ -8,8 +8,7 @@ require 'pry'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'action_controller'
-require 'action_view'
+require 'i18n'
 
 
 I18n.load_path += Dir[File.join(File.dirname(__FILE__), "locales", "*.{rb,yml}")]

data/spec/spec_helper_mongoid.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 require 'mongoid'
 
 Mongoid.configure do |config|
-  config.master = Mongo::Connection.new.db("symboliz")
+  config.master = Mongo::Connection.new.db("symbolize_#{Time.now.to_i}")
 end
 
 require 'symbolize/mongoid'

data/spec/symbolize/active_record_spec.rb

@@ -177,43 +177,6 @@ describe "Symbolize" do
       new_extra.should_not be_valid
     end
 
-
-
-    describe "View helpers" do
-      include ActionView::Helpers::FormHelper
-      include ActionView::Helpers::FormOptionsHelper
-
-      before(:each) do
-        @options_status = [['Active', :active], ['Inactive', :inactive]]
-        @options_gui    = [["cocoa", :cocoa], ["qt", :qt], ["gtk", :gtk]]
-        @options_so     = [["Linux", :linux]  , ["Mac OS X", :mac], ["Videogame", :win]]
-      end
-
-      it "test_helper_select_sym" do
-        @user.status = :inactive
-        output = "<select id=\"user_status\" name=\"user[status]\">#{options_for_select(@options_status, @user.status)}</select>"
-        output.should eql(select_sym("user", "status", nil))
-
-
-        output = "<select id=\"user_status\" name=\"user[status]\">#{options_for_select(@options_status, @user.status)}</select>"
-        output.should eql(select_sym("user", "status", nil))
-      end
-
-      def test_helper_select_sym_order
-        output_so     = "<select id=\"user_so\" name=\"user[so]\">#{options_for_select(@options_so, @user.so)}</select>"
-        output_office = "<select id=\"user_office\" name=\"user[office]\">#{options_for_select(@options_office, @user.office)}</select>"
-
-        assert_equal output_so, select_sym("user", "so", nil)
-        assert_equal output_office, select_sym("user", "office", nil)
-      end
-
-      def test_helper_radio_sym
-        output = radio_sym("user", "status", nil)
-        assert_equal("<label>Active: <input checked=\"checked\" id=\"user_status_active\" name=\"user[status]\" type=\"radio\" value=\"active\" /></label><label>Inactive: <input id=\"user_status_inactive\" name=\"user[status]\" type=\"radio\" value=\"inactive\" /></label>", output)
-      end
-
-    end
-
     describe "i18n" do
 
       it "should test i18n ones" do
@@ -387,13 +350,12 @@ describe "Symbolize" do
           @anna.language_changed?.should be_true
         end
 
-        it "is not dirty if you set the attribute value to the same value it was originally" do
+        it "is not dirty if you set the attribute value to the same value" do
           @anna.language.should == :pt
           @anna.language_changed?.should be_false
 
           return_value = @anna.language = :pt
           return_value.should == :pt
-          p @anna.changes
           @anna.language_changed?.should be_false
         end
       end

data/spec/symbolize/mongoid_spec.rb

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
-require File.dirname(__FILE__) + '/../spec_helper_mongoid'
+require 'spec_helper_mongoid'
 
 #
 # Test model
-class User
+class Person
   include Mongoid::Document
   include Mongoid::Symbolize
 
@@ -17,28 +17,32 @@ class User
     :win   => 'Videogame'
   }, :scopes => true
   symbolize :gui, :allow_blank => true, :in => [:cocoa, :qt, :gtk], :i18n => false
-  symbolize :karma, :in => %w{ good bad ugly}, :methods => true, :i18n => false, :allow_nil => true
+  symbolize :karma, :in => %w{good bad ugly}, :methods => true, :i18n => false, :allow_nil => true
+  symbolize :planet, :in => %w{earth centauri tatooine}, :default => :earth
  # symbolize :cool, :in => [true, false], :scopes => true
 
-  has_many :extras, :dependent => :destroy, :class_name => "UserExtra"
-  embeds_many :skills, :class_name => "UserSkill"
+  has_many :rights, :dependent => :destroy
+  has_many :extras, :dependent => :destroy, :class_name => "PersonExtra"
+  embeds_many :skills, :class_name => "PersonSkill"
 end
 
-class UserSkill
+class PersonSkill
   include Mongoid::Document
   include Mongoid::Symbolize
+  embedded_in :person, :inverse_of => :skills
 
   symbolize :kind, :in => [:agility, :magic]
 end
 
-class UserExtra
+class PersonExtra
   include Mongoid::Document
   include Mongoid::Symbolize
+  belongs_to :person, :inverse_of => :extras
 
   symbolize :key, :in => [:one, :another]
 end
 
-class Permission
+class Right
   include Mongoid::Document
   include Mongoid::Symbolize
 
@@ -46,208 +50,177 @@ class Permission
   symbolize :kind, :in => [:temp, :perm], :default => :perm
 end
 
-[User, UserExtra, UserSkill, Permission].each { |k| k.destroy_all }
-
-# Test records
-User.create(:name => 'Anna', :other => :fo, :status => :active  , :so => :linux, :gui => :qt, :language => :pt, :sex => true, :cool => true)
-User.create!(:name => 'Bob' , :other => :bar,:status => :inactive, :so => :mac, :gui => :gtk, :language => :en, :sex => false, :cool => false)
-
-
 describe "Symbolize" do
 
   it "should be a module" do
     Mongoid.const_defined?("Symbolize").should be_true
   end
 
-  describe "User Instantiated" do
-    before(:each) do
-      @user = User.first
-    end
+  it "should instantiate" do
+    anna = Person.create(:name => 'Anna', :so => :mac, :gui => :cocoa, :language => :pt, :status => :active)
+    anna.should be_valid
+    # anna.errors.messages.should eql({})
+  end
+
+  describe "Person Instantiated" do
+    let(:person) { Person.create(:name => 'Anna', :other => :fo, :status => :active  , :so => :linux, :gui => :qt, :language => :pt, :sex => true, :cool => true) }
 
     it "test_symbolize_string" do
-      @user.status = 'inactive'
-      @user.status.should eql(:inactive)
-      #      @user.status_before_type_cast.should eql(:inactive)
-      # @user.read_attribute(:status).should eql('inactive')
+      person.status = 'inactive'
+      person.status.should eql(:inactive)
+      person.read_attribute(:status).should eql(:inactive)
     end
 
     it "test_symbolize_symbol" do
-      @user.status = :active
-      @user.status.should eql(:active)
-      @user.save
-      @user.status.should eql(:active)
-      @user[:status].should eql(:active)
+      person.status = :active
+      person.status.should eql(:active)
+      person.save
+      person.status.should eql(:active)
+      person[:status].should eql(:active)
     end
 
     # it "should work nice with numbers" do
     #   pending
-    #   @user.status = 43
-    #   @user.status.should_not be_nil
-    #   # @user.status_before_type_cast.should be_nil
-    #   # @user.read_attribute(:status).should be_nil
+    #   person.status = 43
+    #   person.status.should_not be_nil
+    #   # person.status_before_type_cast.should be_nil
+    #   # person.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
+    #   person.status = nil
+    #   person.status.should be_nil
+    #   person.status_before_type_cast.should be_nil
+    #   person.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
+    #   person.status = ""
+    #   person.status.should be_nil
+    #   person.status_before_type_cast.should be_nil
+    #   person.read_attribute(:status).should be_nil
     # end
 
     it "should not validates other" do
-      @user.other = nil
-      @user.should be_valid
-      @user.other = ""
-      @user.should be_valid
+      person.other = nil
+      person.should be_valid
+      person.other = ""
+      person.should be_valid
     end
 
     it "should get the correct values" do
-      User.get_status_values.should eql([["Active", :active],["Inactive", :inactive]])
-      User::STATUS_VALUES.should eql({:inactive=>"Inactive", :active=>"Active"})
+      Person.get_status_values.should eql([["Active", :active],["Inactive", :inactive]])
+      Person::STATUS_VALUES.should eql({ inactive: "Inactive", active: "Active"})
     end
 
     it "test_symbolize_humanize" do
-      @user.status_text.should eql("Active")
+      person.status_text.should eql("Active")
     end
 
     it "should get the correct values" do
-      User.get_gui_values.should =~ [["cocoa", :cocoa], ["qt", :qt], ["gtk", :gtk]]
-      User::GUI_VALUES.should eql({:cocoa=>"cocoa", :qt=>"qt", :gtk=>"gtk"})
+      Person.get_gui_values.should =~ [["cocoa", :cocoa], ["qt", :qt], ["gtk", :gtk]]
+      Person::GUI_VALUES.should eql({cocoa: "cocoa",  qt: "qt",  gtk: "gtk"})
     end
 
     it "test_symbolize_humanize" do
-      @user.gui_text.should eql("qt")
+      person.gui_text.should eql("qt")
     end
 
     it "should get the correct values" do
-      User.get_so_values.should =~ [["Linux", :linux], ["Mac OS X", :mac], ["Videogame", :win]]
-      User::SO_VALUES.should eql({:linux => "Linux", :mac => "Mac OS X", :win => "Videogame"})
+      Person.get_so_values.should =~ [["Linux", :linux], ["Mac OS X", :mac], ["Videogame", :win]]
+      Person::SO_VALUES.should eql({linux: "Linux", mac: "Mac OS X", win: "Videogame"})
     end
 
     it "test_symbolize_humanize" do
-      @user.so_text.should eql("Linux")
+      person.so_text.should eql("Linux")
     end
 
     it "test_symbolize_humanize" do
-      @user.so = :mac
-      @user.so_text.should eql("Mac OS X")
+      person.so = :mac
+      person.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")
+      person.other_text.should eql("fo")
+      person.other = :foo
+      person.other_text.should eql("foo")
     end
 
     it "should validate status" do
-      @user.status = nil
-      @user.should_not be_valid
-      @user.should have(1).errors
+      person.status = nil
+      person.should_not be_valid
+      person.should have(1).errors
     end
 
     it "should not validate so" do
-      @user.so = nil
-      @user.should be_valid
+      person.so = nil
+      person.should be_valid
     end
 
-    it "test_symbols_with_weird_chars_quoted_id" do
-      @user.status = :"weird'; chars"
-      @user.status.should eql(:"weird'; chars")
+    it "should work with weird chars" do
+      person.status = :"weird'; chars"
+      person.status.should eql(:"weird'; chars")
     end
 
     it "should work fine through relations" do
-      @user.extras.create(:key => :one)
-      UserExtra.first.key.should eql(:one)
+      person.extras.create(:key => :one)
+      PersonExtra.first.key.should eql(:one)
+    end
+
+    it "should work fine through embeds" do
+      person.skills.create(:kind => :magic)
+      person.skills.first.kind.should eql(:magic)
     end
 
     # it "should play fine with null db columns" do
-    #   new_extra = @user.extras.build
+    #   new_extra = person.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 = person.extras.build
     #   new_extra.should_not be_valid
     # end
 
+    it "should default planet to earth" do
+      Person.new.planet.should eql(:earth)
+    end
 
 
-    # describe "View helpers" do
-    #   include ActionView::Helpers::FormHelper
-    #   include ActionView::Helpers::FormOptionsHelper
-
-    #   before(:each) do
-    #     @options_status = [['Active', :active], ['Inactive', :inactive]]
-    #     @options_gui    = [["cocoa", :cocoa], ["qt", :qt], ["gtk", :gtk]]
-    #     @options_so     = [["Linux", :linux]  , ["Mac OS X", :mac], ["Videogame", :win]]
-    #   end
-
-    #   it "test_helper_select_sym" do
-    #     @user.status = :inactive
-    #     output = "<select id=\"user_status\" name=\"user[status]\">#{options_for_select(@options_status, @user.status)}</select>"
-    #     output.should eql(select_sym("user", "status", nil))
-
-
-    #     output = "<select id=\"user_status\" name=\"user[status]\">#{options_for_select(@options_status, @user.status)}</select>"
-    #     output.should eql(select_sym("user", "status", nil))
-    #   end
-
-    #   def test_helper_select_sym_order
-    #     output_so     = "<select id=\"user_so\" name=\"user[so]\">#{options_for_select(@options_so, @user.so)}</select>"
-    #     output_office = "<select id=\"user_office\" name=\"user[office]\">#{options_for_select(@options_office, @user.office)}</select>"
-
-    #     assert_equal output_so.should, select_sym("user", "so", nil)
-    #     assert_equal output_office, select_sym("user", "office", nil)
-    #   end
-
-    #   def test_helper_radio_sym
-    #     output = radio_sym("user", "status", nil)
-    #     assert_equal("<label>Active: <input checked=\"checked\" id=\"user_status_active\" name=\"user[status]\" type=\"radio\" value=\"active\" /></label><label>Inactive: <input id=\"user_status_inactive\" name=\"user[status]\" type=\"radio\" value=\"inactive\" /></label>", output)
-    #   end
-
-    # end
-
     describe "i18n" do
 
       it "should test i18n ones" do
-        @user.language_text.should eql("Português")
+        person.language_text.should eql("Português")
       end
 
       it "should get the correct values" do
-        User.get_language_values.should =~ [["Português", :pt], ["Inglês", :en]]
+        Person.get_language_values.should =~ [["Português", :pt], ["Inglês", :en]]
       end
 
       it "should get the correct values" do
-        User::LANGUAGE_VALUES.should eql({:pt=>"pt", :en=>"en"})
+        Person::LANGUAGE_VALUES.should eql({:pt=>"pt", :en=>"en"})
       end
 
       # it "should test boolean" do
-      #   @user.sex_text.should eql("Feminino")
+      #   person.sex_text.should eql("Feminino")
       # end
 
       # it "should get the correct values" do
-      #   User.get_sex_values.should eql([["Feminino", true],["Masculino", false]])
+      #   Person.get_sex_values.should eql([["Feminino", true],["Masculino", false]])
       # end
 
       # it "should get the correct values" do
-      #   User::SEX_VALUES.should eql({true=>"true", false=>"false"})
+      #   Person::SEX_VALUES.should eql({true=>"true", false=>"false"})
       # end
 
-      it "should translate a multiword class" do
-        @skill = UserSkill.create(:kind => :magic)
-        @skill.kind_text.should eql("Mágica")
+      it "should translate a multiword classname" do
+        skill = PersonSkill.new(:kind => :magic)
+        skill.kind_text.should eql("Mágica")
       end
 
       it "should return nil if there's no value" do
-        @skill = UserSkill.create(:kind => nil)
-        @skill.kind_text.should be_nil
+        skill = PersonSkill.new(:kind => nil)
+        skill.kind_text.should be_nil
       end
 
     end
@@ -255,53 +228,53 @@ describe "Symbolize" do
     describe "Methods" do
 
       it "should play nice with other stuff" do
-        @user.karma.should be_nil
-        User::KARMA_VALUES.should eql({:bad => "bad", :ugly => "ugly", :good => "good"})
+        person.karma.should be_nil
+        Person::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
+        person.should_not be_good
+        person.karma = :ugly
+        person.should be_ugly
       end
 
       it "should work" do
-        @user.karma = "good"
-        @user.should be_good
-        @user.should_not be_bad
+        person.karma = "good"
+        person.should be_good
+        person.should_not be_bad
       end
 
     end
 
   end
 
-  describe "more tests on Permission" do
+  describe "more tests on Right" do
 
     it "should use default value on object build" do
-      Permission.new.kind.should eql(:perm)
+      Right.new.kind.should eql(:perm)
     end
 
     it "should not interfer on create" do
-      Permission.create!(:name => "p7", :kind => :temp)
-      Permission.where(name: "p7").first.kind.should eql(:temp)
+      Right.create!(:name => "p7", :kind => :temp)
+      Right.where(name: "p7").first.kind.should eql(:temp)
     end
 
     it "should work on create" do
-      pm = Permission.new(:name => "p7")
+      pm = Right.new(:name => "p7")
       pm.should be_valid
       pm.save.should be_true
     end
 
     it "should work on create" do
-      Permission.create(:name => "p8")
-      Permission.first(conditions: { name: "p8" }).kind.should eql(:perm)
+      Right.create(:name => "p8")
+      Right.first(conditions: { name: "p8" }).kind.should eql(:perm)
     end
 
     it "should work on edit" do
-      pm = Permission.where(name: "p8").first
+      pm = Right.where(name: "p8").first
       pm.kind = :temp
       pm.save
-      Permission.where(name: "p8").first.kind.should eql(:temp)
+      Right.where(name: "p8").first.kind.should eql(:temp)
     end
 
   end
@@ -309,19 +282,21 @@ describe "Symbolize" do
   describe "Mongoid stuff" do
 
     it "test_symbolized_finder" do
-      User.where({ :status => :inactive }).all.map(&:name).should eql(['Bob'])
-      User.where(status: :inactive).map(&:name).should eql(['Bob'])
+      Person.create(:name => 'Bob' , :other => :bar, :status => :inactive, :so => :mac, :gui => :gtk, :language => :en, :sex => false, :cool => false)
+
+      Person.where({ :status => :inactive }).all.map(&:name).should eql(['Bob'])
+      Person.where(status: :inactive).map(&:name).should eql(['Bob'])
     end
 
-    # it "test_symabolized_with_scope" do
-    #   User.with_scope({ :status => :inactive }) do
-    #     User.all.map(&:name).should eql(['Bob'])
+    # it "should work under scope" do
+    #   Person.with_scope({ :status => :inactive }) do
+    #     Person.all.map(&:name).should eql(['Bob'])
     #   end
     # end
 
     describe "dirty tracking / changed flag" do
       before do
-        @anna = User.where(name: 'Anna').first
+        @anna = Person.where(name: 'Anna').first
       end
 
       it "is dirty if you change the attribute value" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 4
   - 0
-  - 2
-  version: 4.0.2
+  - 3
+  version: 4.0.3
 platform: ruby
 authors: 
 - Marcos Piccinini
@@ -14,64 +14,94 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-29 00:00:00 -03:00
+date: 2011-10-15 23:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: i18n
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        version: "0"
+        - 6
+        - 0
+        version: 0.6.0
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: sqlite3
+  name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
+        - 2
+        - 6
         - 0
-        version: "0"
+        version: 2.6.0
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 1
+        version: 2.3.1
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: active_record
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 1
+        - 1
+        version: 3.1.1
+  type: :development
+  version_requirements: *id004
 description: ActiveRecord/Mongoid enums with i18n
 email: x@nofxx.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
-- .document
-- MIT-LICENSE
-- README.rdoc
-- Rakefile
-- VERSION
 - lib/symbolize.rb
 - lib/symbolize/active_record.rb
 - lib/symbolize/mongoid.rb
+- lib/symbolize/version.rb
 - lib/symbolize/railtie.rb
-- lib/symbolize/symbolize_helper.rb
-- spec/db/001_create_testing_structure.rb
-- spec/locales/en.yml
-- spec/locales/pt.yml
+- spec/spec_helper_mongoid.rb
 - spec/spec_helper.rb
+- spec/symbolize_spec.rb
 - spec/spec_helper_ar.rb
-- spec/spec_helper_mongoid.rb
 - spec/symbolize/active_record_spec.rb
 - spec/symbolize/mongoid_spec.rb
-- spec/symbolize_spec.rb
-- symbolize.gemspec
+- spec/db/001_create_testing_structure.rb
+- spec/locales/pt.yml
+- spec/locales/en.yml
+- README.rdoc
+- Rakefile
 has_rdoc: true
 homepage: http://github.com/nofxx/symbolize
 licenses: []

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/MIT-LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2007-2008 Andreas Neuhaus <zargony@zargony.com>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION

@@ -1 +0,0 @@
-4.0.2

data/lib/symbolize/symbolize_helper.rb

@@ -1,60 +0,0 @@
-# Goes in lib/meta_tag_helper.rb
-module ActionView
-  module Helpers
-    module FormHelper
-      # helper to create a select drop down list for the symbolize values
-      def select_sym(object, method, choices = nil, options = {}, html_options = {})
-
-        InstanceTag.new(object, method, self, options.delete(:object)).
-          to_select_sym_tag(choices, options, html_options)
-      end
-
-      def radio_sym(object, method, choices = nil, options = {})
-        InstanceTag.new(object, method, self, options.delete(:object)).
-          to_radio_sym_tag(choices, options)
-      end
-    end
-
-    class FormBuilder
-      def select_sym(method, choices = nil, options = {}, html_options = {})
-        @template.select_sym(@object_name, method, choices, objectify_options(options), html_options)
-      end
-
-      def radio_sym(method, choices = nil, options = {})
-        @template.radio_sym(@object_name, method, choices, objectify_options(options))
-      end
-    end
-
-    class InstanceTag
-      # Create a select tag and one option for each of the
-      # symbolize values.
-      def to_select_sym_tag(choices, options, html_options)
-        choices = symbolize_values(choices)
-        to_select_tag(choices, options, html_options)
-      end
-
-      def to_radio_sym_tag(choices, options)
-        choices = symbolize_values(choices)
-        raise ArgumentError, "No values for radio tag" unless choices
-        add_default_name_and_id(options)
-        v = value(object)
-        tag_text = ''
-        template = options.dup
-        template.delete('checked')
-        choices.each do |choice|
-          opts = template.dup
-          opts['checked'] = 'checked' if v and v == choice[1]
-          opts['id'] = "#{opts['id']}_#{choice[1]}"
-          tag_text << "<label>#{choice[0]}: "
-          tag_text << to_radio_button_tag(choice[1], opts)
-          tag_text << "</label>"
-        end
-        tag_text
-      end
-
-      def symbolize_values(choices)
-        choices.nil? ? object.class.send("get_#{@method_name}_values") : choices
-      end
-    end
-  end
-end

data/symbolize.gemspec

@@ -1,61 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{symbolize}
-  s.version = "4.0.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Marcos Piccinini"]
-  s.date = %q{2011-09-29}
-  s.description = %q{ActiveRecord/Mongoid enums with i18n}
-  s.email = %q{x@nofxx.com}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-    "MIT-LICENSE",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "lib/symbolize.rb",
-    "lib/symbolize/active_record.rb",
-    "lib/symbolize/mongoid.rb",
-    "lib/symbolize/railtie.rb",
-    "lib/symbolize/symbolize_helper.rb",
-    "spec/db/001_create_testing_structure.rb",
-    "spec/locales/en.yml",
-    "spec/locales/pt.yml",
-    "spec/spec_helper.rb",
-    "spec/spec_helper_ar.rb",
-    "spec/spec_helper_mongoid.rb",
-    "spec/symbolize/active_record_spec.rb",
-    "spec/symbolize/mongoid_spec.rb",
-    "spec/symbolize_spec.rb",
-    "symbolize.gemspec"
-  ]
-  s.homepage = %q{http://github.com/nofxx/symbolize}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Object enums with i18n in AR or Mongoid}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<sqlite3>, [">= 0"])
-    else
-      s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<sqlite3>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<sqlite3>, [">= 0"])
-  end
-end
-