symbolize 3.3.0pre → 4.0.1

data/README.rdoc

@@ -1,52 +1,34 @@
-= 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
+= 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
+and can be set using :symbols or "strings".
 
 == Install
 
 === Gem
 
-  gem install symbolize
-  config.gem "symbolize", :source => 'http://gemcutter.org'
+    gem install symbolize
 
 
-Rails 3+ Gemfile
+=== Mongoid
 
-  gem "symbolize"
+    gem "symbolize", :require => "symbolize/mongoid"
 
 
-=== Plugin:
+=== ActiveRecord
+
+    gem "symbolize", :require => "symbolize/active_record"
 
-  ./script/plugin install git://github.com/nofxx/symbolize.git
 
-or in Rails3+
 
-  rails plugin install ..
+== 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).
 
-== Rails 3 (beta)
+On SQL-based DBs, an attribute to symbolize should be a string (varchar) column in the database.
 
-Specs pass with rails 3, but a scope :public == fail.
 
 
 == Usage
@@ -54,7 +36,14 @@ Specs pass with rails 3, but a scope :public == fail.
 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
+
       symbolize :gender, :in => [:female, :male], :scopes => true
       symbolize :so, :in => {
         :linux   => "Linux",
@@ -174,6 +163,15 @@ As the name suggest, the symbol you choose as default will be set in new objects
   u = User.new(:name => 'ET', :gender => :unknown)
   u.save                          # => validation fails
 
+== Rails Form Example
+
+    class Coffee
+      symbolize :genetic, :in => [:arabica, :robusta, :blend]
+    end
+
+    form_for(@coffee) do |f|
+      = f.label :genetic
+      = f.select :genetic, Coffee.get_genetic_values
 
 == Model Helpers
 
@@ -181,9 +179,6 @@ As the name suggest, the symbol you choose as default will be set in new objects
 You may call `Class.get_attr_values` anywhere to get a nice array.
 Works nice with dropdowns. Examples:
 
-    class Coffee
-      symbolize :genetic, :in => [:arabica, :robusta, :blend]
-    end
 
 Somewhere on a view:
 
@@ -221,6 +216,27 @@ Somewhere on a view:
   </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.
+
+
+== Specs
+
+Run the adapter independently:
+
+    $ rspec spec/symbolize/mongoid_spec.rb
+    $ rspec spec/symbolize/active_record_spec.rb
+
+
 == Notes
 
 This fork:

data/Rakefile

@@ -6,8 +6,8 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "symbolize"
-    gem.summary = "ActiveRecord enums with i18n"
-    gem.description = "ActiveRecord enums with i18n"
+    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"]
@@ -39,7 +39,7 @@ end
 #   rdoc.rdoc_files.include('README')
 #   rdoc.rdoc_files.include('lib/**/*.rb')
 # end
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   if File.exist?('VERSION.yml')
     config = YAML.load(File.read('VERSION.yml'))

data/VERSION

@@ -1 +1 @@
-3.3.0
+4.0.1

data/lib/symbolize/active_record.rb

@@ -0,0 +1,194 @@
+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.delete(:i18n).nil? && !enum.instance_of?(Hash) && enum ? true : configuration[:i18n]
+      scopes  = configuration.delete :scopes
+      methods = configuration.delete :methods
+      capitalize = configuration.delete :capitalize
+      validation     = configuration.delete(:validation) != false
+      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
+          const =  "#{attr_name}_values"
+          if enum.is_a?(Hash)
+            values = enum
+          else
+            values = hsh.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
+            end
+          end
+
+          # Get the values of :in
+          const_set const.upcase, values unless const_defined? const.upcase
+          ev = if i18n
+            # This one is a dropdown helper
+            code =  "#{const.upcase}.map { |k,v| [I18n.translate(\"activerecord.attributes.\#{ActiveSupport::Inflector.underscore(self)}.enums.#{attr_name}.\#{k}\"), k] }" #.to_sym rescue nila
+            "def self.get_#{const}; #{code}; end;"
+          else
+            "def self.get_#{const}; #{const.upcase}.map(&:reverse); end"
+          end
+          class_eval(ev)
+
+          if methods
+            values.each do |value|
+              define_method("#{value[0]}?") do
+                self.send(attr_name) == value[0]
+              end
+            end
+          end
+
+          if scopes
+            scope_comm = lambda { |*args| ActiveRecord::VERSION::MAJOR >= 3 ? scope(*args) : named_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 }
+              elsif ActiveRecord::VERSION::STRING <= "3.0"
+                if value[0] == true || value[0] == false
+                  scope_comm.call "with_#{attr_name}".to_sym,    :conditions => { attr_name => '1' }
+                  scope_comm.call "without_#{attr_name}".to_sym, :conditions => { attr_name => '0' }
+
+                  scope_comm.call attr_name.to_sym,   :conditions => { attr_name => '1' }
+                  scope_comm.call "not_#{attr_name}".to_sym, :conditions => { attr_name => '0' }
+                end
+              end
+            end
+          end
+        end
+
+        if validation
+          class_eval "validates_inclusion_of :#{attr_names.join(', :')}, #{configuration.inspect}"
+        end
+      end
+
+      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")
+        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
+    attr = read_attribute(attr_name)
+    return nil if attr.nil?
+    I18n.translate("activerecord.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?
+
+    self[attr_name] = val #.to_s # rails 3.1 fix
+  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

data/lib/symbolize/mongoid.rb

@@ -0,0 +1,172 @@
+module Mongoid
+  module Symbolize
+    def self.included base
+      base.extend(ClassMethods)
+    end
+
+    # Symbolize Mongoid 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.
+    #
+    # There's no need for 'field :attr_name', symbolize will do it.
+    #
+    # Example:
+    #   class User
+    #     include Mongoid::Document
+    #     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:
+    #
+    # models:
+    #   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.delete(:i18n).nil? && !enum.instance_of?(Hash) && enum ? true : configuration[:i18n]
+        scopes  = configuration.delete :scopes
+        methods = configuration.delete :methods
+        capitalize = configuration.delete :capitalize
+        validation     = configuration.delete(:validation) != false
+        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
+
+            # Builds Mongoid 'field :name, type: type, :default
+            type    = ", type: Symbol"
+            default = ", default: :#{default_opt}" if default_opt
+            class_eval("field :#{attr_name} #{type} #{default}")
+
+            const =  "#{attr_name}_values"
+            if enum.is_a?(Hash)
+              values = enum
+            else
+              values = {}
+              enum.map do |val|
+                key = val.respond_to?(:to_sym) ? val.to_sym : val
+                values[key] = capitalize ? val.to_s.capitalize : val.to_s
+              end
+            end
+
+            # Get the values of :in
+            const_set const.upcase, values unless const_defined? const.upcase
+            ev = if i18n
+                   # This one is a dropdown helper
+                   code =  "#{const.upcase}.map { |k,v| [I18n.t(\"mongoid.attributes.\#{ActiveSupport::Inflector.underscore(self)}.enums.#{attr_name}.\#{k}\"), k] }" #.to_sym rescue nila
+                   "def self.get_#{const}; #{code}; end;"
+                 else
+                   "def self.get_#{const}; #{const.upcase}.map(&:reverse); end"
+                 end
+            class_eval(ev)
+
+            if methods
+              values.each do |value|
+                define_method("#{value[0]}?") do
+                  self.send(attr_name) == value[0]
+                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, :conditions => { attr_name => value[0].to_sym }
+                end
+              end
+            end
+
+            if validation
+              class_eval "validates_inclusion_of :#{attr_names.join(', :')}, #{configuration.inspect}"
+            end
+          end
+        end
+
+        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")
+          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("activerecord.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?
+
+    #   self[attr_name] = val #.to_s # rails 3.1 fix
+    # end
+  end
+end

data/lib/symbolize/railtie.rb

@@ -1,14 +1,15 @@
 # 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
+  # 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
 end
 
+