i18n-inflector-rails 0.2.0 → 1.0.0

data/ChangeLog

@@ -1,3 +1,45 @@
+commit 5ee55b3ea54cfa86e541a47f27cbe321932c3820
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Tue Feb 15 01:38:13 2011 +0100
+
+    Release 1.0.0
+
+commit 46377c25557637e0f576a637b6abd203555989da
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Tue Feb 15 01:09:46 2011 +0100
+
+    Documentation updated
+
+commit f3419fd70560927aec82813e25d6dd4d33e6e629
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Tue Feb 15 01:09:07 2011 +0100
+
+    Specification updated
+
+commit 8c2907f62a9273a66bc5be0e90da92c0299d1e72
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Tue Feb 15 01:07:53 2011 +0100
+
+    ClassMethods and InflectedTranslate refactored
+    
+    - There are no additional Procs support, but Inflector's inflection methods may take arguments.
+    - Translation method now makes use of lazy methods feature of I18n Inflector.
+    - The internal hash is now i18n_inflector_kinds and it's indexed by kinds.
+    - Rewritten argument parsing for inflection_method.
+    - Added no_inflection_method_for (aka no_inflection_kind).
+
+commit aee2f6f484bee1812ecf8765b28d910adc8412e5
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Tue Feb 15 00:58:53 2011 +0100
+
+    New switches are now added by opening the InflectionOptions class, added new switch :lazy_methods
+
+commit 938f7bf971d8c00710b2202dc15e37929f8391dc
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Mon Jan 17 15:01:07 2011 +0100
+
+    Link in documentation fixed
+
 commit 15e330e957f34579fa95aa2036f0c06fd168ab54
 Author: Paweł Wilk <siefca@gnu.org>
 Date:   Sun Jan 16 07:06:57 2011 +0100

data/Gemfile

@@ -2,7 +2,7 @@
 
 source :gemcutter
 
-gem "i18n-inflector", "~>2.0"
+gem "i18n-inflector", "~>2.3"
 gem "railties", "~>3.0"
 gem "actionpack", "~>3.0"
 

data/README.rdoc

@@ -1,6 +1,6 @@
 = Simple I18n Inflector for Rails
 
-<b>i18n-inflector-rails version <tt>0.1</tt></b> (<b><tt>Sexparty</tt></b>)
+<b>i18n-inflector-rails version <tt>1.0</tt></b> (<b><tt>Rain</tt></b>)
 
 
 
@@ -11,7 +11,7 @@
 == Summary
 
 This Rails plug-in contains bindings for the I18n Inflector module for Ruby's I18n.
-It overwrites the translate() method from Rails in a way that it will
+It overwrites the <tt>translate()</tt> method from Rails in a way that it will
 interpolate additional inflection tokens present in translations.
 These tokens may appear in *patterns* which are contained within
 <tt>@{</tt> and <tt>}</tt> symbols.
@@ -19,15 +19,15 @@ These tokens may appear in *patterns* which are contained within
 == Why?
 
 It's intended to be used in a projects where tranlations are performed
-by many people, yet there is a need to substitute fragments of text
-depending on user's gender, person or other data.
+by many people, yet there is a need to inflect sentences or words by
+user's gender, person or other data.
 
 To achieve similar functionality lambdas can be used but including
-proc objects in translations may be considered as the unsafe idea.
+Proc objects in translations may be considered unsafe.
 
 If you have a troop of happy translators that shouldn't have the
 ability to execute any code yet you need some simple inflection
-then you should use this module.
+then this plug-in might help you.
 
 == Synopsis
 
@@ -50,7 +50,7 @@ then you should use this module.
           @neuter:  @n
           man:      @male
           woman:    @female
-          default:  neuter
+          default:  n
 
 ===== In a controller:
 
@@ -78,26 +78,26 @@ then you should use this module.
   
 == Description
 
-You can choose different kinds (gender, title, person, time, author, etc.)
-of tokens to group them in a meaningful, semantical sets. That means you can
-apply I18n Inflector to do simple inflection by a gender or a person, when some
-language requires it.
+You can create your own kinds (gender, title, person, time, author, etc.)
+of tokens to group them in a meaningful, semantical sets.
 
-This module adds +inflection_method+ clause that can be used
-in controllers and views. Using that clause makes it easy to register
-methods that will be called to obtain mentioned inflection options.
+This plug-in adds {I18n::Inflector::Rails::ClassMethods#inflection_method inflection_method},
+{I18n::Inflector::Rails::ClassMethods#no_inflection_method no_inflection_method}
+and {I18n::Inflector::Rails::ClassMethods#no_inflection_method_for no_inflection_method_for} clauses
+that can be used in controllers and views. Using that clauses makes it easy to register
+methods that will be called to obtain certain inflection options.
+It is also possible to set up an inflection method for a so called
+strict kind commonly used in a so called named and complex patterns.
 
-This module uses i18n-inflector[https://rubygems.org/gems/i18n-inflector]
+This plug-in uses i18n-inflector[https://rubygems.org/gems/i18n-inflector]
 module which allows passing inflection options to the translate method.
-You may find i18n-inflector default objects very helpful since they
-allow you to read inflection data in many different ways. You may, for
-example, use it to generate forms containing languages that are using inflection,
-all known inflection kinds or tokens assigned to them. To access default inflector
-bound to default I18n backend use:
-  I18n.inflector
+You may find I18n Inflector's API and a default object very helpful since
+they allow you to read inflection data in many different ways. You might,
+for example, use it to generate forms containing lists of languages that are using
+inflection, or to view all known inflection kinds or tokens assigned to them.
 
-See {whole documentation}[http://rubydoc.info/gems/i18n-inflector-rails/] for more info about the usage.
-To understand how the I18n Inflector works please read {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector/file/README.rdoc].
+To access the Inflector object bound to default I18n backend use:
+  I18n.inflector
 
 == Requirements
 
@@ -119,7 +119,7 @@ To understand how the I18n Inflector works please read {I18n Inflector documenta
 
 == Installation
 
-* <tt>sudo gem install i18n-inflector-rails</tt>
+* <tt>gem install i18n-inflector-rails</tt>
 
 == Specs
 
@@ -130,9 +130,16 @@ You can run RSpec examples both with
 
 == More information
 
-See {whole documentation}[http://rubydoc.info/gems/i18n-inflector-rails/] for more info about the usage.
+See {I18n::Inflector::Rails::ClassMethods} to learn how to use +inflection_method+ and +no_inflection_method+.
+
+See {I18n::Inflector::Rails::InflectedTranslate} to learn about using the translation wrapper.
+
+See {I18n::Inflector::InflectionOptions} to know more about switches that can be used to control the engine.
+
+See the {whole documentation}[http://rubydoc.info/gems/i18n-inflector-rails/] for more information.
 
-See {I18n::Inflector::Rails} module documentation for detailed information.
+To know how the basics and to learn more about Inflector that is used by this plug-in
+see {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector].
 
 == Credits
 

data/Rakefile

@@ -1,6 +1,6 @@
 # encoding: utf-8
 # -*- ruby -*-
- 
+
 $:.unshift File.join(File.dirname(__FILE__), "lib")
 
 require 'rubygems'
@@ -40,15 +40,15 @@ Hoe.spec 'i18n-inflector-rails' do
   self.rsync_args      << '--chmod=a+rX'
   self.readme_file     = 'README.rdoc'
   self.history_file    = 'docs/HISTORY'
-  
-  extra_deps          << ['i18n-inflector',   '~> 2.0'] <<
+
+  extra_deps          << ['i18n-inflector',   '~> 2.3'] <<
                          ['railties',         '~> 3.0'] <<
                          ['actionpack',       '~> 3.0']
   extra_dev_deps      << ['rspec',            '>= 2.3.0'] <<
                          ['yard',             '>= 0.6.4'] <<
                          ['bundler',          '>= 1.0.7'] <<
                          ['hoe-bundler',      '>= 1.0.0']
-  
+
   unless extra_dev_deps.flatten.include?('hoe-yard')
     extra_dev_deps << ['hoe-yard', '>= 0.1.2']
   end

data/docs/HISTORY

@@ -1,3 +1,20 @@
+=== 1.0.0 / 2011-02-14
+
+* major enhancements
+
+  * Inflection methods evaluation is now lazy; passing Method objects to the Inflector
+  * Added strict kinds (named patterns) better support
+  * Added no_inflection_method_for (alias no_inflection_kind) clause
+  * Changed way that associations are stored from (method => kind) to (kind => method)
+  * Removed block passing support from inflection_method since I18n Inflector supports inflection methods with arguments
+
+* minor enhancements
+
+  * Removed magic symbols from code
+  * Improved arguments parsing in inflection_method
+  * Added auto_helper global switch
+  * Added lazy_methods global switch
+
 === 0.2.0 / 2011-01-15
 
 * 1 major enhancement

data/docs/TODO

@@ -1,3 +1,2 @@
 
 * write more real specs with full Rails 3 stack simulation
-

data/i18n-inflector-rails.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = '>= 1.3.5'
   s.specification_version = 3
 
-  s.add_dependency 'i18n-inflector',          '~> 2.0'
+  s.add_dependency 'i18n-inflector',          '~> 2.3'
   s.add_dependency 'railties',                '~> 3.0'
   s.add_dependency 'actionpack',              '~> 3.0'
   s.add_development_dependency 'rspec',       '>= 2.3.0'

data/lib/i18n-inflector-rails.rb

@@ -6,8 +6,6 @@ require 'i18n-inflector-rails/errors'
 require 'i18n-inflector-rails/options'
 require 'i18n-inflector-rails/inflector'
 
-I18n::Inflector::InflectionOptions.send(:include, I18n::Inflector::Rails::AdditionalOptions)
-
 if defined? Rails::Engine
 
   require 'i18n-inflector-rails/railtie'

data/lib/i18n-inflector-rails/errors.rb

@@ -9,7 +9,9 @@
 module I18n
   module Inflector
     module Rails
-      
+
+      # This class is for reporting bad inflection method
+      # in the given assignment.
       class BadInflectionMethod < I18n::ArgumentError
         attr_reader :assignment
         def initialize(assignment)
@@ -17,7 +19,7 @@ module I18n
           super "The given assignment is invalid: #{assignment}"
         end
       end
-      
+
     end
   end
 end

data/lib/i18n-inflector-rails/inflector.rb

@@ -10,38 +10,40 @@
 # inflection tokens defined in translation data.
 
 module I18n
+
+  # @abstract It is defined in {I18n Inflector library}[http://rubydoc.info/gems/i18n-inflector].
   module Inflector
     module Rails
-  
+
       # This module contains instance methods for ActionController.
       module InstanceMethods
-  
-        # This method calls the class method {I18n::Inflector::Rails::ClassMethods#i18n_inflector_methods}
-        def i18n_inflector_methods
-          self.class.i18n_inflector_methods
+
+        # This method calls the class method {I18n::Inflector::Rails::ClassMethods#i18n_inflector_kinds}
+        def i18n_inflector_kinds
+          self.class.i18n_inflector_kinds
         end
 
         # @private
         def self.included(base)
-          base.helper_method(:i18n_inflector_methods)
+          base.helper_method(:i18n_inflector_kinds)
         end
-  
+
       end # instance methods
-  
+
       # This module contains class methods for ActionController.
       module ClassMethods
-  
-        # This method reads the internal Hash +i18n_inflector_methods+ containing registered
+
+        # This method reads the internal Hash +i18n_inflector_kinds+ containing registered
         # inflection methods and the assigned kinds. It also reads any methods
         # assignments that were defined earlier in the inheritance path and
         # merges them with current results; the most current entries will
         # override the entries defined before.
         # 
         # @api public
-        # @return [Hash] the Hash containing assignments made by using {inflection_method}
-        def i18n_inflector_methods
-          prev = superclass.respond_to?(:i18n_inflector_methods) ? superclass.i18n_inflector_methods : {}
-          return @i18n_inflector_methods.nil? ? prev : prev.merge(@i18n_inflector_methods)
+        # @return [Hash] the Hash containing assignments made by using {#inflection_method}
+        def i18n_inflector_kinds
+          prev = superclass.respond_to?(:i18n_inflector_kinds) ? superclass.i18n_inflector_kinds : {}
+          return @i18n_inflector_kinds.nil? ? prev : prev.merge(@i18n_inflector_kinds)
         end
 
         # This method allows to assign methods (typically attribute readers)
@@ -52,96 +54,248 @@ module I18n
         # given then method assumes that the name of a kind is the same as the given
         # name of a method.
         # 
+        # If the given kind begins with +@+ then strict kind is assumed. If there is
+        # no kind given but the given method name begins with +@+ character then
+        # also strict kind of the same name is assumed but method name is memorized
+        # without the leading symbol.
+        # 
+        # Registering method for feeding an inflection option describing a strict
+        # kind might be good idea when using some regular kind of the same name,
+        # but note that regular kind inflection option is also tried by the
+        # translation method when strict kind is in use.
+        # 
+        # In case of registering two methods of different
+        # names but assigned to kind and to a strict kind using the same base name,
+        # a named inflection pattern will first use an inflection option obtained
+        # from a method assigned to a strict kind. Note that it is impossible
+        # to use short formed +inflection_method+ calls to register a method for both
+        # strict and regular inflection kind, since the method names will be the
+        # same and the second call will overwrite the first one.
+        # 
+        # @example Registering an inflection method for the kind gender visible in a whole application
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :gender
+        #     […]
+        #   end
+        # 
+        # @example Registering an inflection method for the strict kind @gender visible in a whole application
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :@gender
+        #     […]
+        #   end
+        # 
+        # @example Registering a custom-named inflection method for the kind gender
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :get_user_gender => :gender
+        #     […]
+        #   end
+        # 
+        # @example Registering a custom-named inflection methods for the kinds gender and tense
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :get_user_gender => :gender, :get_tense => :tense
+        #     […]
+        #   end
+        # 
+        # @example Registering inflection methods for the kinds gender and tense
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :gender, :tense
+        #     […]
+        #   end
+        # 
+        # @example Registering inflection methods for the kind gender and the strict kind @tense
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :gender, :@tense
+        #     […]
+        #   end
+        # 
+        # @example Registering a custom-named inflection methods for the kinds gender and @gender
+        #   # in case of named patterns the method get_strict_gender and the
+        #   # strict kind @gender will have priority; the regular kind gender
+        #   # and its method would be used if there would be no strict variants
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :get_gender => :gender, :get_strict_gender => :@gender
+        #     […]
+        #   end
+        # 
+        # @example Registering a method for the kind gender and the custom-named method for the kind @gender
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :gender, :get_strict_gender => :@gender
+        #     […]
+        #   end
+        # 
+        # @example Registering a method for the kind gender visible in whole app and a variant for some controller
+        #   class ApplicationController < ActionController::Base
+        #     inflection_method :gender
+        #     […]
+        #   end
+        #   
+        #   # In this controller the method gender will be called
+        #   # to obtain inflection option's value for the kind gender
+        #   class UsersController < ApplicationController
+        #   end
+        #   
+        #   # In this controller the method getit will be called
+        #   # to obtain inflection option's value for the kind gender
+        #   class OtherController < ApplicationController
+        #     inflection_method :getit => :gender
+        #   end
+        #   
+        #   # In this controller no method will be called
+        #   # to obtain inflection option's value for the kind gender
+        #   class FlowersController < ApplicationController
+        #     no_inflection_method :getit
+        #   end
+        # 
         # @api public
-        # @note Any added method will become helper!
-        # @raise [I18n::Inflector::Rails::BadInflectionMethod] when name or value is malformed
-        # @param [Hash,Array,Symbol,String] assignment the methods and inflection kinds assigned to them
+        # @note Any added method will become a helper unless {I18n::Inflector::InflectionOptions#auto_helper} swtich is set to +false+!
+        # @raise [I18n::Inflector::Rails::BadInflectionMethod] when the given name or value are malformed
+        # @param [Hash{Symbol => Symbol},Array<Symbol>,Symbol,String] *args the methods and inflection kinds assigned to them
         # @return [void]
-        # @yield [method, kind, value, caller] optional block that will be executed
-        #   each time the registered method is called. Its result will replace
-        #   the original returning value of the method that is assigned to a kind
-        # @yieldparam [Symbol] method the name of an assigned method
-        # @yieldparam [Symbol] kind the name of an inflection kind assigned to that +method+
-        # @yieldparam [Object] value the original result of calling the +method+ that will be assigned to a +kind+ as a token
-        # @yieldparam [Object] caller the object that made a call to {translate} method
-        # @yieldreturn [String] the new +value+ (token name) that will be assigned to a +kind+
-        def inflection_method(assignment, &block)
-          if assignment.is_a?(Array)
-            new_assignment = {}
-            assignment.flatten.each{|e| new_assignment[e]=new_assignment}
-            assignment = new_assignment
-          elsif (assignment.is_a?(String) || assignment.is_a?(Symbol))
-            assignment = { assignment => assignment }
+        def inflection_method(*args)
+          args = args.flatten
+          if args.empty?
+            raise I18n::Inflector::Rails::BadInflectionMethod.new(assignment)
           end
 
-          if (assignment.nil? || !assignment.is_a?(Hash) || assignment.empty?)
-            raise I18n::Inflector::Rails::BadInflectionMethod.new(assignment)
+          assignment = {}
+          args.each do |e|
+            if (e.is_a?(Symbol) || e.is_a?(String))
+              assignment[e] = e
+            elsif e.is_a?(Hash)
+              raise I18n::Inflector::Rails::BadInflectionMethod.new(assignment) if e.empty?
+              assignment.merge!(e)
+            else
+              raise I18n::Inflector::Rails::BadInflectionMethod.new(assignment)
+            end
           end
 
-          @i18n_inflector_methods ||= {}
-          assignment.each_pair do |k,v|
-            k = k.to_s
-            v = v.to_s
-            if (k.empty? || v.empty?)
-              raise I18n::Inflector::Rails::BadInflectionMethod.new("#{k.inspect} => #{v.inspect}")
+          @i18n_inflector_kinds ||= {}
+          assignment.each_pair do |method, kind|
+            method = method.to_s
+            if (method.empty? || I18n::Inflector::Config::Reserved::Kinds.invalid?(kind, :OPTION))
+              raise I18n::Inflector::Rails::BadInflectionMethod.new("#{method.inspect} => #{kind.inspect}")
             end
-            k = k.to_sym
-            helper_method(k)
-            @i18n_inflector_methods[k]      ||= {}
-            @i18n_inflector_methods[k][:kind] = v.to_sym
-            @i18n_inflector_methods[k][:proc] = block
+            kind   = kind.to_s
+            method = method[1..-1] if (method[0..0] == I18n::Inflector::Config::Markers::PATTERN && method == kind)
+            kind   = kind.to_sym
+            method = method.to_sym
+            helper_method(method) if I18n.backend.inflector.options.auto_helper
+            @i18n_inflector_kinds[kind] = method
           end
         end
         alias_method :inflection_methods, :inflection_method
 
-        # This method allows to remove methods from sets
-        # created using {inflection_method}. It is useful
+        # This method unregisters inflection kinds from assignments
+        # created by {inflection_method}. It is useful
         # when there is a need to break inheritance in some controller,
-        # but a method has been marked as inflection method by
+        # but there was a method assigned to some inflection kind in
         # a parrent class.
         # 
         # @api public
-        # @raise [I18n::Inflector::Rails::BadInflectionMethod] when name or value is malformed
-        # @param [Array] names the method names that should be marked as removed in this controller
+        # @raise [I18n::Inflector::Rails::BadInflectionMethod] when name or value is bad or malformed
+        # @param [Array<Symbol>] names the method names for which the assigned kinds should be marked as not
+        #   supported in a current controller and all derivative controllers
         # @return [void]
         def no_inflection_method(*names)
           names = names.flatten
           if (names.nil? || names.empty?)
             raise I18n::Inflector::Rails::BadInflectionMethod.new(names)
           end
-          @i18n_inflector_methods ||= {}
+          @i18n_inflector_kinds   ||= {}
           names.each do |meth|
             unless (meth.is_a?(Symbol) || meth.is_a?(String))
               raise I18n::Inflector::Rails::BadInflectionMethod.new(meth)
             end
             meth = meth.to_s
+            meth = meth[1..-1] if meth[0..0] == I18n::Inflector::Config::Markers::PATTERN # for dummies
             raise I18n::Inflector::Rails::BadInflectionMethod.new(meth) if meth.empty?
-            @i18n_inflector_methods[meth.to_sym] = nil
-           end
+            meth = meth.to_sym
+            i18n_inflector_kinds.each_pair do |kind, obj|
+              if obj == meth
+                @i18n_inflector_kinds[kind] = nil
+              end
+            end
+          end
         end
         alias_method :no_inflection_methods, :no_inflection_method
 
+        # This method unregisters the given inflection kinds from assignments
+        # created by {inflection_method}. It is useful
+        # when there is a need to break inheritance in some controller,
+        # but there was a method assigned to some inflection kind in
+        # a parrent class.
+        # 
+        # @api public
+        # @raise [I18n::Inflector::Rails::BadInflectionMethod] when name or value is malformed
+        # @param [String,Symbol,Array<Symbol>] kinds the kind for which the method names should be marked
+        #   as not supported in a current controller and all derivative controllers
+        # @return [void]
+        def no_inflection_method_for(*names)
+          names = names.flatten
+          if (names.nil? || names.empty?)
+            raise I18n::Inflector::Rails::BadInflectionMethod.new(names)
+          end
+          @i18n_inflector_kinds ||= {}
+          names.each do |kind|
+            unless (kind.is_a?(Symbol) || kind.is_a?(String))
+              raise I18n::Inflector::Rails::BadInflectionKind.new(kind)
+            end
+            if (I18n::Inflector::Config::Reserved::Kinds.invalid?(kind, :OPTION) ||
+                kind.to_s == I18n::Inflector::Config::Markers::PATTERN)
+              raise I18n::Inflector::Rails::BadInflectionKind.new(kind)
+            end
+            @i18n_inflector_kinds[kind.to_sym] = nil
+           end
+        end
+        alias_method :no_inflection_methods_for, :no_inflection_method_for
+        alias_method :no_inflection_kind,        :no_inflection_method_for
+
       end # class methods
-  
-      # This module contains a version of {translate} method that
-      # tries to use +i18n_inflector_methods+ available in the current context.
+
+      # This module contains a variant of the +translate+ method that
+      # uses {I18n::Inflector::Rails::ClassMethods#i18n_inflector_kinds i18n_inflector_kinds}
+      # available in the current context.
       # The method from this module will wrap the
       # {ActionView::Helpers::TranslationHelper#translate} method.
       module InflectedTranslate
-  
+
         # This method tries to feed itself with the data coming
-        # from +i18n_inflector_methods+ available in the current context.
-        # The data from the last method should contain options
-        # of inflection pairs (<tt>kind => value</tt>) that will
-        # be passed to {I18n::Backend::Inflector#translate} through
+        # from {I18n::Inflector::Rails::ClassMethods#i18n_inflector_kinds i18n_inflector_kinds}
+        # available in the current context.
+        # That data contains inflection pairs (<tt>kind => value</tt>) that will
+        # be passed to the interpolation method from {I18n::Inflector} through
         # {ActionView::Helpers::TranslationHelper#translate}.
         # 
+        # You may also pass inflection options directly, along with other options,
+        # without registering methods responsible for delivering tokens.
+        # See {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector]
+        # for more info about inflection options.
+        # 
         # @api public
-        # @param [String] key translation key
-        # @param [Hash] options a set of options to pass to the
-        #   translation routines
-        # @return [String] the translated string with inflection patterns
-        #   interpolated
+        # @raise {I18n::InvalidInflectionKind}
+        # @raise {I18n::InvalidInflectionOption}
+        # @raise {I18n::InvalidInflectionToken}
+        # @raise {I18n::MisplacedInflectionToken}
+        # @overload translate(key, options)
+        #   @param [String] key translation key
+        #   @param [Hash] options a set of options to pass to the
+        #     translation routines
+        #   @option options [Boolean] :inflector_verify_methods (false) local switch
+        #     that overrides global setting (see {I18n::Inflector::InflectionOptions#verify_methods})
+        #   @option options [Boolean] :inflector_lazy_methods (true) local switch
+        #     that overrides global setting (see {I18n::Inflector::InflectionOptions#lazy_methods})
+        #   @option options [Boolean] :inflector_excluded_defaults (false) local switch
+        #     that overrides global setting (see {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector])
+        #   @option options [Boolean] :inflector_unknown_defaults (true) local switch
+        #     that overrides global setting (see {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector])
+        #   @option options [Boolean] :inflector_raises (false) local switch
+        #     that overrides global setting (see {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector])
+        #   @option options [Boolean] :inflector_aliased_patterns (false) local switch
+        #     that overrides global setting (see {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector])
+        #   @option options [Boolean] :inflector_cache_aware (false) local switch
+        #     that overrides global setting (see {I18n Inflector documentation}[http://rubydoc.info/gems/i18n-inflector])
+        #   @return [String] the translated string with inflection patterns
+        #     interpolated
         def translate(*args)
           opts_present  = args.last.is_a?(Hash)
           if opts_present
@@ -153,16 +307,12 @@ module I18n
           test_locale ||= I18n.locale
           inflector = I18n.backend.inflector
 
-          # use standard translate if the locale is not supported
+          # return immediately if the locale is not supported
           return super unless inflector.inflected_locale?(test_locale)
 
-          # read switch
-          verifies = options.delete(:inflector_verify_methods)
-          verifies = verifies.nil? ? inflector.options.verify_methods : verifies
-
           # collect inflection variables that are present in this context
-          subopts  = t_prepare_inflection_options(inflector, verifies)
-  
+          subopts  = t_prepare_inflection_options(inflector, locale, options)
+
           # jump to original translate if no variables are present
           return super if subopts.empty?
 
@@ -173,29 +323,34 @@ module I18n
         end
 
         alias_method :t, :translate
-  
+
         protected
-  
-        # This method tries to read +i18n_inflector_methods+ available in the current context.
+
+        # This method tries to read +i18n_inflector_kinds+ available in the current context.
         # 
         # @return [Hash] the inflection options (<tt>kind => value</tt>)
-        def t_prepare_inflection_options(inflector, verifies)
+        def t_prepare_inflection_options(inflector, locale, options)
           subopts = {}
-          return subopts if (verifies && !respond_to?(:i18n_inflector_methods))
-          i18n_inflector_methods.each_pair do |m, obj|
-            next if obj.nil?                        # method registered but disabled from usage
-            next if (verifies && !respond_to?(m))   # verify_methods enabled
-            value = method(m).call
-            proca = obj[:proc]
-            kind  = obj[:kind]
-            value = proca.call(m, kind, value, self) unless proca.nil?
-            subopts[kind] = value.to_s
+
+          verifies = options[:inflector_verify_methods]
+          verifies = inflector.options.verify_methods if verifies.nil?
+          is_lazy  = options[:inflector_lazy_methods]
+          is_lazy  = inflector.options.lazy_methods if is_lazy.nil?
+
+          return subopts if (verifies && !respond_to?(:i18n_inflector_kinds))
+
+          i18n_inflector_kinds.each_pair do |kind, meth|
+            next if meth.nil?                                   # kind is registered but disabled from usage
+            next if verifies && !respond_to?(meth)
+            obj = method(meth)
+            obj = obj.call { next kind, locale } unless is_lazy # lazy_methods is disabled
+            subopts[kind] = obj
           end
           return subopts
         end
-        
-      end # Translate
-  
-    end
-  end
-end
+
+      end # module InflectedTranslate
+
+    end # module Rails
+  end # module Inflector
+end # module I18n

data/lib/i18n-inflector-rails/options.rb

@@ -10,43 +10,95 @@
 
 module I18n
   module Inflector
-    module Rails
-      
-      # This module adds options to {I18n::Inflector::InflectionOptions}
-      module AdditionalOptions
-
-        attr_writer :verify_methods
-
-        # When this is set to +true+ then
-        # inflection works a bit slower but
-        # checks whether any method exists before
-        # calling it. This switch is by default set
-        # to +false+.
-        # 
-        # By turning this switch on you're sure that
-        # there will be no +NameError+ (no method) exception
-        # raised during translation.
-        # 
-        # Alternatively you can turn this locally,
-        # for the specified translate call, by setting
-        # <tt>:inflector_verify_methods</tt> option to +true+.
-        #    
-        # @example Globally enabling methods verification
-        #   I18n.inflector.options.verify_methods = true
-        # @example Locally enabling methods verification
-        #   translate('welcome', :inflector_verify_methods => true)
-        def verify_methods
-          @verify_methods || false
-        end 
-
-        # This method resets inflector's
-        # switches to default values.
-        def reset
-          @verify_methods = false
-          super
-        end
 
+    # This module adds options to {I18n::Inflector::InflectionOptions}
+    class InflectionOptions
+
+      # When this is set to +true+ then
+      # inflection works a bit slower but
+      # checks whether any method exists before
+      # calling it.
+      # 
+      # This switch is by default set
+      # to +false+.
+      # 
+      # By turning this switch on you're sure that
+      # there will be no +NameError+ (no method) exception
+      # raised during translation.
+      # 
+      # Alternatively you can turn this on locally,
+      # for the specified translation call, by setting
+      # <tt>:inflector_verify_methods</tt> option to +true+.
+      # 
+      # @example Globally enabling methods verification
+      #   I18n.inflector.options.verify_methods = true
+      # @example Locally enabling methods verification
+      #   translate('welcome', :inflector_verify_methods => true)
+      attr_accessor :verify_methods
+
+      # When this is set to +true+ then
+      # each time infleciton method is registered
+      # it becomes a helper method so it's available in
+      # a view.
+      # 
+      # This switch is by default set
+      # to +true+.
+      # 
+      # Setting this switch locally,
+      # for the specified translation call, using
+      # <tt>:inflector_auto_helper</tt> option will
+      # have no effect.
+      # 
+      # @example Globally disabling automatic setting of helpers
+      #   I18n.inflector.options.auto_helper = false
+      attr_accessor :auto_helper
+
+      # When this is set to +true+ then
+      # each time an infleciton method is used to obtain
+      # value for the associated kind it evaluates lazy.
+      # That means the method object is passed to the
+      # translation routines and it is evaluated when there
+      # is a need. If this is set to +false+ then
+      # evaluation takes place before calling Inflector's
+      # translation method and inflection options are passed
+      # as symbols, not as method objects.
+      # 
+      # This switch is by default set
+      # to +true+. By disabling it you may experience
+      # some negative performance impact when many
+      # inflection methods are registered. That is because
+      # the lazy evaluation causes calling only those methods
+      # that are needed by internal interpolation routines
+      # of the Inflector. For instance, if in some pattern
+      # only the kind "gender" is used then there is no
+      # need to call inflection methods for other kinds.
+      # When lazy evaluation is disabled then all inflection
+      # methods have to be called before passing control
+      # to translation routines, since this plug-in does not
+      # analyze contents of inflection patterns or keys.
+      # 
+      # Alternatively you can turn this off locally,
+      # for the specified translation call, by setting
+      # <tt>:inflector_lazy_methods</tt> option to +false+.
+      # 
+      # @example Globally disabling lazy evaluation of kinds
+      #   I18n.inflector.options.lazy_methods = false
+      # @example Locally disabling lazy evaluation of kinds
+      #   translate('welcome', :inflector_lazy_methods => false)
+      attr_accessor :lazy_methods
+
+      # @private
+      alias_method :_rai_orig_reset, :reset
+
+      # This method resets inflector's
+      # switches to default values.
+      def reset
+        @verify_methods = false
+        @auto_helper    = true
+        @lazy_methods   = true
+        _rai_orig_reset
       end
-    end
-  end
-end
+
+    end # class InflectionOptions
+  end # module Inflector
+end # module I18n

data/lib/i18n-inflector-rails/version.rb

@@ -15,7 +15,7 @@ module I18n
       # @private
       EMAIL       = 'pw@gnu.org'
       # @private
-      VERSION     = '0.2.0'
+      VERSION     = '1.0.0'
       # @private
       NAME        = 'i18n-inflector-rails'
       # @private

data/spec/inflector_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 class ApplicationController < ActionController::Base;       end
 class InflectedTranslateController < ApplicationController; end
+class InflectedStrictController    < ApplicationController; end
 
 describe I18n.inflector.options.class do
 
@@ -25,28 +26,47 @@ describe ApplicationController do
 
     I18n.locale = :xx
     I18n.backend.store_translations(:xx, :i18n => { :inflections => {
-                                                      :gender => {
+                                                     :gender => {
+                                                       :m => 'male',
+                                                       :f => 'female',
+                                                       :n => 'neuter',
+                                                       :s => 'strange',
+                                                       :masculine  => '@m',
+                                                       :feminine   => '@f',
+                                                       :neuter     => '@n',
+                                                       :neutral    => '@neuter',
+                                                       :default    => 'neutral' },
+                                                      :time => {
+                                                        :present  => 'present',
+                                                        :past     => 'past',
+                                                        :future   => 'future'},
+                                                      :@gender => {
                                                         :m => 'male',
                                                         :f => 'female',
+                                                        :d => 'dude',
+                                                        :x => 'tester',
                                                         :n => 'neuter',
-                                                        :s => 'strange',
-                                                        :masculine  => '@m',
-                                                        :feminine   => '@f',
-                                                        :neuter     => '@n',
-                                                        :neutral    => '@neuter',
-                                                        :default    => 'neutral' },
+                                                        :default => 'n'},
                                                       :person => {
                                                         :i   => 'I',
                                                         :you => 'You',
-                                                        :it  => 'It'}
+                                                        :it  => 'It'},
+                                                      :@person => {
+                                                        :i   => 'I',
+                                                        :you => 'You',
+                                                        :it  => 'It'},
                                        }   })
-   I18n.backend.store_translations(:xx, 'welcome' => 'Dear @{f:Lady|m:Sir|n:You|All}!')
-   I18n.backend.store_translations(:xx, 'to_be'   => 'Oh @{i:I am|you:You are|it:It is}')
+
+   I18n.backend.store_translations(:xx, 'welcome'         => 'Dear @{f:Lady|m:Sir|n:You|All}!')
+   I18n.backend.store_translations(:xx, 'welcome_strict'  => 'Dear @gender{f:Lady|m:Sir|d:Dude|n:You|All}!')
+   I18n.backend.store_translations(:xx, 'to_be'           => 'Oh @{i:I am|you:You are|it:It is}')
+   I18n.backend.store_translations(:xx, 'to_be_strict'    => 'Oh @person{i:me|you:You are|it:It is}')
+   I18n.backend.store_translations(:xx, 'hitime'          => '@{present,past,future:~}!')
 
   end
 
   describe ".inflection_method" do
-    
+
     before do
       class AnotherController < InflectedTranslateController; end
     end
@@ -54,28 +74,33 @@ describe ApplicationController do
     it "should be albe to assign a mehtod to the inflection kind" do
       lambda{AnotherController.inflection_method(:users_gender => :gender)}.should_not raise_error
     end
-    
+
+    it "should be albe to assign a mehtod to the strict inflection kind" do
+      lambda{AnotherController.inflection_method(:users_gender => :@gender)}.should_not raise_error
+    end
+
     it "should be albe to accept single Symbol argument" do
       lambda{AnotherController.inflection_method(:time)}.should_not raise_error
+      lambda{AnotherController.inflection_method(:@time)}.should_not raise_error
     end
 
     it "should be albe to accept single String argument" do
       lambda{AnotherController.inflection_method('time')}.should_not raise_error
+      lambda{AnotherController.inflection_method('@time')}.should_not raise_error
     end
 
     it "should be albe to accept Array<Symbol> argument" do
       lambda{AnotherController.inflection_method([:time])}.should_not raise_error
-    end
-
-    it "should be albe to assign a mehtod to the inflection kind with proc" do
-      lambda{AnotherController.inflection_method(:users_gender => :gender){|a,b,c,d,e| :m} }.should_not raise_error
-      lambda{AnotherController.inflection_method(:time){|a,b,c,d,e| :m} }.should_not raise_error
+      lambda{AnotherController.inflection_method([:@time])}.should_not raise_error
     end
 
     it "should raise an error when method name is wrong" do
       lambda{AnotherController.inflection_method}.should                  raise_error
       lambda{AnotherController.inflection_method(nil => :blabla)}.should  raise_error
       lambda{AnotherController.inflection_method(:blabla => nil)}.should  raise_error
+      lambda{AnotherController.inflection_method(nil => :@blabla)}.should raise_error
+      lambda{AnotherController.inflection_method(:@blabla => nil)}.should raise_error
+      lambda{AnotherController.inflection_method(:"@")}.should            raise_error
       lambda{AnotherController.inflection_method({''=>''})}.should        raise_error
       lambda{AnotherController.inflection_method(nil => nil)}.should      raise_error
       lambda{AnotherController.inflection_method(nil)}.should             raise_error
@@ -88,99 +113,155 @@ describe ApplicationController do
   end
 
   describe ".no_inflection_method" do
-    
+
     before do
       class AnotherController < InflectedTranslateController; end
     end
 
-    it "should be albe to spit a mehtod of the inflection kind" do
+    it "should be albe to split a mehtod of the inflection kind" do
       lambda{AnotherController.no_inflection_method(:users_gender)}.should_not raise_error
     end
-    
+
     it "should be albe to accept single Symbol argument" do
       lambda{AnotherController.no_inflection_method(:time)}.should_not raise_error
+      lambda{AnotherController.no_inflection_method(:@time)}.should_not raise_error
     end
 
     it "should be albe to accept single String argument" do
       lambda{AnotherController.no_inflection_method('time')}.should_not raise_error
+      lambda{AnotherController.no_inflection_method('@time')}.should_not raise_error
     end
 
     it "should be albe to accept Array<Symbol> argument" do
       lambda{AnotherController.no_inflection_method([:time])}.should_not raise_error
+      lambda{AnotherController.no_inflection_method([:@time])}.should_not raise_error
+    end
+
+    it "should raise an error when method name is wrong" do
+      lambda{AnotherController.no_inflection_method}.should         raise_error
+      lambda{AnotherController.no_inflection_method(nil)}.should    raise_error
+      lambda{AnotherController.no_inflection_method([nil])}.should  raise_error
+      lambda{AnotherController.no_inflection_method(:"@")}.should   raise_error
+      lambda{AnotherController.no_inflection_method([''])}.should   raise_error
+      lambda{AnotherController.no_inflection_method([])}.should     raise_error
+      lambda{AnotherController.no_inflection_method({})}.should     raise_error
+    end
+
+  end
+
+  describe ".no_inflection_kind" do
+
+    before do
+      class AnotherController < InflectedTranslateController; end
+    end
+
+    it "should be albe to spit a mehtod of the inflection kind" do
+      lambda{AnotherController.no_inflection_kind(:gender)}.should_not raise_error
+      lambda{AnotherController.no_inflection_kind(:@gender)}.should_not raise_error
+    end
+
+    it "should be albe to accept single Symbol argument" do
+      lambda{AnotherController.no_inflection_kind(:time)}.should_not raise_error
+      lambda{AnotherController.no_inflection_kind(:@time)}.should_not raise_error
+    end
+
+    it "should be albe to accept single String argument" do
+      lambda{AnotherController.no_inflection_kind('time')}.should_not raise_error
+      lambda{AnotherController.no_inflection_kind('@time')}.should_not raise_error
+    end
+
+    it "should be albe to accept Array<Symbol> argument" do
+      lambda{AnotherController.no_inflection_kind([:time])}.should_not raise_error
+      lambda{AnotherController.no_inflection_kind([:@time])}.should_not raise_error
     end
 
     it "should raise an error when method name is wrong" do
-      lambda{AnotherController.no_inflection_method}.should                  raise_error
-      lambda{AnotherController.no_inflection_method(nil)}.should             raise_error
-      lambda{AnotherController.no_inflection_method([nil])}.should           raise_error
-      lambda{AnotherController.no_inflection_method([''])}.should            raise_error
-      lambda{AnotherController.no_inflection_method([])}.should              raise_error
-      lambda{AnotherController.no_inflection_method({})}.should              raise_error
+      lambda{AnotherController.no_inflection_kind}.should        raise_error
+      lambda{AnotherController.no_inflection_kind(nil)}.should   raise_error
+      lambda{AnotherController.no_inflection_kind(:"@")}.should  raise_error
+      lambda{AnotherController.no_inflection_kind([nil])}.should raise_error
+      lambda{AnotherController.no_inflection_kind([''])}.should  raise_error
+      lambda{AnotherController.no_inflection_kind([])}.should    raise_error
+      lambda{AnotherController.no_inflection_kind({})}.should    raise_error
     end
 
   end
 
-  describe ".i18n_inflector_methods" do
+  describe ".i18n_inflector_kinds" do
 
     before do
       InflectedTranslateController.inflection_method(:users_gender => :gender)
       InflectedTranslateController.inflection_method(:time) 
-      @expected_hash = {:users_gender=>{:kind=>:gender, :proc=>nil},
-                        :time=>{:kind=>:time, :proc=>nil}}   
+      @expected_hash =  { :gender => :users_gender, :time   => :time }
     end
 
     it "should be callable" do
-      lambda{InflectedTranslateController.i18n_inflector_methods}.should_not raise_error
+      lambda{InflectedTranslateController.i18n_inflector_kinds}.should_not raise_error
     end
 
     it "should be able to read methods assigned to inflection kinds" do
-      InflectedTranslateController.i18n_inflector_methods.should ==  @expected_hash
+      InflectedTranslateController.i18n_inflector_kinds.should ==  @expected_hash
     end
 
   end
-  
+
   describe "controller instance methods" do
-  
+
     before do
 
       class InflectedTranslateController
-        inflection_method :users_gender => :gender
-        def users_gender;     :m                    end
-        def time;             :present              end
-        def translated_male;  translate('welcome')  end
-        def t_male;           t('welcome')          end
+        def trn(*args); translate(*args)  end
+        def t_male; t('welcome')          end
+        def users_gender; :m              end
+        def time
+          kind, locale = yield
+          kind == :time ? :past : nil
+        end
       end
 
-      class InflectedLambdedController < InflectedTranslateController
-        inflection_method(:person) {:it}
-        def person; :you                            end
-        def translated_person;  translate('to_be')  end
+      class InflectedStrictController
+        inflection_method :@gender
+
+        def gender; :m end
+        def trn(*args);  translate(*args) end
       end
 
-      class InflectedLambdedPrimController < InflectedLambdedController
-        inflection_method :person
+      class InflectedStrictOverrideController < InflectedTranslateController
+        inflection_method :users_dude     => :@gender
+        inflection_method :users_female   => :gender
+        inflection_method :person_i       => :person
+
+        no_inflection_method_for :@person
+
+        def users_female; :f end
+        def users_dude;   :d end
+        def person_i;     :i end
       end
 
       class NomethodController < InflectedTranslateController
         inflection_method :nonexistent => :gender
-        def translate_male;     translate('welcome') end
-        def translate_male_opt; translate('welcome', :inflector_verify_methods => true) end
+      end
+
+      class MethodDisabledController < InflectedTranslateController
+        no_inflection_method :users_gender
       end
 
       @controller             = InflectedTranslateController.new
-      @person_controller      = InflectedLambdedController.new
-      @personprim_controller  = InflectedLambdedPrimController.new
+      @strict_controller      = InflectedStrictController.new
+      @strict_over_controller = InflectedStrictOverrideController.new
+      @disabled_controller    = MethodDisabledController.new
       @nomethod_controller    = NomethodController.new
 
-      @expected_hash = {:users_gender=>{:kind=>:gender, :proc=>nil},
-                        :time=>{:kind=>:time, :proc=>nil}}
-
     end
 
-    describe "#i18n_inflector_methods" do
+    describe "#i18n_inflector_kinds" do
+
+      before do
+        @expected_hash = {:gender => :users_gender, :time => :time }
+      end
 
       it "should be able to read methods assigned to inflection kinds" do
-        @controller.i18n_inflector_methods.should == @expected_hash
+        @controller.i18n_inflector_kinds.should == @expected_hash
       end
 
     end
@@ -188,25 +269,35 @@ describe ApplicationController do
     describe "#translate" do
 
       it "should translate using inflection patterns and pick up the right value" do
-        @controller.translated_male.should == 'Dear Sir!'
+        @controller.trn('welcome').should == 'Dear Sir!'
+        @controller.trn('welcome_strict').should == 'Dear Sir!'
+        @strict_controller.trn('welcome_strict').should == 'Dear Sir!'
       end
 
-      it "should make use of blocks if assigned to inflection methods" do
-        @person_controller.translated_person.should == 'Oh It is'
+      it "should make use of a block passed to inflection method" do
+        @controller.trn('hitime').should == 'past!'
       end
 
       it "should make use of inherited inflection method assignments" do
-        @person_controller.translated_male.should == 'Dear Sir!'
+        @strict_over_controller.trn('hitime').should == 'past!'
       end
 
       it "should make use of overriden inflection method assignments" do
-        @personprim_controller.translated_person.should == 'Oh You are'
+        @strict_over_controller.trn('welcome').should == 'Dear Lady!'
+      end
+
+      it "should prioritize strict kinds when both inflection options are passed" do
+        @strict_over_controller.trn('welcome_strict').should == 'Dear Dude!'
+        @strict_over_controller.trn('welcome').should == 'Dear Lady!'
+      end
+
+      it "should use regular kind option when strict kind option is missing" do
+        @strict_over_controller.trn('to_be').should == 'Oh I am'
+        @strict_over_controller.trn('to_be_strict').should == 'Oh me'
       end
-      
+
       it "should make use of disabled inflection method assignments" do
-        InflectedLambdedPrimController.no_inflection_method :person
-        @personprim_controller.translated_person.should == 'Oh '
-        @person_controller.translated_person.should == 'Oh It is'
+        @disabled_controller.trn('welcome').should == 'Dear You!'
       end
 
       it "should raise exception when method does not exists" do
@@ -214,19 +305,23 @@ describe ApplicationController do
       end
 
       it "should not raise when method does not exists and verify_methods is enabled" do
-        lambda{@nomethod_controller.translate_male_opt}.should_not raise_error(NameError)
+        lambda{@nomethod_controller.trn('welcome', :inflector_verify_methods => true)}.should_not raise_error(NameError)
         I18n.inflector.options.verify_methods = true
-        lambda{@nomethod_controller.translate_male}.should_not raise_error(NameError)
+        lambda{@nomethod_controller.trn('welcome')}.should_not raise_error(NameError)
+      end
+
+      it "should translate with the :inflector_lazy_methods switch turned off" do
+        @strict_over_controller.trn('welcome', :inflector_lazy_methods => false).should == 'Dear Lady!'
       end
 
     end
-    
+
     describe "#t" do
-      
+
       it "should call translate" do
         @controller.t_male.should == 'Dear Sir!'
       end
-      
+
     end
 
   end

metadata

@@ -3,10 +3,10 @@ name: i18n-inflector-rails
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 2
   - 0
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - "Pawe\xC5\x82 Wilk"
@@ -34,7 +34,7 @@ cert_chain:
   NK3TIZaPCh1S2/ES6wXNvjQ+5EnEEL9j/pSEop9DYEBPaM2WDVR5i0jJTAaRWw==
   -----END CERTIFICATE-----
 
-date: 2011-01-16 00:00:00 +01:00
+date: 2011-02-15 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,8 +46,8 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 2
-        - 0
-        version: "2.0"
+        - 3
+        version: "2.3"
   type: :runtime
   prerelease: false
   version_requirements: *id001
@@ -219,7 +219,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2397947838501194867
+      hash: 2455851808387903881
       segments: 
       - 0
       version: "0"
@@ -228,7 +228,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2397947838501194867
       segments: 
       - 0
       version: "0"