r18n-core 0.3.2 → 0.4

data/lib/r18n-core/i18n.rb

@@ -19,6 +19,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
 require 'date'
+require 'pathname'
 
 module R18n
   # General class to i18n support in your application. It load Translation and
@@ -28,8 +29,30 @@ module R18n
   # translation’s name or <tt>[name]</tt> method. 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).
+  # 
+  # Translations will loaded by loader object, which must have 2 methods:
+  # * <tt>available</tt> – return array of locales of available translations;
+  # * <tt>load(locale)</tt> – return Hash of translation.
+  # If you will use default loader (+R18n.default_loader+) you can pass to I18n
+  # only constructor argument for loader:
+  # 
+  #   R18n::I18n.new('en', R18n::Loader::YAML.new('dir/with/translations'))
+  # 
+  # is a same as:
+  # 
+  #   R18n::I18n.new('en', 'dir/with/translations')
+  # 
+  # In translation file you can use strings, numbers, floats (any YAML types)
+  # and pluralizable values (<tt>!!pl</tt>). You can use params in string
+  # values, which you can replace in program. Just write <tt>%1</tt>,
+  # <tt>%2</tt>, etc and set it values as method arguments, when you will be get
+  # value.
+  #
+  # You can use filters for some YAML type or for all strings. See R18n::Filters
+  # for details.
   #
-  # See Translation and Locale documentation.
+  # R18n contain translations for common words (such as “OK”, “Cancel”, etc)
+  # for most supported locales. See <tt>base/</tt> dir.
   #
   # == Usage
   # translations/ru.yml
@@ -57,6 +80,10 @@ module R18n
   #   i18n.l Time.now, :date   #=> "21.09.2008"
   #   i18n.l Time.now, :time   #=> "22:10"
   #   i18n.l Time.now, '%A'    #=> "Воскресенье"
+  #
+  #   i18n.yes    #=> "Yes"
+  #   i18n.ok     #=> "OK"
+  #   i18n.cancel #=> "Cancel"
   class I18n
     @@default = 'en'
 
@@ -87,27 +114,44 @@ module R18n
       locales.map! { |i| i[0] }
     end
     
+    # Return Array of locales with available translations.
+    def self.available_locales(places)
+      convert_places(places).map { |i| i.available }.flatten.uniq
+    end
+    
+    # Load default loader for elements in +places+ with only constructor
+    # argument.
+    def self.convert_places(places)
+      Array(places).map! do |loader|
+        if loader.respond_to? :available and loader.respond_to? :load
+          loader
+        else
+          R18n.default_loader.new(loader)
+        end
+      end
+    end
+    
     # User locales, ordered by priority
     attr_reader :locales
     
-    # Dirs with translations files
-    attr_reader :translation_dirs
+    # Loaders with translations files
+    attr_reader :translation_places
     
     # First locale with locale file
     attr_reader :locale
     
-    # Create i18n for +locales+ with translations from +translation_dirs+ and
+    # Create i18n for +locales+ with translations from +translation_places+ 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.
-    # +Translation_dirs+ must be a string with path or array.
-    def initialize(locales, translation_dirs = nil)
-      locales = [locales] if locales.is_a? String
+    # +Translation_places+ must be a string with path or array.
+    def initialize(locales, translation_places = nil)
+      locales = Array(locales)
       
       if not locales.empty? and Locale.exists? locales.first
-        locales += Locale.load(locales.first)['sublocales']
+        locales += Locale.load(locales.first).sublocales
       end
       locales << @@default
       locales.each_with_index do |locale, i|
@@ -115,18 +159,10 @@ module R18n
           locales.insert(i + 1, locale.match(/([^_-]+)[_-]/)[1])
         end
       end
-      locales.uniq!
+      locales.map! { |i| i.to_s.downcase }.uniq!
+      @locales_codes = locales
       @locales = locales.map { |i| Locale.load(i) }
       
-      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
-      
       @locale = @locales.first
       unless @locale.supported?
         @locales.each do |locale|
@@ -136,15 +172,58 @@ module R18n
           end
         end
       end
+      
+      if translation_places
+        @original_places = translation_places
+      else
+        @original_places = R18n.extension_places
+      end
+      
+      @translation_places = self.class.convert_places(@original_places)
+      
+      reload! unless @translation = R18n.cache[translation_cache_key]
     end
     
-    # Return Hash with titles (or code for unsupported locales) for available
-    # translations.
-    def translations
-      Translation.available(@translation_dirs).inject({}) do |all, code|
-        all[code] = Locale.load(code).title
-        all
+    
+    # Return unique key for current locales in translation and places.
+    def translation_cache_key
+      available = @translation_places.inject([]) { |all, i|
+        all + i.available }.uniq.map { |i| i.code }
+      (@locales_codes & available).join(',') + '@' +
+        R18n.default_loader.hash.to_s +
+        @translation_places.hash.to_s + R18n.extension_places.hash.to_s
+    end
+    
+    # Reload translations.
+    def reload!
+      @translation_places = self.class.convert_places(@original_places)
+      
+      available_in_places = @translation_places.map { |i| [i, i.available] }
+      available_in_extensions = R18n.extension_places.map { |i| [i, i.available] }
+      
+      @translation = Translation.new @locale
+      @locales.each do |locale|
+        loaded = false
+        available_in_places.each do |place, available|
+          if available.include? locale
+            @translation.merge! place.load(locale), locale
+            loaded = true
+          end
+        end
+        if loaded
+          available_in_extensions.each do |extension, available|
+            if available.include? locale
+              @translation.merge! extension.load(locale), locale
+            end
+          end
+        end
       end
+      R18n.cache[translation_cache_key] = @translation
+    end
+    
+    # Return Array of locales with available translations.
+    def available_locales
+      @available ||= self.class.available_locales(@translation_places)
     end
     
     # Convert +object+ to String, according to the rules of the current locale.
@@ -161,30 +240,15 @@ module R18n
     #   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 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
+      locale.localize(object, format, self, *params)
     end
     alias :l :localize
     
+    # Return translations.
+    def t
+      @translation
+    end
+    
     # Short and pretty way to get translation by method name. If translation
     # has name like object methods (+new+, +to_s+, +methods+) use <tt>[]</tt>
     # method to access.
@@ -192,7 +256,7 @@ module R18n
     # Translation can contain variable part. Just set is as <tt>%1</tt>,
     # <tt>%2</tt>, etc in translations file and set values as methods params.
     def method_missing(name, *params)
-      @translation[name.to_s, *params]
+      @translation[name, *params]
     end
     
     # Return translation with special +name+.

data/lib/r18n-core/locale.rb

@@ -19,14 +19,15 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
 require 'pathname'
-require 'yaml'
+require 'singleton'
 
 module R18n
   # Information about locale (language, country and other special variant
   # preferences). Locale was named by RFC 3066. For example, locale for French
-  # speaking people in Canada will be +fr_CA+.
+  # speaking people in Canada will be +fr-CA+.
   #
-  # Locale files is placed in <tt>locales/</tt> dir in YAML files.
+  # Locale classes are placed in <tt>R18n::Locales</tt> module and storage
+  # install <tt>locales/</tt> dir.
   #
   # Each locale has +sublocales+ – often known languages for people from this
   # locale. For example, many Belorussians know Russian and English. If there
@@ -44,110 +45,86 @@ module R18n
   #
   # == Available data
   #
-  # * +code+: locale RFC 3066 code;
-  # * +title+: locale name on it language;
-  # * +direction+: writing direction, +ltr+ or +rtl+ (for Arabic and Hebrew);
-  # * +sublocales+: often known languages for people from this locale;
-  # * +include+: locale code to include it data, optional.
+  # * +code+ – locale RFC 3066 code;
+  # * +title+ – locale name on it language;
+  # * +ltr?+ – true on left-to-right writing direction, false for Arabic and
+  #   Hebrew);
+  # * +sublocales+ – often known languages for people from this locale;
+  # * +week_start+ – does week start from +:monday+ or +:sunday+.
   #
   # 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/'
+    
+    @@loaded = {}
 
-    # All available locales
+    # Codes of all available locales.
     def self.available
-      Dir.glob(File.join(LOCALES_DIR, '*.yml')).map do |i|
-        File.basename(i, '.yml')
+      Dir.glob(File.join(LOCALES_DIR, '*.rb')).map do |i|
+        File.basename(i, '.rb')
       end
     end
 
-    # Is +locale+ has info file
+    # Is +locale+ has info file.
     def self.exists?(locale)
-      File.exists?(File.join(LOCALES_DIR, locale + '.yml'))
+      File.exists?(File.join(LOCALES_DIR, locale.to_s + '.rb'))
     end
 
-    # Load locale by RFC 3066 +code+
+    # 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(original) unless exists? code
-      
-      data = {}
-      klass = R18n::Locale
-      default_loaded = false
+      original = code.to_s.gsub(/[^-a-zA-Z]/, '')
+      code = original.downcase
       
-      while code and exists? code
-        file = LOCALES_DIR + "#{code}.yml"
-        default_loaded = true if I18n.default == code
-        
-        if R18n::Locale == klass and File.exists? LOCALES_DIR + "#{code}.rb"
+      @@loaded[code] ||= begin
+        if exists? code
           require LOCALES_DIR + "#{code}.rb"
           name = code.gsub(/[\w\d]+/) { |i| i.capitalize }.gsub('-', '')
-          klass = eval 'R18n::Locales::' + name
-        end
-        
-        loaded = YAML.load_file(file)
-        code = loaded['include']
-        data = Utils.deep_merge! loaded, data
-      end
-      
-      unless default_loaded
-        code = I18n.default
-        while code and exists? code
-          loaded = YAML.load_file(LOCALES_DIR + "#{code}.yml")
-          code = loaded['include']
-          data = Utils.deep_merge! loaded, data
+          eval('R18n::Locales::' + name).new
+        else
+          UnsupportedLocale.new(original)
         end
       end
-      
-      klass.new(data)
     end
     
-    attr_reader :data
-
-    # Create locale object with locale +data+.
-    #
-    # This is internal a constructor. To load translation use
-    # <tt>R18n::Translation.load(locales, translations_dir)</tt>.
-    def initialize(data)
-      @data = data
+    # Set locale +properties+. Locale class will have methods for each propetry
+    # name, which return propetry value:
+    # 
+    #   class R18n::Locales::En < R18n::Locale
+    #     set :title => 'English',
+    #         :code  => 'en'
+    #   end
+    #   
+    #   locale = R18n::Locales::En.new
+    #   locale.title #=> "English"
+    #   locale.code  #=> "en"
+    def self.set(properties)
+      properties.each_pair do |key, value|
+        define_method(key) { value }
+      end
     end
     
     # Locale RFC 3066 code.
     def code
-      @data['code']
+      self.class.name.split('::').last.downcase
     end
     
-    # Locale title.
-    def title
-      @data['title']
-    end
+    set :sublocales => %w{en},
+        :week_start => :monday,
+        :time_am => 'AM',
+        :time_pm => 'PM',
+        :time_format => ' %H:%M',
+        :full_format => '%e %B',
+        :year_format => '_ %Y'
+    
+    def month_standalone; month_names; end
     
     # Is locale has left-to-right write direction.
-    def ltr?
-      @data['direction'] == 'ltr'
-    end
-
-    # Get information about locale
-    def [](name)
-      @data[name]
-    end
+    def ltr?; true; end
 
-    # Is another locale has same code
+    # Is another locale has same code.
     def ==(locale)
-      code.downcase == locale.code.downcase
+      self.class == locale.class
     end
     
     # Is locale has information file. In this class always return true.
@@ -155,17 +132,48 @@ module R18n
       true
     end
 
-    # Human readable locale code and title
+    # Human readable locale code and title.
     def inspect
       "Locale #{code} (#{title})"
     end
     
+    # Convert +object+ to String. It support Fixnum, Bignum, Float, Time, Date
+    # and DateTime.
+    #
+    # 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>.
+    def localize(obj, format = nil, *params)
+      case obj
+      when Integer
+        format_integer(obj)
+      when Float
+        format_float(obj)
+      when Time, DateTime, Date
+        return strftime(obj, format) if format.is_a? String
+        return month_standalone[obj.month - 1] if :month == format
+        return obj.to_s if :human == format and not params.first.is_a? I18n
+        
+        type = obj.is_a?(Date) ? 'date' : 'time'
+        format = :standard unless format
+        
+        unless [:human, :full, :standard].include? format
+          raise ArgumentError, "Unknown time formatter #{format}"
+        end
+          
+        send "format_#{type}_#{format}", obj, *params
+      else
+        obj.to_s
+      end
+    end
+    
     # Returns the integer in String form, according to the rules of the locale.
     # It will also put real typographic minus.
     def format_integer(integer)
       str = integer.to_s
       str[0] = '−' if 0 > integer # Real typographic minus
-      group = @data['numbers']['group_delimiter']
+      group = number_group
       
       str.gsub(/(\d)(?=(\d\d\d)+(?!\d))/) do |match|
         match + group
@@ -175,7 +183,7 @@ module R18n
     # Returns the float in String form, according to the rules of the locale.
     # It will also put real typographic minus.
     def format_float(float)
-      decimal = @data['numbers']['decimal_separator']
+      decimal = number_decimal
       self.format_integer(float.to_i) + decimal + float.to_s.split('.').last
     end
     
@@ -187,19 +195,15 @@ module R18n
       format.scan(/%[EO]?.|./o) do |c|
         case c.sub(/^%[EO]?(.)$/o, '%\\1')
         when '%A'
-          translated << @data['week']['days'][time.wday]
+          translated << wday_names[time.wday]
         when '%a'
-          translated << @data['week']['abbrs'][time.wday]
+          translated << wday_abbrs[time.wday]
         when '%B'
-          translated << @data['months']['names'][time.month - 1]
+          translated << month_names[time.month - 1]
         when '%b'
-          translated << @data['months']['abbrs'][time.month - 1]
+          translated << month_abbrs[time.month - 1]
         when '%p'
-          translated << if time.hour < 12
-            @data['time']['am']
-          else
-            @data['time']['pm']
-          end
+          translated << (time.hour < 12 ? time_am : time_pm)
         else
           translated << c
         end
@@ -209,17 +213,17 @@ module R18n
     
     # Format +time+ without date. For example, “12:59”.
     def format_time(time)
-      strftime(time, @data['time']['time'])
+      strftime(time, time_format)
     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)
+    def format_time_human(time, i18n, now = Time.now, *params)
       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)
+        format_date_human(R18n::Utils.to_date(time), i18n,
+                          R18n::Utils.to_date(now)) + format_time(time)
       else
         case minutes
         when -60..-1
@@ -240,20 +244,20 @@ module R18n
     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)
+    def format_time_standard(time, *params)
+      format_date_standard(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)
+    def format_time_full(time, *params)
+      format_date_full(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)
+    def format_date_human(date, i18n, now = Date.today, *params)
       days = (date - now).to_i
       case days
       when -6..-2
@@ -267,21 +271,21 @@ module R18n
       when 2..6
         i18n.human_time.after_days(days)
       else
-        format_date_full(i18n, date, date.year != now.year)
+        format_date_full(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'])
+    def format_date_standard(date, *params)
+      strftime(date, date_format)
     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
+    def format_date_full(date, year = true, *params)
+      format = full_format
+      format = year_format.sub('_', format) if year
       strftime(date, format)
     end
 
@@ -298,4 +302,6 @@ module R18n
       end
     end
   end
+  
+  module Locales; end
 end

data/lib/r18n-core/translated.rb

@@ -123,8 +123,6 @@ module R18n
         
         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
@@ -132,11 +130,18 @@ module R18n
               result = method(unlocalized[code]).#{call}
               next unless result
               
+              path = "\#{self.class.name}##{name}"
               type = self.class.translation_types[#{name.inspect}]
-              return R18n::Filters.process(result, locale, path, type, params)
+              if type
+                return R18n::Filters.process(type, result, locale, path, params)
+              else
+                result = TranslatedString.new(result, locale, path)
+                return R18n::Filters.process_string(result, path, params)
+              end
             end
             
-            R18n::Untranslated.new(path, '#{name}', R18n.get.locales)
+            R18n::Untranslated.new("\#{self.class.name}\#", '#{name}',
+                                   R18n.get.locale)
           end
         EOS
         

data/lib/r18n-core/translated_string.rb

@@ -34,5 +34,15 @@ module R18n
       @locale = locale
       @path = path
     end
+    
+    # Return self for translated string.
+    def |(default)
+      self
+    end
+    
+    # Return true for translated strings.
+    def translated?
+      true
+    end
   end
 end