rich_i18n 1.0.3

data/lib/rich/i18n/core.rb

@@ -0,0 +1,8 @@
+
+(required_files = %w(object string enriched_string)).each do |file|
+  require "rich/i18n/core/#{file}"
+end
+
+Dir[File.join(File.dirname(__FILE__), "core", "*.rb")].each do |file|
+  require file unless required_files.include?(File.basename file, ".rb")
+end

data/lib/rich/i18n/core/array.rb

@@ -0,0 +1,8 @@
+
+require "rich/i18n/core/enumerable/methods"
+require "rich/i18n/core/array/merging"
+
+class Array
+  include Rich::I18n::Core::Enumerable::Methods
+  include Rich::I18n::Core::Array::Merging
+end

data/lib/rich/i18n/core/array/merging.rb

@@ -0,0 +1,29 @@
+
+module Rich
+  module I18n
+    module Core
+      module Array
+        module Merging
+        
+          def self.included(base)
+            base.class_eval do
+              alias_method_chain :join, :rich_i18n
+            end
+          end
+        
+          def join_with_rich_i18n(sep = "")
+            if size == 1 && first.is_a?(EnrichedString)
+              first
+            else
+              merged_strings = dup
+              result = join_without_rich_i18n(sep)
+              result.merged_strings = merged_strings
+              result
+            end
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/core/enriched_string.rb

@@ -0,0 +1,28 @@
+
+module Rich
+  module I18n
+    module Core
+      class EnrichedString < ::String
+      
+        def initialize(s = "", meta_data = nil)
+          super s
+          @meta_data = meta_data || (s.meta_data.dup unless (s.meta_data.nil? rescue true)) || {}
+        end
+      
+        def initialize_copy_with_rich_i18n(s)
+          result = super(s)
+          result.meta_data = self.meta_data.dup
+        end
+      
+        def to_es
+          @meta_data.filled? and ::Rich::I18n::Engine.can_enrich_output? ? 
+            "<i18n #{@meta_data.collect{|k, v| "data-#{k}=#{v.inspect}"}.join(" ")}>#{to_s}</i18n>" :
+            to_s
+        end
+        
+      end
+    end
+  end
+end
+
+EnrichedString = Rich::I18n::Core::EnrichedString

data/lib/rich/i18n/core/enumerable/methods.rb

@@ -0,0 +1,16 @@
+
+module Rich
+  module I18n
+    module Core
+      module Enumerable
+        module Methods
+        
+          def filled?
+            !empty?
+          end
+                
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/core/erb.rb

@@ -0,0 +1,6 @@
+
+require "rich/i18n/core/erb/output"
+
+class ERB::Compiler::Buffer
+  include Rich::I18n::Core::ERB::Output
+end

data/lib/rich/i18n/core/erb/output.rb

@@ -0,0 +1,22 @@
+
+module Rich
+  module I18n
+    module Core
+      module ERB
+        module Output
+        
+          def self.included(base)
+            base.class_eval do
+              alias_method_chain :push, :rich_i18n
+            end
+          end
+      
+          def push_with_rich_i18n(cmd)
+            push_without_rich_i18n cmd.match(/^#{@compiler.insert_cmd}\(\(.*\)\.to_s\)$/) ? cmd.gsub(/to_s\)$/, "to_output)") : cmd
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/core/hash.rb

@@ -0,0 +1,6 @@
+
+require "rich/i18n/core/enumerable/methods"
+
+class Hash
+  include Rich::I18n::Core::Enumerable::Methods
+end

data/lib/rich/i18n/core/nil_class.rb

@@ -0,0 +1,8 @@
+
+class NilClass
+
+  def filled?
+    false
+  end
+
+end

data/lib/rich/i18n/core/object.rb

@@ -0,0 +1,6 @@
+
+require "rich/i18n/core/object/output"
+
+class Object
+  include Rich::I18n::Core::Object::Output
+end

data/lib/rich/i18n/core/object/output.rb

@@ -0,0 +1,20 @@
+
+module Rich
+  module I18n
+    module Core
+      module Object
+        module Output
+        
+          def to_output
+            to_es
+          end
+        
+          def to_es
+            to_s
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/core/string.rb

@@ -0,0 +1,10 @@
+
+require "rich/i18n/core/string/inflections"
+require "rich/i18n/core/string/internationalization"
+require "rich/i18n/core/string/enrichments"
+
+class String
+  include Rich::I18n::Core::String::Inflections
+  include Rich::I18n::Core::String::Internationalization
+  include Rich::I18n::Core::String::Enrichments
+end

data/lib/rich/i18n/core/string/enrichments.rb

@@ -0,0 +1,68 @@
+
+module Rich
+  module I18n
+    module Core
+      module String
+        module Enrichments
+        
+          # TODO: override String interpolation (e.g. "foo #{"bar".t}")
+        
+          def self.included(base)
+            base.class_eval do
+              alias_method :add_without_rich_i18n, :+
+              alias_method :+, :add_with_rich_i18n
+              alias_method_chain :concat, :rich_i18n
+              undef_method :<<
+              alias_method :<<, :concat_with_rich_i18n
+            
+              alias_method_chain :initialize_copy, :rich_i18n
+
+              attr_accessor :meta_data
+              attr_accessor :merged_strings
+            end
+          end
+        
+          def initialize_copy_with_rich_i18n(s)
+            result = initialize_copy_without_rich_i18n(s)
+            result.merged_strings = self.merged_strings.try :dup
+          end
+
+          def add_with_rich_i18n(other)
+            strings, result = self.merged_strings.try(:dup) || [], add_without_rich_i18n(other)
+          
+            if (result.merged_strings = strings).empty?
+              result.merged_strings << self.dup
+            end
+            unless other.empty?
+              result.merged_strings << other
+            end
+          
+            result
+          end
+
+          def concat_with_rich_i18n(other_or_fixnum)
+            string, result = self.dup, concat_without_rich_i18n(other_or_fixnum)
+          
+            if (result.merged_strings ||= []).empty? and !string.empty?
+              result.merged_strings << string
+            end
+            result.merged_strings << other_or_fixnum.dup unless other_or_fixnum.empty?
+          
+            result
+          end
+        
+          def enriched_string?
+            is_a?(EnrichedString) or (merged_strings || []).any?(&:enriched_string?)
+          end
+        
+          def to_output
+            merged_strings.blank? ?
+              to_es :
+              merged_strings.collect(&:to_output).join
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/core/string/inflections.rb

@@ -0,0 +1,42 @@
+
+module Rich
+  module I18n
+    module Core
+      module String
+        module Inflections
+          
+          # -- start FIXME: these methods are also defined in rich_pluralization
+        
+          def upcase_first
+            empty? ?
+              self :
+              self[0].chr.capitalize + self[1, size]
+          end
+  
+          def cp_case(s)
+            send((:downcase unless s.dup.downcase!) || (:upcase unless s.dup.upcase!) || (:upcase_first unless s.dup.upcase_first!) || :to_s)
+          end
+  
+          def upcase_first!
+            self == (result = upcase_first) ? nil : replace(result)
+          end
+  
+          def cp_case!(s)
+            self == (result = cp_case(s))   ? nil : replace(result)
+          end
+          
+          # -- end
+  
+          def singularize!
+            downcase == (result = singularize).downcase ? nil : replace(result)
+          end
+  
+          def pluralize!
+            downcase == (result = pluralize).downcase   ? nil : replace(result)
+          end
+                
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/core/string/internationalization.rb

@@ -0,0 +1,82 @@
+
+module Rich
+  module I18n
+    module Core
+      module String
+        module Internationalization
+
+          def self.included(base)
+            base.send :include, InstanceMethods
+          end
+        
+          module InstanceMethods
+            def t(options = {})
+              self.split(" ").collect do |string|
+                key              = string.include?(".") ? string.dup : "word.#{string}"
+                default          = key.split(".").last
+                translating_word = key.starts_with?("word.")
+    
+                key.downcase!
+                options[:pluralize]            = "".respond_to?(:pl) && (options[:pluralize].nil? || options[:pluralize])
+                options[:translate_callback] ||= LOGGER_PROC if RAILS_ENV == "development"
+
+                if options.include? :default
+                  options[:default] = [options[:default]].flatten << default.humanize
+                  s = i18n_t key, options
+                  s = s[:_base] if s.is_a?(Hash)
+                  value = s.dup
+                else
+                  s = i18n_t key, options.merge({:default => translating_word ? "" : default.humanize})
+                  value = s.dup
+    
+                  if translating_word
+                    unless (translated = !s.empty?) or !"".respond_to?(:pl)
+                      key.singularize!
+                      s = i18n_t key, options.merge({:default => ""})
+                      value = s.dup
+                    end
+      
+                    if s.empty?
+                      s = default.humanize
+                      value = s.dup
+                    else
+                      s = s.pl(options[:count]) unless !options[:pluralize] or (options[:count].nil? and default.dup.pluralize!)
+                    end
+                  end
+                end
+      
+                unless s.gsub!(/^=\s+/, "")
+                  s.cp_case! options[:capitalize] ? default.capitalize : default
+                end
+              
+                EnrichedString.new s, {:key => string, :actual_key => key, :actual_value => value}
+      
+              end.join(" ")
+            end
+          
+          private
+
+            RICH_I18N_OPTIONS = [:count, :pluralize, :capitalize, :translate_callback]
+            LOGGER_PROC = Proc.new{|translation, key, options| puts "INFO: I18n.t #{key.inspect}, #{options.inspect}"}
+          
+            @@i18n_translations = {}
+
+            def i18n_t(key, opts = {})
+              options = opts.inject({}) do |hash, (k, v)|
+                          hash[k] = v.is_a?(String) && v.include?("<i18n") ? v.gsub(/(\<i18n[^\>]+\>)|(\<\/i18n\>)/, "") : v unless RICH_I18N_OPTIONS.include?(k)
+                          hash
+                        end
+            
+              k = "#{key.inspect}, #{options.inspect}"
+              translation = (@@i18n_translations[k] ||= I18n.t(key, options).dup)
+              opts[:translate_callback].try :call, translation, key, options
+    
+              translation
+            end
+          end
+                
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/core/symbol.rb

@@ -0,0 +1,6 @@
+
+require "rich/i18n/core/symbol/internationalization"
+
+class Symbol
+  include Rich::I18n::Core::Symbol::Internationalization
+end

data/lib/rich/i18n/core/symbol/internationalization.rb

@@ -0,0 +1,16 @@
+
+module Rich
+  module I18n
+    module Core
+      module Symbol
+        module Internationalization
+        
+          def t(options = {})
+            to_s.t options
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/rich/i18n/engine.rb

@@ -0,0 +1,31 @@
+
+module Rich
+  module I18n
+    module Engine
+      extend self
+    
+      attr_accessor :enable_enriched_output
+    
+      def init(test_class = nil)
+        if test_class
+          test_locale = test_class.name.match(/(Rich\:\:I18n\:\:Test\:\:Locales\:\:)(\w+)/).captures[1].downcase.to_sym
+          
+          I18n.load_path  =    [File.join(File.dirname(__FILE__), "..", "..", "..", "locales", "#{test_locale}.yml")]
+        else
+          I18n.load_path += Dir[File.join(File.dirname(__FILE__), "..", "..", "..", "locales", "*.yml")]
+        end
+
+        I18n.backend.reload!
+        
+        test_locale
+      end
+      
+      def can_enrich_output?
+        !enable_enriched_output.blank? and (enable_enriched_output.is_a?(Symbol) ? (send(enable_enriched_output) rescue false) : enable_enriched_output)
+      end
+    
+    end
+  end
+end
+
+Rich::I18n::Engine.init

data/lib/rich/i18n/formtastic.rb

@@ -0,0 +1,51 @@
+
+module Rich
+  module I18n
+    module Formtastic
+    
+      def self.included(base)
+        base.alias_method_chain :input, :enrichments
+      end
+
+      def input_with_enrichments(*args)
+        object      = (@object.class.name if @object) || @object_name.match(/\[(\w+)_attributes\]/).captures.first.classify
+        method_arg  = args.shift
+        method      = method_arg.to_s
+        options     = args.extract_options!
+        wrapper_tag = options.delete(:wrapper_tag)
+
+        unless options.include?(:label)
+          keys = [:"label.#{object}.#{method}", :"label.#{method}", :"word.#{method}"]
+        
+          if @options.include?(:name)
+            keys.unshift :"label.forms.(#{@options[:name]}).#{method}"
+            keys.unshift :"label.forms.(#{@options[:name]}).#{object}.#{method}"
+          end
+        
+          options[:label] = keys.shift.t(:default => keys, :capitalize => true).to_output
+        end
+      
+        unless options.include?(:seatholder)
+          keys = [:"seatholder.#{object}.#{method}", :"seatholder.#{method}", ""]
+        
+          if @options.include?(:name)
+            keys.unshift :"seatholder.forms.(#{@options[:name]}).#{method}"
+            keys.unshift :"seatholder.forms.(#{@options[:name]}).#{object}.#{method}"
+          end
+        
+          seatholder = keys.shift.t :default => keys, :capitalize => true
+          options[:seatholder] = seatholder.to_output unless seatholder.empty? 
+        end
+      
+        (options[:input_html] ||= {}).store :seatholder, options.delete(:seatholder) unless @object && @object.respond_to?(:errors) && !@object.errors[method.to_sym].blank?
+      
+        if (output = input_without_enrichments method_arg, options) and wrapper_tag
+          output.gsub(/^\<li/, "<#{wrapper_tag}").gsub(/\<\/li\>$/, "</#{wrapper_tag}>")
+        else
+          output
+        end
+      end
+      
+    end
+  end  
+end