r18n-core 0.2.3 → 0.3

data/lib/r18n-core/i18n.rb

@@ -48,9 +48,9 @@ module R18n
   #   i18n.one   #=> "Один"
   #   i18n.two   #=> "Two"
   #   
-  #   i18n.locale['title']     #=> "Русский"
-  #   i18n.locale['code']      #=> "ru"
-  #   i18n.locale['direction'] #=> "ltr"
+  #   i18n.locale.title        #=> "Русский"
+  #   i18n.locale.code         #=> "ru"
+  #   i18n.locale.ltr?         #=> true
   #   
   #   i18n.l -11000.5          #=> "−11 000,5"
   #   i18n.l Time.now          #=> "Вск, 21 сен 2008, 22:10:10 MSD"
@@ -91,56 +91,58 @@ module R18n
     attr_reader :locales
     
     # Dirs with translations files
-    attr_reader :translations_dirs
+    attr_reader :translation_dirs
     
     # First locale with locale file
     attr_reader :locale
     
-    # Create i18n for +locales+ with translations from +translations_dirs+ and
+    # Create i18n for +locales+ with translations from +translation_dirs+ and
     # locales data. Translations will be also loaded for default locale,
     # +sublocales+ from first in +locales+ and general languages for dialects
     # (it will load +fr+ for +fr_CA+ too).
     #
     # +Locales+ must be a locale code (RFC 3066) or array, ordered by priority.
-    # +Translations_dirs+ must be a string with path or array.
-    def initialize(locales, translations_dirs = nil)
+    # +Translation_dirs+ must be a string with path or array.
+    def initialize(locales, translation_dirs = nil)
       locales = [locales] if locales.is_a? String
       
-      @locales = locales.map { |i| Locale.load(i) }
-      
-      locales << @@default
-      if @locales.first.kind_of? Locale
-        locales += @locales.first['sublocales']
+      if not locales.empty? and Locale.exists? locales.first
+        locales += Locale.load(locales.first)['sublocales']
       end
+      locales << @@default
       locales.each_with_index do |locale, i|
-        if "_" == locale[2..2]
-          locales.insert(i + 1, locale[0..1])
+        if locale =~ /[_-]/
+          locales.insert(i + 1, locale.match(/([^_-]+)[_-]/)[1])
         end
       end
       locales.uniq!
+      @locales = locales.map { |i| Locale.load(i) }
       
-      locales.each do |locale|
-        if Locale.exists? locale
-          @locale = Locale.load(locale)
-          break
-        end
+      if translation_dirs.nil?
+        @translation_dirs = []
+        @translation = Translation.load(@locales,
+                                        Translation.extension_translations)
+      else
+        @translation_dirs = translation_dirs
+        @translation = Translation.load(@locales, @translation_dirs)
       end
       
-      if not translations_dirs.nil?
-        @translations_dirs = translations_dirs
-        @translation = Translation.load(locales, @translations_dirs)
+      @locale = @locales.first
+      unless @locale.supported?
+        @locales.each do |locale|
+          if locale.supported?
+            @locale.base = locale
+            break
+          end
+        end
       end
     end
     
     # Return Hash with titles (or code for unsupported locales) for available
     # translations.
     def translations
-      Translation.available(@translations_dirs).inject({}) do |all, code|
-        all[code] = if Locale.exists? code
-          Locale.load(code)['title']
-        else
-          code
-        end
+      Translation.available(@translation_dirs).inject({}) do |all, code|
+        all[code] = Locale.load(code).title
         all
       end
     end
@@ -148,22 +150,37 @@ module R18n
     # Convert +object+ to String, according to the rules of the current locale.
     # It support Fixnum, Bignum, Float, Time, Date and DateTime.
     #
-    # For time classes you can set +format+ in standart +strftime+ form, or
-    # Symbol to use format from locale file (<tt>:time</tt>, <tt>:date</tt>,
-    # <tt>:short_data</tt>, <tt>:long_data</tt>, <tt>:datetime</tt>,
-    # <tt>:short_datetime</tt> or <tt>:long_datetime</tt>). Without format it
-    # use <tt>:datetime</tt> for Time and DateTime and <tt>:date</tt> for Date.
-    def localize(object, format = nil)
+    # For time classes you can set +format+ in standard +strftime+ form,
+    # <tt>:full</tt> (“01 Jule, 2009”), <tt>:human</tt> (“yesterday”),
+    # <tt>:standard</tt> (“07/01/09”) or <tt>:month</tt> for standalone month
+    # name. Default format is <tt>:standard</tt>.
+    #
+    #   i18n.l -12000.5         #=> "−12,000.5"
+    #   i18n.l Time.now         #=> "07/01/09 12:59"
+    #   i18n.l Time.now.to_date #=> "07/01/09"
+    #   i18n.l Time.now, :human #=> "now"
+    #   i18n.l Time.now, :full  #=> "Jule 1st, 2009 12:59"
+    def localize(object, format = nil, *params)
       if object.is_a? Integer
         locale.format_integer(object)
       elsif object.is_a? Float
         locale.format_float(object)
-      elsif object.is_a? Time or object.is_a? DateTime
-        format = :datetime if format.nil?
-        locale.strftime(object, format)
-      elsif object.is_a? Date
-        format = :date if format.nil?
-        locale.strftime(object, format)
+      elsif object.is_a? Time or object.is_a? DateTime or object.is_a? Date
+        if format.is_a? String
+          locale.strftime(object, format)
+        else
+          if :month == format
+            return locale.data['months']['standalone'][object.month - 1]
+          end
+          type = object.is_a?(Date) ? 'date' : 'time'
+          format = :standard unless format
+          
+          unless [:human, :full, :standard].include? format
+            raise ArgumentError, "Unknown time formatter #{format}"
+          end
+          
+          locale.send "format_#{type}_#{format}", self, object, *params
+        end
       end
     end
     alias :l :localize

data/lib/r18n-core/locale.rb

@@ -38,9 +38,9 @@ module R18n
   # Get Russian locale and print it information
   #
   #   ru = R18n::Locale.load('ru')
-  #   ru['title']        #=> "Русский"
-  #   ru['code']         #=> "ru"
-  #   ru['direction']    #=> "ltr"
+  #   ru.title #=> "Русский"
+  #   ru.code  #=> "ru"
+  #   ru.ltr?  #=> true
   #
   # == Available data
   #
@@ -52,6 +52,12 @@ module R18n
   #
   # You can see more available data about locale in samples in
   # <tt>locales/</tt> dir.
+  #
+  # == Extend locale
+  # If language need some special logic (for example, another pluralization or
+  # time formatters) you can just change Locale class. Create
+  # R18n::Locales::_Code_ class in base/_code_.rb, extend R18n::Locale and
+  # rewrite methods (for example, +pluralization+ or +format_date_full+).
   class Locale
     LOCALES_DIR = Pathname(__FILE__).dirname.expand_path + '../../locales/'
 
@@ -69,11 +75,14 @@ module R18n
 
     # Load locale by RFC 3066 +code+
     def self.load(code)
+      code = code.to_s
       code.delete! '/'
       code.delete! '\\'
       code.delete! ';'
+      original = code
+      code = code.downcase
       
-      return UnsupportedLocale.new(code) unless exists? code
+      return UnsupportedLocale.new(original) unless exists? code
       
       data = {}
       klass = R18n::Locale
@@ -85,7 +94,8 @@ module R18n
         
         if R18n::Locale == klass and File.exists? LOCALES_DIR + "#{code}.rb"
           require LOCALES_DIR + "#{code}.rb"
-          klass = eval 'R18n::Locales::' + code.capitalize
+          name = code.gsub(/[\w\d]+/) { |i| i.capitalize }.gsub('-', '')
+          klass = eval 'R18n::Locales::' + name
         end
         
         loaded = YAML.load_file(file)
@@ -114,6 +124,21 @@ module R18n
     def initialize(data)
       @data = data
     end
+    
+    # Locale RFC 3066 code.
+    def code
+      @data['code']
+    end
+    
+    # Locale title.
+    def title
+      @data['title']
+    end
+    
+    # Is locale has left-to-right write direction.
+    def ltr?
+      @data['direction'] == 'ltr'
+    end
 
     # Get information about locale
     def [](name)
@@ -122,12 +147,17 @@ module R18n
 
     # Is another locale has same code
     def ==(locale)
-      @data['code'] == locale['code']
+      code.downcase == locale.code.downcase
+    end
+    
+    # Is locale has information file. In this class always return true.
+    def supported?
+      true
     end
 
     # Human readable locale code and title
     def inspect
-      "Locale #{@data['code']} (#{@data['title']})"
+      "Locale #{code} (#{title})"
     end
     
     # Returns the integer in String form, according to the rules of the locale.
@@ -151,19 +181,8 @@ module R18n
     
     # Same that <tt>Time.strftime</tt>, but translate months and week days
     # names. In +time+ you can use Time, DateTime or Date object. In +format+
-    # you can use String with standart +strftime+ format (see
-    # <tt>Time.strftime</tt> docs) or Symbol with format from locale file
-    # (<tt>:month</tt>, <tt>:time</tt>, <tt>:date</tt>, <tt>:short_data</tt>,
-    # <tt>:long_data</tt>, <tt>:datetime</tt>, <tt>:short_datetime</tt> or
-    # <tt>:long_datetime</tt>).
+    # you can use standard +strftime+ format.
     def strftime(time, format)
-      if format.is_a? Symbol
-        if :month == format
-          return @data['months']['standalone'][time.month - 1]
-        end
-        format = @data['formats'][format.to_s]
-      end
-      
       translated = ''
       format.scan(/%[EO]?.|./o) do |c|
         case c.sub(/^%[EO]?(.)$/o, '%\\1')
@@ -187,6 +206,84 @@ module R18n
       end
       time.strftime(translated)
     end
+    
+    # Format +time+ without date. For example, “12:59”.
+    def format_time(time)
+      strftime(time, @data['time']['time'])
+    end
+    
+    # Format +time+ in human usable form. For example “5 minutes ago” or
+    # “yesterday”. In +now+ you can set base time, which be used to get relative
+    # time. For special cases you can replace it in locale’s class.
+    def format_time_human(i18n, time, now = Time.now)
+      minutes = (time - now) / 60.0
+      if time.mday != now.mday and minutes.abs > 720 # 12 hours
+        format_date_human(i18n, R18n::Utils.to_date(time),
+                                R18n::Utils.to_date(now)) + format_time(time)
+      else
+        case minutes
+        when -60..-1
+          i18n.human_time.minutes_ago(minutes.round.abs)
+        when 1..60
+          i18n.human_time.after_minutes(minutes.round)
+        when -1..1
+          i18n.human_time.now
+        else
+          hours = (minutes / 60.0).abs.floor
+          if time > now
+            i18n.human_time.after_hours(hours)
+          else
+            i18n.human_time.hours_ago(hours)
+          end
+        end
+      end
+    end
+    
+    # Format +time+ in compact form. For example, “12/31/09 12:59”.
+    def format_time_standard(i18n, time)
+      format_date_standard(i18n, time) + format_time(time)
+    end
+    
+    # Format +time+ in most official form. For example, “December 31st, 2009
+    # 12:59”. For special cases you can replace it in locale’s class.
+    def format_time_full(i18n, time)
+      format_date_full(i18n, time) + format_time(time)
+    end
+    
+    # Format +date+ in human usable form. For example “5 days ago” or
+    # “yesterday”. In +now+ you can set base time, which be used to get relative
+    # time. For special cases you can replace it in locale’s class.
+    def format_date_human(i18n, date, now = Date.today)
+      days = (date - now).to_i
+      case days
+      when -6..-2
+        i18n.human_time.days_ago(days.abs)
+      when -1
+        i18n.human_time.yesterday
+      when 0
+        i18n.human_time.today
+      when 1
+        i18n.human_time.tomorrow
+      when 2..6
+        i18n.human_time.after_days(days)
+      else
+        format_date_full(i18n, date, date.year != now.year)
+      end
+    end
+    
+    # Format +date+ in compact form. For example, “12/31/09”.
+    def format_date_standard(i18n, date)
+      strftime(date, @data['time']['date'])
+    end
+    
+    # Format +date+ in most official form. For example, “December 31st, 2009”.
+    # For special cases you can replace it in locale’s class. If +year+ is false
+    # date will be without year.
+    def format_date_full(i18n, date, year = true)
+      format = @data['time']['full']
+      format = @data['time']['year'].sub('_', format) if year
+      strftime(date, format)
+    end
 
     # Return pluralization type for +n+ items. This is simple form. For special
     # cases you can replace it in locale’s class.

data/lib/r18n-core/translated.rb

@@ -0,0 +1,186 @@
+# encoding: utf-8
+=begin
+Add i18n support to any class.
+
+Copyright (C) 2008 Andrey “A.I.” Sitnik <andrey@sitnik.ru>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+module R18n
+  # Module to add i18n support to any class. It will be useful for ORM or
+  # R18n plugin with out-of-box i18n support.
+  # 
+  # Module can add proxy-methods to find translation in object methods. For
+  # example, if you class have +title_en+ and +title_ru+ methods, you can add
+  # proxy-method +title+, which will use +title_ru+ for Russian users and
+  # +title_en+ for English:
+  # 
+  #   require 'r18n-core/translated'
+  #   
+  #   class Product
+  #     include DataMapper::Resource
+  #     property :title_ru, String
+  #     property :title_en, String
+  #     property :desciption_ru, String
+  #     property :desciption_en, String
+  #     
+  #     include R18n::Translated
+  #     translations :title, :desciption
+  #   end
+  #   
+  #   # User know only Russian
+  #   R18n.set(R18n::I18n.new('ru'))
+  #   
+  #   product.title #=> Untranslated
+  #   
+  #   # Set value to English (default) title
+  #   product.title_en = "Anthrax"
+  #   product.title #=> "Anthrax"
+  #   product.title.locale #=> Locale en (English)
+  #   
+  #   # Set value to title on user locale (Russian)
+  #   product.title = "Сибирская язва"
+  #   product.title #=> "Сибирская язва"
+  #   product.title.locale #=> Locale ru (Russian)
+  #   
+  #   product.title_en #=> "Anthrax"
+  #   product.title_ru #=> "Сибирская язва"
+  # 
+  # Proxy-method support all funtion from I18n: global and type filters,
+  # pluralization, variables. It also return TranslatedString or Untranslated.
+  #
+  # Note, you must set your I18n object by <tt>R18n.set</tt> and don’t forget
+  # to require <tt>'r18n-core/translated'</tt>. R18n plugins (sinatra-r18n,
+  # r18-desktop) set I18n object by <tt>R18n.set</tt> automatically, but you
+  # must call <tt>i18n</tt> helper in Sinatra before use models.
+  #
+  # See R18n::Translated::Base for class method documentation.
+  # 
+  # == Options
+  # You can set option for proxy-method as Hash with keys;
+  # * +type+ – YAML type for filters. For example, "markdown" or "escape_html".
+  # * +methods+ – manual method map as Hash of locale codes to method names.
+  # * +no_params+ – set it to true if you proxy-method must send it parameters
+  #   only to filters.
+  # * +no_write+ – set it to true if you don’t want to create proxy-setters.
+  # 
+  # Method +translation+ will be more useful for options:
+  # 
+  #   translation :title, :methods => {:ru => :russian, :en => :english}
+  module Translated
+    class << self
+      def included(base) #:nodoc:
+        base.send :extend, Base
+        base.instance_variable_set '@unlocalized_getters', {}
+        base.instance_variable_set '@unlocalized_setters', {}
+        base.instance_variable_set '@translation_types', {}
+      end
+    end
+    
+    # Module with class methods, which be added after R18n::Translated include.
+    module Base
+      # Hash of translation method names to it type for filters.
+      attr_reader :translation_types
+      
+      # Add several proxy +methods+. See R18n::Translated for description.
+      # It’s more compact, that +translation+.
+      # 
+      #   translations :title, :keywords, [:desciption, {:type => 'markdown'}]
+      def translations(*methods)
+        methods.each do |method|
+          translation(*method)
+        end
+      end
+      
+      # Add proxy-method +name+. See R18n::Translated for description.
+      # It’s more useful to set options.
+      # 
+      #   translation :desciption, :type => 'markdown'
+      def translation(name, options = {})
+        if options[:methods]
+          @unlocalized_getters[name] = Hash[
+              options[:methods].map { |l, i| [l.to_s, i.to_s] } ]
+          unless options[:no_write]
+            @unlocalized_setters[name] = Hash[
+                options[:methods].map { |l, i| [l.to_s, i.to_s + '='] } ]
+          end
+        end
+        
+        @translation_types[name] = options[:type]
+        call = options[:no_params] ? 'call' : 'call(*params)'
+        
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}(*params)
+            path = "\#{self.class.name}##{name}"
+            
+            unlocalized = self.class.unlocalized_getters(#{name.inspect})
+            R18n.get.locales.each do |locale|
+              code = locale.code
+              next unless unlocalized.has_key? code
+              result = method(unlocalized[code]).#{call}
+              next unless result
+              
+              type = self.class.translation_types[#{name.inspect}]
+              return R18n::Filters.process(result, locale, path, type, params)
+            end
+            
+            R18n::Untranslated.new(path, '#{name}')
+          end
+        EOS
+        
+        unless options[:no_write]
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(*params)
+              unlocalized = self.class.unlocalized_setters(#{name.inspect})
+              R18n.get.locales.each do |locale|
+                code = locale.code
+                next unless unlocalized.has_key? code
+                return method(unlocalized[code]).call(*params)
+              end
+            end
+          EOS
+        end
+      end
+
+      # Return Hash of locale code to getter method for proxy +method+. If you
+      # didn’t set map in +translation+ option +methods+, it will be detect
+      # automatically.
+      def unlocalized_getters(method)
+        matcher = Regexp.new('^' + Regexp.escape(method.to_s) + '_(.*[^=])$')
+        unless @unlocalized_getters.has_key? method
+          @unlocalized_getters[method] = {}
+          self.instance_methods.reject { |i| not i =~ matcher }.each do |i|
+            @unlocalized_getters[method][i.to_s.match(matcher)[1]] = i.to_s
+          end
+        end
+        @unlocalized_getters[method]
+      end
+      
+      # Return Hash of locale code to setter method for proxy +method+. If you
+      # didn’t set map in +translation+ option +methods+, it will be detect
+      # automatically.
+      def unlocalized_setters(method)
+        matcher = Regexp.new('^' + Regexp.escape(method.to_s) + '_(.*)=$')
+        unless @unlocalized_setters.has_key? method
+          @unlocalized_setters[method] = {}
+          self.instance_methods.reject { |i| not i =~ matcher }.each do |i|
+            @unlocalized_setters[method][i.to_s.match(matcher)[1]] = i.to_s
+          end
+        end
+        @unlocalized_setters[method]
+      end
+    end
+  end
+end