symbolize 4.5.0 → 4.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5fa03980e8f95cd5a9f9517d246364128972c3fd
-  data.tar.gz: 934d6ff3ef97dd046ed3d3d7f5241ee0bebf3bff
+  metadata.gz: d8c8248c8a57a1c3e3248a339ec6214fd6fe93ef
+  data.tar.gz: 5a2a2faba8acc56b88545a583507a714ea03f495
 SHA512:
-  metadata.gz: a1b4cc6c15e0bfb030401926817481f578f4e37d9292066996b3bc42346f6023dfe32ca3a6fb0ebfa7ec9ed8b3d8c41d7e44bf0f9d189b027cb14f3d12e923ec
-  data.tar.gz: ad06350b50ecd3bcd63abbda8baa36ab34a2fecea34a10c8af86ce50e8421fe135ceda22fb693ac096beca821adf7fffb8b257e4cd678e57281fda95694dd708
+  metadata.gz: a6cbd772314ae69fc054ea373487d515f3f3fb6a7eea1144ceda2382c463c0797114a5df969ee7e7e79c48f3f050003b651c5f5a453c7aa096b0dddbb12508c7
+  data.tar.gz: 7dea8dbec2121d3357c269bcfad8926db2b3309a5d40a670911a9bdb972fd86ad9e9bad1bc862dede94acffc156c4a62a04fc263eb285e60d87c5d12847c6e3e

data/README.md

@@ -56,7 +56,7 @@ Mongoid:
 
 Other examples:
 
-    symbolize :so, :in => {
+    symbolize :os, :in => {
         :linux   => "Linux",
         :mac     => "Mac OS X"
     }, :scopes => true

data/Rakefile

@@ -1,7 +1,9 @@
 require 'bundler/gem_tasks'
 
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new
+RuboCop::RakeTask.new
 
-task :default => [:spec]
+task :default => [:spec, :rubocop]

data/lib/symbolize.rb

@@ -1,4 +1,3 @@
-# Todo: is this the best way for AR?
 module Symbolize
   autoload :ActiveRecord, 'symbolize/active_record'
 end

data/lib/symbolize/active_record.rb

@@ -1,211 +1,219 @@
 require 'active_support/concern'
+require 'active_support/core_ext/hash/keys'
 
 module Symbolize
-end
-
-module Symbolize::ActiveRecord
-  extend ActiveSupport::Concern
+  module ActiveRecord
+    extend ActiveSupport::Concern
 
-  included do
-    # Returns an array of all the attributes that have been specified for symbolization
-    class_attribute :symbolized_attributes, :instance_reader => false
-    self.symbolized_attributes = []
-  end
+    included do
+      # Returns an array of all the attributes that have been specified for symbolization
+      class_attribute :symbolized_attributes, :instance_reader => false
+      self.symbolized_attributes = []
+    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:
-  #   symbolizes:
-  #     user:
-  #       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) || (!enum.instance_of?(Hash) && enum)
-      scopes  = configuration.delete :scopes
-      methods = configuration.delete :methods
-      capitalize = configuration.delete :capitalize
-      validation     = configuration.delete(:validate) != false
-      default_option = configuration.delete :default
-
-      unless enum.nil?
+    # 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:
+    #   symbolizes:
+    #     user:
+    #       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 = attr_names.extract_options!
+        configuration.assert_valid_keys(:in, :within, :i18n, :scopes, :methods, :capitalize, :validate, :default, :allow_blank, :allow_nil)
+
+        enum           = configuration[:in] || configuration[:within]
+        i18n           = configuration[:i18n]
+        i18n           = enum && !enum.is_a?(Hash) if i18n.nil?
+        scopes         = configuration[:scopes]
+        methods        = configuration[:methods]
+        capitalize     = configuration[:capitalize]
+        validation     = configuration[:validate] != false
+        default_option = configuration[:default]
 
         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 = ActiveSupport::OrderedHash.new
-            enum.map do |val|
-              key = val.respond_to?(:to_sym) ? val.to_sym : val
-              values[key] = capitalize ? val.to_s.capitalize : val.to_s
+          attr_name_str = attr_name.to_s
+
+          if enum
+            enum_hash = \
+            if enum.is_a?(Hash)
+              enum
+            else
+              enum.map do |val|
+                [
+                  val.respond_to?(:to_sym) ? val.to_sym : val,
+                  capitalize ? val.to_s.capitalize : val.to_s,
+                ]
+              end.to_h
             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.symbolizes.\#{ActiveSupport::Inflector.underscore(self.model_name)}.#{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)
-          class_eval "def self.#{attr_name}_enum; self.get_#{const}; end"
+            values_name = attr_name_str + '_values'
+            values_const_name = values_name.upcase
+
+            # Get the values of :in
+            const_set values_const_name, enum_hash unless const_defined? values_const_name
+
+            [
+              'get_' + values_name,
+              attr_name_str + '_enum',
+            ].each do |enum_method_name|
 
-          if methods
-            values.each do |value|
-              key = value[0]
+              define_singleton_method(enum_method_name) do
+                if i18n
+                  enum_hash.each_key.map do |symbol|
+                    [i18n_translation_for(attr_name_str, symbol), symbol]
+                  end
+                else
+                  enum_hash.map(&:reverse)
+                end
+              end
+            end
 
-              # It's a good idea to test for name collisions here and raise exceptions.
-              # However, the existing software with this kind of errors will start crashing,
-              # so I'd postpone this improvement until the next major version
-              # this way it will not affect those people who use ~> in their Gemfiles
+            if methods
+              enum_hash.each_key do |key|
+                # It's a good idea to test for name collisions here and raise exceptions.
+                # However, the existing software with this kind of errors will start crashing,
+                # so I'd postpone this improvement until the next major version
+                # this way it will not affect those people who use ~> in their Gemfiles
 
-              # raise ArgumentError, "re-defined #{key}? method of #{self.name} class due to 'symbolize'" if method_defined?("#{key}?")
+                # raise ArgumentError, "re-defined #{key}? method of #{self.name} class due to 'symbolize'" if method_defined?("#{key}?")
 
-              define_method("#{key}?") do
-                self.send(attr_name) == key.to_sym
+                define_method("#{key}?") do
+                  send(attr_name_str) == key.to_sym
+                end
               end
             end
-          end
 
-          if scopes
-            if scopes == :shallow
-              values.each do |value|
-                name = value[0]
-                if name.respond_to?(:to_sym)
-                  scope name.to_sym, -> { where(attr_name => name.to_s) }
+            if scopes
+              if scopes == :shallow
+                enum_hash.each_key do |name|
+                  next unless name.respond_to?(:to_sym)
+
+                  scope name, -> { where(attr_name_str => name) }
                   # Figure out if this as another option, or default...
-                  # scope_comm.call "not_#{attr_name}".to_sym, :conditions => { attr_name != name }
+                  # scope "not_#{name}", -> { where.not(attr_name_str => name)
                 end
+              else
+                scope attr_name_str, ->(val) { where(attr_name_str => val) }
               end
-            else
-              scope attr_name, ->(enum) { where(attr_name => enum) }
             end
+
+            if validation
+              validates(*attr_names, configuration.slice(:allow_nil, :allow_blank).merge(:inclusion => { :in => enum_hash.keys }))
+            end
+          end
+
+          define_method(attr_name_str) { read_and_symbolize_attribute(attr_name_str) || default_option }
+          define_method(attr_name_str + '=') { |value| write_symbolized_attribute(attr_name_str, value) }
+
+          if default_option
+            before_save { self[attr_name_str] ||= default_option }
+          else
+            define_method(attr_name_str) { read_and_symbolize_attribute(attr_name_str) }
           end
 
-          if validation
-            validation = "validates :#{attr_names.join(', :')}"
-            validation += ", :inclusion => { :in => #{values.keys.inspect} }"
-            validation += ", :allow_nil => true" if configuration[:allow_nil]
-            validation += ", :allow_blank => true" if configuration[:allow_blank]
-            class_eval validation
+          define_method(attr_name_str + '_text') do
+            if i18n
+              read_i18n_attribute(attr_name_str)
+            else
+              attr_value = send(attr_name_str)
+              if enum
+                enum_hash[attr_value]
+              else
+                attr_value.to_s
+              end
+            end
           end
         end
-      end
 
-      attr_names.each do |attr_name|
+        # merge new symbolized attribute and create a new array to ensure that each class in inheritance hierarchy
+        # has its own array of symbolized attributes
+        self.symbolized_attributes += attr_names.map(&:to_s)
+      end
 
-        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")
+      # Hook used by Rails to do extra stuff to attributes when they are initialized.
+      def initialize_attributes(*args)
+        super.tap do |attributes|
+          # Make sure any default values read from the database are symbolized
+          symbolized_attributes.each do |attr_name|
+            attributes[attr_name] = symbolize_attribute(attributes[attr_name])
+          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")
+      end
+
+      # String becomes symbol, booleans string and nil nil.
+      def symbolize_attribute(value)
+        case value
+        when String
+          value.presence.try(:to_sym)
+        when Symbol, TrueClass, FalseClass, Numeric
+          value
         else
-          class_eval("def #{attr_name}_text; #{attr_name}.to_s; end")
+          nil
         end
       end
 
-      # merge new symbolized attribute and create a new array to ensure that each class in inheritance hierarchy
-      # has its own array of symbolized attributes
-      self.symbolized_attributes += attr_names.map(&:to_s)
-    end
-
-    # Hook used by Rails to do extra stuff to attributes when they are initialized.
-    def initialize_attributes *args
-      super.tap do |attributes|
-        # Make sure any default values read from the database are symbolized
-        symbolized_attributes.each do |attr_name|
-          attributes[attr_name] = symbolize_attribute(attributes[attr_name])
-        end
+      def i18n_translation_for(attr_name, attr_value)
+        I18n.translate("activerecord.symbolizes.#{model_name.to_s.underscore}.#{attr_name}.#{attr_value}")
       end
     end
 
     # String becomes symbol, booleans string and nil nil.
-    def symbolize_attribute value
-      case value
-      when String
-        value.presence.try(:to_sym)
-      when Symbol, TrueClass, FalseClass, Numeric
-        value
-      else
-        nil
-      end
+    def symbolize_attribute(value)
+      self.class.symbolize_attribute(value)
     end
-  end
-
-  # String becomes symbol, booleans string and nil nil.
-  def symbolize_attribute value
-    self.class.symbolize_attribute value
-  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)
-    t = I18n.translate("activerecord.symbolizes.#{self.class.model_name.to_s.underscore}.#{attr_name}.#{attr}") #.to_sym rescue nila
-    t.is_a?(Hash) ? nil : t
-  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
 
-  # 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?
+    # Return an attribute's i18n
+    def read_i18n_attribute(attr_name)
+      unless (t = self.class.i18n_translation_for(attr_name, read_attribute(attr_name))).is_a?(Hash)
+        t
+      end
+    end
 
-    self[attr_name] = val #.to_s
+    # Write a symbolized value. Watch out for booleans.
+    def write_symbolized_attribute(attr_name, value)
+      write_attribute(attr_name, symbolize_attribute(value))
+    end
   end
 end

data/lib/symbolize/mongoid.rb

@@ -1,4 +1,5 @@
 require 'active_support/concern'
+require 'active_support/core_ext/hash/keys'
 
 module Mongoid
   module Symbolize
@@ -49,106 +50,117 @@ module Mongoid
       # 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!)
+      def symbolize(*attr_names)
+        configuration = attr_names.extract_options!
+        configuration.assert_valid_keys(:in, :within, :i18n, :scopes, :methods, :capitalize, :validate, :default, :allow_blank, :allow_nil, :type)
 
-        enum = configuration[:in] || configuration[:within]
-        i18n = configuration.delete(:i18n)
-        i18n = (!enum.instance_of?(Hash) && enum) if i18n.nil?
-        scopes      = configuration.delete :scopes
-        methods     = configuration.delete :methods
-        capitalize  = configuration.delete :capitalize
-        validation  = configuration.delete(:validate) != false
-        field_type  = configuration.delete :type
-        default_opt = configuration.delete :default
-        enum = [true, false] if [Boolean, ::Boolean].include?(field_type)
+        enum           = configuration[:in] || configuration[:within]
+        i18n           = configuration[:i18n]
+        i18n           = enum && !enum.is_a?(Hash) if i18n.nil?
+        scopes         = configuration[:scopes]
+        methods        = configuration[:methods]
+        capitalize     = configuration[:capitalize]
+        validation     = configuration[:validate] != false
+        default_option = configuration[:default]
 
-        unless enum.nil?
+        field_type     = configuration[:type] || Symbol
+        enum           = [true, false] if [Boolean, ::Boolean].include?(field_type)
 
-          attr_names.each do |attr_name|
-            # attr_name = attr_name.to_s
-
-            #
-            # Builds Mongoid 'field :name, type: type, :default'
-            #
-            const       = "#{attr_name}_values"
-            mongo_opts  = ", :type => #{field_type || 'Symbol'}"
-            mongo_opts += ", :default => :#{default_opt}" if default_opt
-            class_eval("field :#{attr_name} #{mongo_opts}")
+        attr_names.each do |attr_name|
+          attr_name_str = attr_name.to_s
 
+          if enum
+            enum_hash = \
             if enum.is_a?(Hash)
-              values = enum
+              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
+              enum.each_with_object({}) do |val, hsh|
+                hsh.store(val.respond_to?(:to_sym) ? val.to_sym : val,
+                          capitalize ? val.to_s.capitalize : val.to_s)
               end
             end
 
+            #
+            # Builds Mongoid 'field :name, type: type, :default'
+            #
+            { :type => field_type }.tap do |field_opts|
+              field_opts.merge!(:default => default_option) if default_option
+              field attr_name, field_opts
+            end
+
+            values_name = attr_name_str + '_values'
+            values_const_name = values_name.upcase
+
             # 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.symbolizes.\#{ActiveSupport::Inflector.underscore(self.model_name)}.#{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)
-            class_eval "def self.#{attr_name}_enum; self.get_#{const}; end"
+            const_set values_const_name, enum_hash unless const_defined? values_const_name
+
+            [
+              'get_' + values_name, attr_name_str + '_enum'
+            ].each do |enum_method_name|
+
+              define_singleton_method(enum_method_name) do
+                if i18n
+                  enum_hash.each_key.map do |symbol|
+                    [i18n_translation_for(attr_name_str, symbol), symbol]
+                  end
+                else
+                  enum_hash.map(&:reverse)
+                end
+              end
+            end
 
             if methods
-              values.each do |k, v|
-                define_method("#{k}?") do
-                  self.send(attr_name) == k
+              enum_hash.each_key do |key|
+                define_method("#{key}?") do
+                  send(attr_name_str) == key.to_sym
                 end
               end
             end
 
             if scopes
               if scopes == :shallow
-                values.each do |k, v|
-                  next unless k.respond_to?(:to_sym)
-                  scope k.to_sym, -> { where(attr_name => k) }
+                enum_hash.each_key do |name|
+                  next unless name.respond_to?(:to_sym)
+                  scope name, -> { where(attr_name_str => name) }
                 end
               else # scoped scopes
-                scope attr_name, ->(enum) { where(attr_name => enum) }
+                scope attr_name_str, ->(val) { where(attr_name_str => val) }
               end
             end
 
             if validation
-              v = "validates :#{attr_names.join(', :')}" +
-                ",:inclusion => { :in => #{values.keys.inspect} }"
-              v += ',:allow_nil => true'   if configuration[:allow_nil]
-              v += ',:allow_blank => true' if configuration[:allow_blank]
-              class_eval v
+              validates(*attr_names, configuration.slice(:allow_nil, :allow_blank).merge(:inclusion => { :in => enum_hash.keys }))
             end
-
           end
-        end
 
-        #
-        # Creates <attribute>_text helper, human text for attribute.
-        #
-        attr_names.each do |attr_name|
-          if i18n # memoize call to translate... good idea?
-            define_method "#{attr_name}_text" do
-              attr = read_attribute(attr_name)
-              return nil if attr.nil?
-              I18n.t("mongoid.symbolizes.#{self.class.model_name.to_s.underscore}.#{attr_name}.#{attr}")
+          #
+          # Creates <attribute>_text helper, human text for attribute.
+          #
+          define_method(attr_name_str + '_text') do
+            if i18n
+              read_i18n_attribute(attr_name_str)
+            else
+              attr_value = send(attr_name_str)
+              if enum
+                enum_hash[attr_value]
+              else
+                attr_value.to_s
+              end
             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
 
+          def i18n_translation_for(attr_name, attr_value)
+            I18n.translate("mongoid.symbolizes.#{model_name.to_s.underscore}.#{attr_name}.#{attr_value}")
+          end
+        end
       end
-
     end # ClassMethods
+
+    # Return an attribute's i18n
+    def read_i18n_attribute(attr_name)
+      t = self.class.i18n_translation_for(attr_name, read_attribute(attr_name))
+      t.is_a?(Hash) ? nil : t
+    end
   end # Symbolize
 end # Mongoid