linki-symbolize 1.1.0

data/.document

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

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+coverage
+rdoc
+doc
+pkg

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+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/README.rdoc

@@ -0,0 +1,187 @@
+= Symbolize attribute values in ActiveRecord (e.g. for nicer enums)
+
+This plugin introduces an easy way to use symbols for values of ActiveRecord
+attributes. Symbolized attributes return a ruby symbol (or nil) as their value
+and can be set using symbols.
+
+
+== About
+
+Since ActiveRecord does not natively support database column types of ENUM or
+SET, you'll usually use a string attribute and restrict it to certain values
+with validations. Using this plugin, the values of such pseudo-enums are
+symbols, which look more ruby-style than strings.
+
+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).
+
+An attribute to symbolize should be a string (varchar) column in the database.
+
+Blog: http://zargony.com/
+Github: http://github.com/zargony/activerecord_symbolize
+
+
+== Install
+
+Gem:
+
+  gem install gemcutter
+  gem tumble
+  gem install symbolize
+  config.gem "symbolize", :source => 'http://gemcutter.org'
+
+
+Plugin:
+
+  ./script/plugin install git://github.com/nofxx/activerecord_symbolize.git
+
+
+== 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).
+
+    class User < ActiveRecord::Base
+      symbolize :gender, :in => [:female, :male], :scopes => true
+      symbolize :so, :in => {
+        :linux   => "Linux",
+        :mac     => "Mac OS X"
+      }, :scopes => true
+      symbolize :gui, , :in => [:gnome, :kde, :xfce], :allow_blank => true
+      symbolize :browser, :in => [:firefox, :opera], :i18n => false, :methods => true
+      symbolize :angry, :in => [true, false], :scopes => true
+  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).
+Booleans are also supported. See below.
+
+allow_(blank|nil): What you expect.
+
+
+=== i18n
+
+If you don`t provide a hash with values, it will try i18n:
+
+    activerecord:
+      attributes:
+        user:
+          enums:
+            gui:
+              gnome: Gnome Desktop Enviroment
+              kde: K Desktop Enviroment
+              xfce: XFCE4
+            gender:
+              female: Girl
+              male: Boy
+
+You can skip i18n lookup with :i18n => false
+  symbolize :gender, :in => [:female, :male], :i18n => false
+
+
+=== method
+
+If you provide the method option, some fancy boolean methods will be added:
+In our User example, browser has this option, so you can do:
+
+    @user.firefox?
+    @user.opera?
+
+
+=== Booleans
+
+Its possible to use boolean fields also.
+  symbolize :switch, :in => [true, false]
+
+  ...
+    switch:
+      "true": On
+      "false": Off
+      "nil": Unknown
+
+
+=== scopes (BETA)
+
+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:
+
+    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 })
+
+For boolean colums you can use
+
+    User.angry     => User.find(:all, :conditions => { :angry => true })
+    User.not_angry => User.find(:all, :conditions => { :angry => false })
+    
+    ( or with_[attribute] and without_[attribute] )
+    
+
+== Examples
+
+  u = User.find_by_name('Anna')   # => #<User Anna>
+  u.gender                        # => :female
+
+  u = User.find_by_gender(:male)  # => #<User Bob>
+  u.gender                        # => :male
+
+  u = User.find(:all, :conditions => { :gender => :female })
+  u = User.female
+
+  u = User.new(:name => 'ET', :gender => :unknown)
+  u.save                          # => validation fails
+
+
+== Examples Helpers
+
+  <% form_for @user do |f| %>
+    <%= f.radio_sym "gender" %>
+    <!-- Alphabetic order -->
+    <%= 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>
+
+
+== Notes
+
+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/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "linki-symbolize"
+    gem.summary = "ActiveRecord enums with i18n"
+    gem.description = "ActiveRecord enums with i18n"
+    gem.email = "m.linkhorst@googlemail.com"
+    gem.homepage = "http://github.com/linki/symbolize"
+    gem.authors = ["Marcos Piccinini", "Martin Linkhorst"]
+    gem.add_development_dependency "rspec"
+  end
+  Jeweler::GemcutterTasks.new
+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']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+task :default => :spec
+
+# desc 'Generate documentation for the activerecord_symbolize plugin.'
+# Rake::RDocTask.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'ActiverecordSymbolize'
+#   rdoc.options << '--line-numbers' << '--inline-source'
+#   rdoc.rdoc_files.include('README')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+require 'rake/rdoctask'
+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/VERSION

@@ -0,0 +1 @@
+1.1.0

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/symbolize.rb

@@ -0,0 +1,176 @@
+module Symbolize
+  def self.included base
+    base.extend(ClassMethods)
+  end
+
+  # Symbolize ActiveRecord attributes. Add
+  #   symbolize :attr_name
+  # to your model class, to make an attribute return symbols instead of
+  # string values. Setting such an attribute will accept symbols as well
+  # as strings. In the database, the symbolized attribute should have
+  # the column-type :string.
+  #
+  # Example:
+  #   class User < ActiveRecord::Base
+  #     symbolize :gender, :in => [:female, :male]
+  #     symbolize :so, :in => {
+  #       :linux   => "Linux",
+  #       :mac     => "Mac OS X"
+  #     }
+  #     symbolize :gui, , :in => [:gnome, :kde, :xfce], :allow_blank => true
+  #     symbolize :browser, :in => [:firefox, :opera], :i18n => false
+  #   end
+  #
+  # It will automattically lookup for i18n:
+  #
+  # activerecord:
+  #   attributes:
+  #     user:
+  #       enums:
+  #         gender:
+  #           female: Girl
+  #           male: Boy
+  #
+  # You can skip i18n lookup with :i18n => false
+  #   symbolize :gender, :in => [:female, :male], :i18n => false
+  #
+  # Its possible to use boolean fields also.
+  #   symbolize :switch, :in => [true, false]
+  #
+  #   ...
+  #     switch:
+  #       "true": On
+  #       "false": Off
+  #       "nil": Unknown
+  #
+  module ClassMethods
+    # Specifies that values of the given attributes should be returned
+    # as symbols. The table column should be created of type string.
+    def symbolize *attr_names
+      configuration = {}
+      configuration.update(attr_names.extract_options!)
+
+      enum = configuration[:in] || configuration[:within]
+      i18n = configuration[:i18n].nil? && !enum.instance_of?(Hash) && enum ? true : configuration[:i18n]
+      methods = configuration[:methods]
+      scopes = configuration[:scopes]
+      validation = configuration[:validation] != false
+
+      unless enum.nil?
+        # Little monkeypatching, <1.8 Hashes aren't ordered.
+        hsh = if RUBY_VERSION > '1.9' || !defined?('ActiveSupport')
+          Hash
+        else
+          ActiveSupport::OrderedHash
+        end
+
+        attr_names.each do |attr_name|
+          attr_name = attr_name.to_s
+          if enum.instance_of?(Hash)
+            values = enum
+          else
+            if i18n
+              values = hsh[*enum.map { |v| [v, I18n.translate("activerecord.attributes.#{ActiveSupport::Inflector.underscore(self)}.enums.#{attr_name}.#{v}")] }.flatten]
+            else
+              values = hsh[*enum.map { |v| [v, (configuration[:capitalize] ? v.to_s.capitalize : v.to_s)] }.flatten]
+            end
+          end
+
+          # Get the values of :in
+          const =  "#{attr_name}_values"
+          const_set const.upcase, values unless const_defined? const.upcase
+          # This one is a dropdown helper
+          class_eval "def self.get_#{const}; #{const.upcase}.map(&:reverse); end"
+
+          if methods
+            values.each do |value|
+              define_method("#{value[0]}?") do
+                self.send(attr_name) == value[0]
+              end
+            end
+          end
+          
+          if scopes
+            values.each do |value|
+              if value[0].respond_to?(:to_sym)
+                named_scope value[0].to_sym, :conditions => { attr_name => value[0].to_sym }
+              else
+                if value[0] == true || value[0] == false
+                  named_scope "with_#{attr_name}", :conditions => { attr_name => true }
+                  named_scope "without_#{attr_name}", :conditions => { attr_name => false }
+                  
+                  named_scope attr_name, :conditions => { attr_name => true }
+                  named_scope "not_#{attr_name}", :conditions => { attr_name => false }                  
+                end
+              end  
+            end
+          end
+        end
+
+        if validation
+          class_eval "validates_inclusion_of :#{attr_names.join(', :')}, configuration"          
+        end
+      end
+
+      attr_names.each do |attr_name|
+        attr_name = attr_name.to_s
+        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")
+        if i18n
+          class_eval("def #{attr_name}_text; read_i18n_attribute('#{attr_name}'); end")
+        elsif enum
+          class_eval("def #{attr_name}_text; #{attr_name.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 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 read_attribute(attr_name)
+  end
+
+  # Return an attribute's i18n
+  def read_i18n_attribute attr_name
+    I18n.translate("activerecord.attributes.#{ActiveSupport::Inflector.underscore(self.class)}.enums.#{attr_name}.#{read_attribute(attr_name)}") #.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?
+    write_attribute(attr_name, val)
+  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

data/lib/symbolize_helper.rb

@@ -0,0 +1,60 @@
+# 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, options, html_options)
+      end
+
+      def radio_sym(method, choices = nil, options = {})
+        @template.radio_sym(@object_name, method, choices, 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/linki-symbolize.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{linki-symbolize}
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcos Piccinini", "Martin Linkhorst"]
+  s.date = %q{2009-12-02}
+  s.description = %q{ActiveRecord enums with i18n}
+  s.email = %q{m.linkhorst@googlemail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/symbolize.rb",
+     "lib/symbolize_helper.rb",
+     "linki-symbolize.gemspec",
+     "rails/init.rb",
+     "spec/db/create_testing_structure.rb",
+     "spec/locales/pt.yml",
+     "spec/spec_helper.rb",
+     "spec/symbolize_spec.rb",
+     "symbolize.gemspec"
+  ]
+  s.homepage = %q{http://github.com/linki/symbolize}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{ActiveRecord enums with i18n}
+  s.test_files = [
+    "spec/db/create_testing_structure.rb",
+     "spec/spec_helper.rb",
+     "spec/symbolize_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/rails/init.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), '..', "lib", "symbolize_helper")
+ActiveRecord::Base.send(:include, Symbolize)

data/spec/db/create_testing_structure.rb

@@ -0,0 +1,18 @@
+class CreateTestingStructure < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name, :so, :gui, :other, :status, :language
+      t.string :limited, :limit => 10
+      t.string :karma, :limit => 5
+      t.boolean :sex
+      t.boolean :public
+    end
+    create_table :user_skills do |t|
+      t.string :kind
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/spec/locales/pt.yml

@@ -0,0 +1,16 @@
+pt:
+  activerecord:
+    attributes:
+      user:
+        enums:
+          language:
+            pt: Português
+            en: Inglês
+          sex:
+            "true": Feminino
+            "false": Masculino
+      user_skill:
+        enums:
+          kind:
+            magic: Mágica
+            agility: Agilidade

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'active_record'
+require 'action_controller'
+require 'action_view'
+require 'symbolize'
+require File.join(File.dirname(__FILE__), '..', 'init')
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+require File.dirname(__FILE__) + "/db/create_testing_structure"
+I18n.load_path += Dir[File.join(File.dirname(__FILE__), "locales", "*.{rb,yml}")]
+I18n.default_locale = "pt"
+CreateTestingStructure.migrate(:up)
+
+
+Spec::Runner.configure do |config|
+
+
+end

data/spec/symbolize_spec.rb

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/spec_helper'
+
+#
+# Test model
+class User < ActiveRecord::Base
+  symbolize :other
+  symbolize :language, :in => [:pt, :en]
+  symbolize :sex, :in => [true, false], :scopes => true
+  symbolize :status , :in => [:active, :inactive], :i18n => false, :capitalize => true, :scopes => true
+  symbolize :so, :allow_blank => true, :in => {
+    :linux => 'Linux',
+    :mac   => 'Mac OS X',
+    :win   => 'Videogame'
+  }, :scopes => true
+  symbolize :gui, :allow_blank => true, :in => [:cocoa, :qt, :gtk], :i18n => false
+  symbolize :karma, :in => [:good, :bad, :ugly], :methods => true, :i18n => false, :allow_nil => true
+  symbolize :public, :in => [true, false], :scopes => true
+end
+
+class UserSkill < ActiveRecord::Base
+  symbolize :kind, :in => [:agility, :magic]
+end
+
+# Make with_scope public-usable for testing
+class << ActiveRecord::Base
+  public :with_scope
+end
+
+# Test records
+User.create(:name => 'Anna', :other => :fo, :status => :active  , :so => :linux, :gui => :qt, :language => :pt, :sex => true, :public => true)
+User.create(:name => 'Bob' , :other => :bar,:status => :inactive, :so => :mac, :gui => :gtk, :language => :en, :sex => false, :public => false)
+
+
+describe "Symbolize" do
+
+
+  it "should respond to symbolize" do
+    ActiveRecord::Base.should respond_to :symbolize
+  end
+
+  describe "Instantiated" do
+    before(:each) do
+      @user = User.first
+    end
+
+    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')
+    end
+
+    it "test_symbolize_symbol" do
+      @user.status = :active
+      @user.status.should eql(:active)
+      @user.status_before_type_cast.should eql(:active)
+      # @user.read_attribute(:status).should eql('active')
+    end
+
+    it "should acts nice with numbers" do
+      @user.status = 43
+      @user.status.should be_nil
+      @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
+    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
+    end
+
+    it "test_symbols_quoted_id" do
+      @user.status = :active
+      @user.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
+    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"})
+    end
+
+    it "test_symbolize_humanize" do
+      @user.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"})
+    end
+
+    it "test_symbolize_humanize" do
+      @user.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"})
+    end
+
+    it "test_symbolize_humanize" do
+      @user.so_text.should eql("Linux")
+    end
+
+    it "test_symbolize_humanize" do
+      @user.so = :mac
+      @user.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")
+    end
+
+    it "should validate status" do
+      @user.status = nil
+      @user.should_not be_valid
+      @user.should have(1).errors
+    end
+
+    it "should not validate so" do
+      @user.so = nil
+      @user.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")
+      #    assert_equal "weird'; chars", @user.read_attribute(:status)
+      #   assert_equal "'weird''; chars'", @user.status.quoted_id
+    end
+
+    it "test_symbolized_finder" do
+      User.find(:all, :conditions => { :status => :inactive }).map(&:name).should eql(['Bob'])
+      User.find_all_by_status(:inactive).map(&:name).should eql(['Bob'])
+    end
+
+    it "test_symbolized_with_scope" do
+      User.with_scope(:find => { :conditions => { :status => :inactive }}) do
+        User.find(:all).map(&:name).should eql(['Bob'])
+      end
+    end
+    
+    it "should have named scopes" do
+      anna = User.find_by_name!('Anna')
+      bob = User.find_by_name!('Bob')
+      
+      User.inactive.should == [bob]
+      User.linux.should == [anna]
+      
+      User.with_sex.should == [anna]
+      User.without_sex.should == [bob]
+      
+      User.public.should == [anna]
+      User.not_public.should == [bob]
+    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
+        @user.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]]
+      end
+
+      it "should get the correct values" do
+        User::LANGUAGE_VALUES.should eql({:pt => "Português", :en => "Inglês"})
+      end
+
+      it "should test boolean" do
+        @user.sex_text.should eql("Feminino")
+      end
+
+      it "should get the correct values" do
+        User.get_sex_values.should eql([["Feminino", true],["Masculino", false]])
+      end
+
+      it "should get the correct values" do
+        User::SEX_VALUES.should eql({false=>"Masculino", true=>"Feminino"})
+      end
+
+      it "should translate a multiword class" do
+        @skill = UserSkill.create(:kind => :magic)
+        @skill.kind_text.should eql("Mágica")
+      end
+
+    end
+
+    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"})
+      end
+
+      it "should provide a boolean method" do
+        @user.should_not be_good
+        @user.karma = :ugly
+        @user.should be_ugly
+      end
+
+      it "should work" do
+        @user.karma = "good"
+        @user.should be_good
+        @user.should_not be_bad
+      end
+
+    end
+
+  end
+
+end

data/symbolize.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{symbolize}
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcos Piccinini", "Martin Linkhorst"]
+  s.date = %q{2009-12-02}
+  s.description = %q{ActiveRecord enums with i18n}
+  s.email = %q{m.linkhorst@googlemail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/symbolize.rb",
+     "lib/symbolize_helper.rb",
+     "rails/init.rb",
+     "spec/db/create_testing_structure.rb",
+     "spec/locales/pt.yml",
+     "spec/spec_helper.rb",
+     "spec/symbolize_spec.rb",
+     "symbolize.gemspec"
+  ]
+  s.homepage = %q{http://github.com/linki/symbolize}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{ActiveRecord enums with i18n}
+  s.test_files = [
+    "spec/db/create_testing_structure.rb",
+     "spec/spec_helper.rb",
+     "spec/symbolize_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: linki-symbolize
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+platform: ruby
+authors: 
+- Marcos Piccinini
+- Martin Linkhorst
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-02 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: ActiveRecord enums with i18n
+email: m.linkhorst@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/symbolize.rb
+- lib/symbolize_helper.rb
+- linki-symbolize.gemspec
+- rails/init.rb
+- spec/db/create_testing_structure.rb
+- spec/locales/pt.yml
+- spec/spec_helper.rb
+- spec/symbolize_spec.rb
+- symbolize.gemspec
+has_rdoc: true
+homepage: http://github.com/linki/symbolize
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ActiveRecord enums with i18n
+test_files: 
+- spec/db/create_testing_structure.rb
+- spec/spec_helper.rb
+- spec/symbolize_spec.rb