i18n-inflector-rails 0.1.0

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

@@ -0,0 +1,185 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains I18n::Backend::Inflector::Rails module,
+# which extends ActionView::Helpers::TranslationHelper
+# by adding the ability to interpolate patterns containing
+# inflection tokens defined in translation data.
+
+module I18n
+  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
+        end
+
+        # @private
+        def self.included(base)
+          base.helper_method(:i18n_inflector_methods)
+        end
+  
+      end # instance methods
+  
+      # This module contains class methods for ActionController.
+      module ClassMethods
+  
+        # This method reads the internal Hash +i18n_inflector_methods+ 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)
+        end
+
+        # This method allows to assign methods (typically attribute readers)
+        # to inflection kinds that are defined in translation files and
+        # supported by {I18n::Inflector} module. Methods registered like that
+        # will be tracked when {translate} is used and their returning values will be
+        # passed as inflection options along with assigned kinds. If the kind is not
+        # given then method assumes that the name of a kind is the same as the given
+        # name of a method.
+        # 
+        # @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
+        # @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 }
+          end
+
+          if (assignment.nil? || !assignment.is_a?(Hash) || assignment.empty?)
+            raise I18n::Inflector::Rails::BadInflectionMethod.new(assignment)
+          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}")
+            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
+          end
+        end
+        alias_method :inflection_methods, :inflection_method
+
+        # This method allows to remove methods from sets
+        # created using {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
+        # 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
+        # @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 ||= {}
+          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
+            raise I18n::Inflector::Rails::BadInflectionMethod.new(meth) if meth.empty?
+            @i18n_inflector_methods[meth.to_sym] = nil
+           end
+        end
+        alias_method :no_inflection_methods, :no_inflection_method
+
+      end # class methods
+  
+      # This module contains a version of {translate} method that
+      # tries to use +i18n_inflector_methods+ 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
+        # {ActionView::Helpers::TranslationHelper#translate}.
+        # 
+        # @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
+        def translate(*args)
+          test_locale = args.last.is_a?(Hash) ? args.last[:locale] : nil
+          test_locale ||= I18n.locale
+          return super unless I18n.backend.inflector.inflected_locale?(test_locale)
+
+          # collect inflection variables that are present in this context
+          subopts = t_prepare_inflection_options
+  
+          # jump to original translate if no variables are present
+          return super if subopts.empty?
+  
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          args.push subopts.merge(options)
+          super
+        end
+        
+        alias_method :t, :translate
+  
+        protected
+  
+        # This method tries to read +i18n_inflector_methods+ available in the current context.
+        # 
+        # @return [Hash] the inflection options (<tt>kind => value</tt>)
+        def t_prepare_inflection_options
+          subopts = {}
+          i18n_inflector_methods.each_pair do |m, obj|
+            next if obj.nil?
+            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
+          end
+          return subopts
+        end
+        
+      end # Translate
+  
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file loads I18n::Inflector::Rails goodies into Rails.
+
+module I18n
+  module Inflector
+    module Rails
+
+      class Railtie < ::Rails::Engine
+
+        initializer :before_initialize do
+          ActionController::Base.send(:extend,  I18n::Inflector::Rails::ClassMethods)
+          ActionController::Base.send(:include, I18n::Inflector::Rails::InstanceMethods)
+        end
+
+        initializer :after_initialize do
+          ActionController::Base.helper I18n::Inflector::Rails::InflectedTranslate
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains version information.
+
+module I18n
+  module Inflector
+    module Rails
+
+      # @private
+      DEVELOPER   = 'Paweł Wilk'
+      # @private
+      EMAIL       = 'pw@gnu.org'
+      # @private
+      VERSION     = '0.1.0'
+      # @private
+      NAME        = 'i18n-inflector-rails'
+      # @private
+      SUMMARY     = 'I18n Inflector bindings for Rails'
+      # @private
+      URL         = 'https://rubygems.org/gems/i18n-inflector-rails/'
+      # @private
+      DESCRIPTION = 'This plug-in provides I18n Inflector module bindings for Rails.'
+
+    end
+  end
+end

data/spec/inflector_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+class ApplicationController < ActionController::Base;       end
+class InflectedTranslateController < ApplicationController; end
+
+describe ApplicationController do
+
+  before do
+
+    I18n.locale = :xx
+    I18n.backend.store_translations(:xx, :i18n => { :inflections => {
+                                                      :gender => {
+                                                        :m => 'male',
+                                                        :f => 'female',
+                                                        :n => 'neuter',
+                                                        :s => 'strange',
+                                                        :masculine  => '@m',
+                                                        :feminine   => '@f',
+                                                        :neuter     => '@n',
+                                                        :neutral    => '@neuter',
+                                                        :default    => 'neutral' },
+                                                      :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}')
+
+  end
+  
+  describe ".inflection_method" do
+    
+    before do
+      class AnotherController < InflectedTranslateController; end
+    end
+
+    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 accept single Symbol argument" do
+      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
+    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
+    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({''=>''})}.should        raise_error
+      lambda{AnotherController.inflection_method(nil => nil)}.should      raise_error
+      lambda{AnotherController.inflection_method(nil)}.should             raise_error
+      lambda{AnotherController.inflection_method([nil])}.should           raise_error
+      lambda{AnotherController.inflection_method([''])}.should            raise_error
+      lambda{AnotherController.inflection_method([])}.should              raise_error
+      lambda{AnotherController.inflection_method({})}.should              raise_error
+    end
+
+  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
+      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
+    end
+
+    it "should be albe to accept single String argument" do
+      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
+    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
+    end
+
+  end
+
+  describe ".i18n_inflector_methods" 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}}   
+    end
+
+    it "should be callable" do
+      lambda{InflectedTranslateController.i18n_inflector_methods}.should_not raise_error
+    end
+
+    it "should be able to read methods assigned to inflection kinds" do
+      InflectedTranslateController.i18n_inflector_methods.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
+      end
+
+      class InflectedLambdedController < InflectedTranslateController
+        inflection_method(:person) {:it}
+        def person; :you                            end
+        def translated_person;  translate('to_be')  end
+      end
+
+      class InflectedLambdedPrimController < InflectedLambdedController
+        inflection_method :person
+      end
+
+      @controller             = InflectedTranslateController.new
+      @person_controller      = InflectedLambdedController.new
+      @personprim_controller  = InflectedLambdedPrimController.new
+      
+      @expected_hash = {:users_gender=>{:kind=>:gender, :proc=>nil},
+                        :time=>{:kind=>:time, :proc=>nil}}
+
+    end
+
+    describe "#i18n_inflector_methods" do
+
+      it "should be able to read methods assigned to inflection kinds" do
+        @controller.i18n_inflector_methods.should == @expected_hash
+      end
+
+    end
+
+    describe "#translate" do
+
+      it "should translate using inflection patterns and pick up the right value" do
+        @controller.translated_male.should == 'Dear Sir!'
+      end
+
+      it "should make use of blocks if assigned to inflection methods" do
+        @person_controller.translated_person.should == 'Oh It is'
+      end
+
+      it "should make use of inherited inflection method assignments" do
+        @person_controller.translated_male.should == 'Dear Sir!'
+      end
+
+      it "should make use of overriden inflection method assignments" do
+        @personprim_controller.translated_person.should == 'Oh You are'
+      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'
+      end
+
+    end
+    
+    describe "#t" do
+      
+      it "should call translate" do
+        @controller.t_male.should == 'Dear Sir!'
+      end
+      
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec/core'
+require 'i18n-inflector-rails'