merb_babel 0.1.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Matt Aimonetti
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,151 @@
+Merb_babel
+=========
+
+A plugin for the Merb framework that provides locales, languages, countries. (in a thread safe environment)
+
+
+Purpose of Merb\_babel
+---------------------
+
+Merb_babel is primarily written to fulfill my personal needs. Instead of porting my http://github.com/mattetti/globalite plugin over, I decided to re write it from scratch learning from my mistakes.
+
+Goals:
+
+* simplicity
+* speed
+
+My first and simple objective is to get Merb to work in Simplified and Traditional Chinese + switch from one to the other.
+
+Also, as of today, I'm not planning on supporting model localization since I believe it's easy to do, and in most cases it's too specific to use a plugin. (but other plugins offer that for you anyway ;) )
+
+One of the objectives is that people can add Merb\_babel to their project and use merb in a different language without worrying about internationalization/localization. I hope to keep merb helpers and other plugins (merb\_activerecord / merb\_datamapper / merb\_sequel) localized so someone can define his app's locale/language/country and Merb will talk his language right away.
+
+Before you go further, you might want to read [this explanation about i18n/l10n](http://www.w3.org/International/questions/qa-i18n)
+
+Usage
+------
+
+In your application controller add:
+
+    before :set_locale
+    
+
+and access the user locale using  @controller.locale (or simply #locale in the controller)
+If a locale is set, you can also access @controller.language and @controller.country (same thing, you can use #language or #country from within your controller scope)
+
+The locale is stored in request.env[:locale]
+
+At the moment you have 3 ways of setting up a locale:
+
+* default way in the config settings (that you can overwrite in your init.rb file )
+
+    Merb::Plugins.config[:Merb_babel] = {
+      :default_locale => 'en-US',
+      :default_language => 'en',
+      :default_country => 'US'
+    }
+    
+* per request basis, by sending a param called locale (language, and country will set their own values)
+* store the locale in the session
+* use routes
+
+Babel doesn't support http header lookup yet.
+
+Set locale in your routes
+--------------------------
+
+    r.match(/\/?(en\-US|en\-UK|es\-ES|es\-AR)?/).to(:locale => "[1]") do |l|
+      l.match("/articles/:action/:id").to(:controller => "articles")
+    end
+    
+What if you don't need to use a full locale?
+--------------------------------------------
+
+some people might not need to use the full locale, they just want to use one version of a language and the locale is an overkill. Don't worry, you can use the language instance variable.
+
+    before :set_language
+    
+    
+All locale work is done in ``merb_babel/lib/merb_babel/m_locale.rb`` and tested in ``spec/merb_babel_spec.rb``
+
+Localization(L10n)
+------------------
+
+L10n is basically the adaptation of your product to a specific locale. In our case, we see L10n as the storing and retrieval of localized data. (for a locale or language)
+
+Localizations are loaded from localization files.
+
+Localization files are simple yaml files that get loaded in memory. By default Merb\_babel will look in ./lang for localization files. The default location is defined in Merb::Plugins.config[:merb_babel][:localization_dirs] and can be overwritten. Also, you can add more folders to look for by calling:
+
+    add_localization_dir(path_with_more_localization_files)
+    
+Note: when you add a new localization directory, localizations gets reloaded.
+This needs to be done when Merb loads as I didn't add a mutex around that task yet.
+
+Localizations are available in #localizations and are namespaced as follows:
+
+    localizations['en'][:right] => 'right'
+    localizations['en'][:left] => 'left'
+    localizations['en']['US'][:greeting] => 'Howdie'
+    localizations['en']['AU'][:greeting] => "Good'ay"
+    
+For that the localization files to be loaded properly, you need to follow some conventions:
+
+* you have to declare a merb localization language code pair: 
+    mloc\_language_code: en
+where en represents the language code of the localization
+
+* All generic localization for a language should go under their own language file. Region/culture specific localizations have to go to their own files and will be used if the full locale is set.
+
+* A localization file is recognized as being locale specific if the mloc_country_code pair is set.
+
+* ONLY localizations/translations specific to a locale should be written in a locale file.
+
+* Recommended: set the mloc\_language_name pair so you list the available languages in their own language.
+
+* look at examples in spec/lang
+
+All the Localization(L10n) work is done in ``merb_babel/lib/merb_abel/m_l10n.rb`` and tested in ``spec/m_l10n_spec.rb``
+
+
+Internationalization(I18n)
+--------------------------
+
+I18n enables easy localization of your product. That's what the developer/designer user to make their data localizable.
+
+At the moment, only strings can be localized/translated.
+
+In your controller, or view simply do:
+
+    translate(:localization_key)
+
+You might prefer a shorter version so here are some aliases for you to use:
+
+    babelize(:translation_key)
+or
+    t(:translation_key)  
+or
+    _(:translation_key)
+    
+The translation will use the full locale (language and country) if set and available, otherwise the language translation will be displayed.
+
+*Params*
+
+You can pass a hash of parameters after the translation key. For instance:
+
+    t(:greetings, :language => 'fr')
+
+Would lookup the French translation for the greetings key and return 'Salut'
+
+You can also pass the country code to use the full locale.
+
+    t(:greetings, :language => 'en', :country => 'AU')
+    
+would lookup the Australian English translation for the greetings key and return "G'day"
+
+
+Other plugins you might want to look at:
+----------------------------------------
+
+* http://github.com/myabc/merb_global
+* http://github.com/lemon/poppycock

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+require 'merb-core'
+require 'merb-core/tasks/merb'
+
+GEM_NAME = "merb_babel"
+GEM_VERSION = "0.1.2"
+AUTHOR = "Matt Aimonetti"
+EMAIL = "mattaimonetti@gmail.com"
+HOMEPAGE = "http://github.com/mattetti/merb_babel/"
+SUMMARY = "Merb plugin that provides simple localization/internationalisation"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = 'merb'
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.markdown", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb-core', '>= 1.0')
+  s.add_dependency('locale', '>= 0.9.0')
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.markdown Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the plugin as a gem"
+task :install do
+  Merb::RakeHelper.install(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Uninstall the gem"
+task :uninstall do
+  Merb::RakeHelper.uninstall(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc "Run specs"
+task :spec do
+  sh "spec --color spec"
+end
+
+task :default => :spec

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb_abel.rb
+Add your Merb rake tasks to lib/merb_abel/merbtasks.rb

data/lib/merb_babel.rb

@@ -0,0 +1,59 @@
+#require File.join(File.dirname(__FILE__) / "merb_babel" / "core_ext")
+
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+
+  # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+  Merb::Plugins.config[:merb_babel] = {
+    :default_locale => 'en-US',
+    :default_language => 'en',
+    # :default_country => 'US',
+    :localization_dirs => ["#{Merb.root}/lang"]
+  }
+  
+  require File.join(File.dirname(__FILE__) / "merb_babel" / "m_locale")
+  require File.join(File.dirname(__FILE__) / "merb_babel" / "m_l10n")
+  require File.join(File.dirname(__FILE__) / "merb_babel" / "m_i18n")
+  require File.join(File.dirname(__FILE__) / "merb_babel" / 'locale_detector')
+  gem "locale"
+  require 'locale'
+  
+  Merb::BootLoader.before_app_loads do
+    # require code that must be loaded before the application
+    module Merb
+      module GlobalHelpers
+
+        # Used to translate words using localizations
+        def babelize(*args)
+          begin
+            options = args.pop if args.last.kind_of?(Hash) 
+            options ||= {}
+            options[:language] ||= language
+            options[:country] ||= country
+            case key = args.last
+            when Date, Time
+              format = MI18n.lookup(options.merge(:keys => args[0..-2]))
+              ML10n.localize_time(key, format, options)
+            else
+              MI18n.lookup(options.merge(:keys => args))
+            end
+          rescue
+            key.to_s
+          end
+        end
+        alias :translate :babelize
+        alias :t :babelize
+        alias :_ :babelize
+      end
+    end
+    
+    Merb::Controller.send(:include, MLocale)
+    ML10n.load_localization!
+  end
+  
+  Merb::BootLoader.after_app_loads do
+    # code that can be required after the application loads
+  end
+  
+  Merb::Plugins.add_rakefiles "merb_babel/merbtasks"
+end

data/lib/merb_babel/locale_detector.rb

@@ -0,0 +1,80 @@
+module LocaleDetector
+  LANGUAGE_TO_COUNTRY = {
+    "nn"=>["NO"],
+    "uk"=>["UA"],
+    "it"=>["IT", "GI", "CH", "LY", "SM"],
+    "zh_TW"=>["TT", "VN", "HK"],
+    "no"=>["NO"],
+    "st"=>["ZA"],
+    "tk"=>["TM"],
+    "bn"=>["IN"],
+    "mn"=>["MN"],
+    "ja"=>["JP"],
+    "fr"=>["FR", "CD", "GG", "RW", "CG", "LU", "TT", "CH", "CI", "JE", "SC",
+      "VN", "BE", "MU", "DJ", "BI", "CA"],
+    "hi"=>["TT", "AE", "IN"],
+    "de"=>["DE", "LU", "CH", "LI", "AT", "BE", "RO"],
+    "ne"=>["NP"], "jw"=>["ID"],
+    "ta"=>["IN", "SG"],
+    "tl"=>["PH"],
+    "pt_PT"=>["PT", "GI"],
+    "hu"=>["HU", "SK", "RO"],
+    "sk"=>["SK"],
+    "fi"=>["FI"],
+    "sv"=>["SE", "FI"],
+    "iw"=>["IL"],
+    "az"=>["AZ"],
+    "zh"=>["TW"],
+    "ru"=>["RU", "KZ", "KG", "AZ", "LV", "UA", "TM", "AM", "UZ"],
+    "ky"=>["KG"],
+    "es"=>["ES", "HN", "CU", "PR", "TT", "PA", "VE", "DO", "BO", "GI", "PE",
+      "PY", "NI", "CL", "SV", "CO", "UY", "BZ", "CR", "EC", "GT", "AR", "MX"],
+    "ko"=>["KR"],
+    "pt_BR"=>["BR"],
+    "sw"=>["RW", "KE"],
+    "ga"=>["IE"],
+    "id"=>["ID"],
+    "eu"=>["ES"],
+    "gl"=>["ES"],
+    "xh"=>["ZA"],
+    "uz"=>["TM", "UZ"],
+    "mr"=>["IN"],
+    "fa"=>["AE"],
+    "zu"=>["LS", "ZA"],
+    "af"=>["NA", "ZA"],
+    "pl"=>["PL"],
+    "hy"=>["AM"],
+    "pa"=>["PK"],
+    "te"=>["IN"],
+    "ar"=>["AE", "LY", "SA", "DJ"],
+    "ms"=>["MY", "SG"],
+    "el"=>["GR"],
+    "ro"=>["RO"],
+    "mt"=>["MT"],
+    "ur"=>["AE", "PK"],
+    "da"=>["DK", "GL"],
+    "ca"=>["ES"],
+    "tr"=>["TR"],
+    "zh_CN"=>["SG"],
+    "nl"=>["NL", "BE", "ID"],
+    "vi"=>["VN"],
+    "lt"=>["LT", "LV"],
+    "th"=>["TH"],
+    "fo"=>["DK"],
+    "en"=>["US", "AS", "IE", "NP", "MY", "UK", "FM", "VC", "PR", "TT", "AU",
+      "PA", "NA", "GG", "LS", "RW", "VG", "AE", "GI", "VI", "AG", "TH", "CH",
+      "NF", "JE", "AI", "GL", "PH", "CK", "GM", "LY", "IN", "NZ", "NI", "SC",
+      "PK", "VN", "MS", "TO", "MT", "BE", "PN", "MU", "UG", "SG", "ZA", "BZ",
+      "SH", "MW", "FJ", "CR", "HK", "JM", "KE", "CA", "ID"],
+    "lv"=>["LV"]
+  }.freeze
+  
+module_function
+  def countries_from_language(language)
+    LANGUAGE_TO_COUNTRY[language]
+  end
+
+  def country_from_language(language)
+    (countries_from_language(language) || []).first
+  end
+end

data/lib/merb_babel/m_i18n.rb

@@ -0,0 +1,39 @@
+module MI18n
+  
+  def self.lookup(options)
+    keys = [options[:keys].map{|key| key.to_s}].flatten
+    language = options[:language]
+    country = options[:country]
+
+    raise ArgumentError, "You need to pass a language reference" unless language
+    raise ArgumentError, "You need to pass a localization key" if keys.empty?
+    raise ArgumentError,
+      "language: #{language} not found" unless ML10n.localizations[language]
+    
+    full_location = nil
+    full_location = lookup_with_full_locale(keys, language, country) if country
+    
+    if full_location
+      return full_location
+    else
+      return lookup_with_language(keys, language) || keys.last
+    end
+  end
+
+  def self.lookup_with_language(keys, language)
+    lookup_with_hash(keys, ML10n.localizations[language])
+  end
+  
+  def self.lookup_with_full_locale(keys, language, country)
+    if ML10n.localizations.has_key?(language)
+      ML10n.localizations[language].has_key?(country) ?
+        lookup_with_hash(keys, ML10n.localizations[language][country]) : nil 
+    else
+      nil
+    end
+  end
+  
+  def self.lookup_with_hash(keys, l_hash)
+    keys.inject(l_hash){|h,k| h[k] rescue nil}
+  end
+end

data/lib/merb_babel/m_l10n.rb

@@ -0,0 +1,149 @@
+module ML10n
+  LANGUAGE_CODE_KEY = 'mloc_language_code'.freeze
+  COUNTRY_CODE_KEY = 'mloc_country_code'.freeze
+  
+  class << self
+  
+    # TODO add a mutex for when we load the localizations, in case people want to load the localizations
+    # at runtime
+
+    # all localizations are saved in this class variable
+    # localizations are namespaced using the language or locale they belong to
+    #
+    # for instance:
+    #   ML10n.localizations['en'][:right] => 'right'
+    #   ML10n.localizations['en'][:left] => 'left'
+    #   ML10n.localizations['en']['US'][:greeting] => 'Howdie'
+    #   ML10n.localizations['en']['AU'][:greeting] => "Good'ay"
+    # 
+    # locales, including languages and countries use string keys while localization keys themselves are symbols  
+    def localizations
+      @@localizations ||= {}
+    end
+  
+    # files containing localizations
+    def localization_files
+      @@localization_files ||= ML10n.find_localization_files
+    end
+  
+    # locations to look for localization files
+    def localization_dirs
+      @@localization_dirs ||= Merb::Plugins.config[:merb_babel][:localization_dirs].dup
+    end
+  
+    # add a dir to look for localizations
+    def add_localization_dir(dir_path)
+      return ML10n.localization_dirs if dir_path.empty?
+      unless ML10n.localization_dirs.include?(dir_path)
+        ML10n.localization_dirs << dir_path
+        ML10n.reload_localization_files! 
+      end
+      return ML10n.localization_dirs
+    end
+  
+    def load_localization!
+    
+      # look for localization files directly just in case new files were added
+      ML10n.reset_localization_files! 
+      ML10n.find_localization_files.each do |l_file|
+        begin
+          l_hash = YAML.load_file(l_file)#.symbolize_keys
+        rescue Exception => e
+          # might raise a real error here in the future
+          p e.inspect
+        else
+          load_localization_hash(l_hash)
+        end
+      end
+    
+    end
+  
+    # go through the localization dirs and find the localization files
+    def find_localization_files
+      l_files = []
+      ML10n.localization_dirs.map do |l_dir|
+        Dir["#{l_dir}/*"].each do |file|
+          l_files << file unless l_files.include?(file)
+        end
+      end
+      return l_files
+    end
+  
+    # reset the localization dirs and files to the plugin config
+    # careful when using this method since it will remove any localization files
+    # you loaded after the plugin started
+    # 
+    # note that it won't clear the localization already loaded in memory
+    def reset_localization_files_and_dirs!
+      ML10n.reset_localization_dirs!
+      ML10n.reset_localization_files!
+    end
+  
+    def reset_localization_dirs!
+      @@localization_dirs = nil
+    end
+  
+    def reset_localization_files!
+      @@localization_files = nil
+      ML10n.find_localization_files
+    end
+
+    def reset_localizations!
+      @@localizations = {}
+    end
+  
+    def reload_localization_files!
+      ML10n.reset_localization_files!
+      ML10n.find_localization_files
+    end
+  
+    # localization helper
+    def localize(key, *options)
+      MI18n.localize(options.merge({:locale => locale}))
+    end
+
+    def localize_time(object, format, options)
+      table_for = proc do |table_name, key, default|
+        keys = ["DateFormat", table_name]
+        table = MI18n.lookup(options.merge(:keys => keys)) || {}
+        table[key] || default
+      end
+      format = format.to_s.dup
+      format.gsub!(/%a/) do
+        table_for["AbbrDayNames", object.wday, "%a"]
+      end
+      format.gsub!(/%A/) do
+        table_for["AbbrMonthNames", object.mon - 1, "%A"]
+      end
+      format.gsub!(/%B/) do
+        table_for["MonthNames", object.mon - 1, "%B"]
+      end
+      format.gsub!(/%p/) do
+        table_for["AmPm", object.hour < 12 ? 0 : 1, "%p"]
+      end if object.respond_to?(:hour)
+      format.gsub!(/%\{([a-zA-Z]\w*)\}/) do
+        object.send($1) rescue $1
+      end
+      object.strftime(format)
+    end
+  
+    protected
+  
+    def load_localization_hash(l_hash)
+      if l_hash.has_key?(LANGUAGE_CODE_KEY)
+        language = l_hash[LANGUAGE_CODE_KEY]
+        if l_hash.has_key?(COUNTRY_CODE_KEY)
+          country = l_hash[COUNTRY_CODE_KEY]
+          # load localization under the full locale namespace
+          ML10n.localizations[language] ||= {}
+          (ML10n.localizations[language][country] ||= {}).merge!(l_hash)
+        else
+          # load generic language localization
+          (ML10n.localizations[language] ||= {}).merge!(l_hash)
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/merb_babel/m_locale.rb

@@ -0,0 +1,103 @@
+
+# The MLocale module helps you set up a locale, language, country
+# You don't have to use a locale, in some cases you might just want to use the language
+module MLocale
+  def locale_from_request
+    if hal = request.env["HTTP_ACCEPT_LANGUAGE"]
+      hal.gsub!(/\s/, "")
+      result = hal.split(/,/).map do |v|
+        v.split(";q=")
+      end.map do |j|
+        [j[0], j[1] ? j[1].to_f : 1.0]
+      end.sort do |a,b|
+        -(a[1] <=> b[1])
+      end.map do |v|
+        Locale::Tag.parse(v[0])
+      end.first
+      return nil if result.nil?
+      language = result.language
+      country = result.country ||
+        LocaleDetector.country_from_language(language)
+      request.env[:locale] = "#{language}-#{country}"
+    end
+  end
+
+  # A locale is made of a language + country code, such as en-UK or en-US 
+  def locale 
+    request.env[:locale] || params[:locale] || (session ? session[:locale] : nil) || locale_from_request || default_locale
+  end
+  
+  # Many people don't care about locales, they might just want to use languages instead
+  def language
+    request.env[:language] || params[:language] || language_from_locale || (session ? session[:language] : nil) || default_language
+  end
+  
+  # The country is used when localizing currency or time
+  def country
+    request.env[:country] || params[:country] || country_from_locale || (session ? session[:country] : nil) || LocaleDetector.country_from_language(language) || default_country
+  end
+  
+  # Extract the language from the locale
+  def language_from_locale
+    if request.env[:locale] && request.env[:locale] =~ locale_regexp
+      language, country = request.env[:locale].match(locale_regexp).captures
+      return language
+    else 
+      return nil
+    end
+  end
+  
+  # Extract the country from the locale
+  def country_from_locale
+    request.env[:locale] ? request.env[:locale][3..5].upcase : nil
+  end
+  
+  # Defaults set in the plugin settings
+  # You can change the default settings by overwriting 
+  # the Merb::Plugins.config[:merb_abel] hash in your settings
+  #
+    def default_locale
+      Merb::Plugins.config[:merb_babel] ? Merb::Plugins.config[:merb_babel][:default_locale] : nil
+    end
+
+    def default_language
+      Merb::Plugins.config[:merb_babel] ? Merb::Plugins.config[:merb_babel][:default_language] : nil
+    end
+  
+    def default_country
+      Merb::Plugins.config[:merb_babel] ? Merb::Plugins.config[:merb_babel][:default_country] : nil
+    end
+  #
+  #### end of defaults
+  
+  protected
+
+    def locale_regexp
+      /(.+)\-([a-z]{2})/i
+    end
+    
+    # You can extend this method in application.rb
+    # example:
+    #
+    #   def set_locale
+    #     super
+    #     session[:language] = language
+    #   end
+    #
+    #
+    # takes a locale as in fr-FR or en-US
+    def set_locale
+      if locale =~ locale_regexp
+        language, country = locale.match(locale_regexp).captures
+        # Set the locale, language and country
+        language = language.downcase
+        country = country.upcase
+        request.env[:locale] = "#{language}-#{country}"
+      end
+      
+    end
+  
+    def set_language
+      request.env[:language] = language.downcase
+    end
+end

data/lib/merb_babel/merbtasks.rb

@@ -0,0 +1,6 @@
+# namespace :merb_babel do
+#   desc "Do something for merb_babel"
+#   task :default do
+#     puts "merb_babel doesn't do anything"
+#   end
+# end

data/spec/lang/en-UK.yml

@@ -0,0 +1,13 @@
+#################################################
+# en-UK only localization
+#
+# only add localization specific to this locale
+# other comman localizations must go in en.yml
+#################################################
+# required
+mloc_language_code: en
+# required for a locale localization file
+mloc_country_code: UK
+#################################################
+
+greetings: Heya

data/spec/lang/en-US.yml

@@ -0,0 +1,13 @@
+#################################################
+# en-US only localization
+#
+# only add localization specific to this locale
+# other comman localizations must go in en.yml
+#################################################
+# required
+mloc_language_code: en
+# required for a locale localization file
+mloc_country_code: US
+#################################################
+
+greetings: Howdie

data/spec/lang/en.yml

@@ -0,0 +1,22 @@
+#################################################
+# English localization
+#
+# localization specific must go in their own file
+# see en-US.yml for instance
+#################################################
+mloc_language_code: en
+# Optional, the following key has the name of the localized language in its ow language.
+mloc_language_name: English
+# mloc_country:
+#################################################
+
+
+right: right
+left: left
+greetings: Hello
+
+night:
+  greetings: Good evening
+
+DateFormat:
+  AbbrDayNames: ["S", "M", "T", "W", "T", "F", "S"]

data/spec/lang/ja.yml

@@ -0,0 +1,23 @@
+#################################################
+# Japanese localization
+#
+# localization specific must go in their own file
+# see ja-JP.yml for instance
+#################################################
+mloc_language_code: ja
+# Optional, the following key has the name of the localized language in its ow language.
+mloc_language_name: Japanese
+# mloc_country:
+#################################################
+
+
+right: 右
+left: 左
+greetings: こんにちわ
+
+night:
+  greetings: こんばんわ
+
+DateFormat:
+  AbbrDayNames: ["日", "月", "火", "水", "木", "金", "土"]
+  AmPm: ["午前", "午後"]

data/spec/locale_detector_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'country detector' do
+  it "should detect country from request" do
+    c = dispatch_to(TestController, :index, {},
+      'HTTP_ACCEPT_LANGUAGE' => 'en-UK')
+    c.country.should == 'UK'
+  end
+
+  it "should detect language from request" do
+    c = dispatch_to(TestController, :index, {},
+      'HTTP_ACCEPT_LANGUAGE' => 'fr-FR')
+    c.language.should == 'fr'
+  end
+
+  it "should detect full locale from request" do
+    c = dispatch_to(TestController, :index, {},
+      'HTTP_ACCEPT_LANGUAGE' => 'en-UK')
+    c.locale.should == 'en-UK'
+  end
+
+  it "should detect full locale from request 2" do
+    c = dispatch_to(TestController, :index, {},
+      'HTTP_ACCEPT_LANGUAGE' => 'en_UK')
+    c.language.should == 'en'
+    c.country.should == 'UK'
+    c.locale.should == 'en-UK'
+  end
+
+  it "should guess country from language" do
+    c = dispatch_to(TestController, :index, {},
+      'HTTP_ACCEPT_LANGUAGE' => 'ja')
+    c.country.should == 'JP'
+    c.locale.should == 'ja-JP'
+  end
+
+  it "should detect language from request including candidates" do
+    c = dispatch_to(TestController, :index, {},
+      'HTTP_ACCEPT_LANGUAGE' => 'ja,en;q=0.9,fr;q=0.8,de;q=0.7,es;q=0.6')
+    c.locale.should == 'ja-JP'
+  end
+end

data/spec/m_i18n_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/spec_helper'
+  
+describe '#babelize' do
+  
+  before(:each) do
+    Merb::Controller.send :include, Merb::GlobalHelpers
+    @c = dispatch_to(TestController, :index)
+    ML10n.add_localization_dir(File.expand_path(File.dirname(__FILE__) + "/lang"))
+    ML10n.add_localization_dir(File.expand_path(File.dirname(__FILE__) + "/other_lang_dir"))
+    ML10n.load_localization!
+  end
+
+  after(:each) do
+    ML10n.reset_localizations!
+  end
+
+  it "should babelize a word in English " do
+    @c.locale.should == 'en-US'
+    @c.language.should == 'en'
+    @c.country.should == 'US'
+    @c.babelize(:left).should == 'left'
+  end
+  
+  it "should translate a word in English" do
+    @c.t(:left).should == 'left'
+    @c.translate(:left).should == 'left'
+    @c._(:left).should == 'left'
+  end
+  
+  it "should translate a word in american English" do
+    @c.t(:greetings).should == 'Howdie'
+  end
+  
+  it "should translate a word in british English" do
+    @c.request.env[:locale] = 'en-UK'
+    @c.t(:greetings).should == 'Heya'
+  end
+  
+  it "should translate a word in French" do
+    @c.request.env[:language] = 'fr'
+    @c.t(:greetings).should == 'Salut'
+  end
+  
+  it "should translate passing the full locale" do
+    @c.t(:greetings, :language => 'en', :country => 'UK').should == 'Heya'
+    @c.t(:greetings, :language => 'en', :country => 'US').should == 'Howdie'
+  end
+  
+  it "should translate passing the language" do
+    @c.t(:greetings, :language => 'fr').should == 'Salut'
+  end
+  
+  it "should translate with domain" do
+    @c.t(:night, :greetings, :language => 'en').should == 'Good evening'
+    @c.t(:night, :greetings, :language => 'ja').should == 'こんばんわ'
+  end
+
+  it "should localize date" do
+    date = Date.new(2009,1,1)
+    @c.t("%Y/%m/%d", date, :language => 'en').should == "2009/01/01"
+    @c.t("%Y/%{mon}/%{day}", date, :language => 'en').should == "2009/1/1"
+    @c.t("%a/%d", date, :language => 'en').should == "T/01"
+    @c.t("%a/%d", date, :language => 'en', :country => 'UK').should == "T/01"
+    @c.t("%a/%d", date, :language => 'ja').should == "木/01"
+  end
+
+  it "should localize time" do
+    time = Time.now
+    if time.hour < 12
+      @c.t("%p", time, :language => "ja").should == "午前"
+    else
+      @c.t("%p", time, :language => "ja").should == "午後"
+    end
+  end
+end

data/spec/m_l10n_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "ML10n" do
+  
+  before(:each) do
+    @lang_test_path = File.expand_path(File.dirname(__FILE__) + "/lang")
+    @lang_test_path_2 = File.expand_path(File.dirname(__FILE__) + "/other_lang_dir")
+    ML10n.reset_localization_files_and_dirs!
+  end
+
+  after(:each) do
+    ML10n.reset_localizations!
+  end
+  
+  it "should have a list of localization directories" do
+    ML10n.localization_dirs.should == Merb::Plugins.config[:merb_babel][:localization_dirs]
+  end
+  
+  it "should be able to add a new localization directory" do
+    ML10n.add_localization_dir(@lang_test_path)
+    ML10n.localization_dirs.include?(@lang_test_path)
+  end
+  
+  it "should have a list of localization source files" do
+    ML10n.localization_files.should == []
+    ML10n.add_localization_dir(@lang_test_path)
+    ML10n.localization_files.include?("#{@lang_test_path}/en.yml").should be_true
+    ML10n.localization_files.include?("#{@lang_test_path}/en-US.yml").should be_true
+  end
+  
+  it "should load localization files and have them available" do
+    ML10n.add_localization_dir(@lang_test_path)
+    ML10n.load_localization!
+    ML10n.localizations['en']['right'].should == 'right'
+    ML10n.localizations['en']['left'].should == 'left'
+    ML10n.localizations['en']['US']['greetings'].should == 'Howdie'
+  end
+  
+  it "should load more localization files and have them available" do
+    ML10n.add_localization_dir(@lang_test_path)
+    ML10n.load_localization!
+    ML10n.localizations['en']['right'].should == 'right'
+    ML10n.localizations.has_key?('fr').should be_false
+    
+    ML10n.add_localization_dir(@lang_test_path_2)
+    ML10n.load_localization!
+    ML10n.localizations['en']['right'].should == 'right'
+    ML10n.localizations.has_key?('fr').should be_true
+    ML10n.localizations['fr']['right'].should == 'la droite'
+    ML10n.localizations['fr']['left'].should == 'la gauche'
+    ML10n.localizations['fr']['greetings'].should == 'Salut'
+  end
+  
+end

data/spec/merb_babel_spec.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe 'using set_locale before filter, ' do
+  describe 'a controller' do
+  
+    describe 'locale' do
+    
+      it "should be set by default" do
+        c = dispatch_to(TestController, :index)
+        c.locale.should == 'en-US'
+      end
+  
+      it "should be able to be set by passing a param" do
+        c = dispatch_to(TestController, :index, :locale => 'fr-FR')
+        c.locale.should == 'fr-FR'
+      end
+      
+      it "should be able to be set using the session" do
+        c = dispatch_to(TestController, :index) do |controller|
+          controller.stub!(:session).and_return( :locale => "es-BO" )
+        end
+        c.locale.should == 'es-BO'
+      end
+      
+      it "should be set using an url (when the routes are set properly)" do
+        #c = get('tests')
+        #c.locale.should == 'en-US'
+        c = get('en-US/tests')
+        c.locale.should == 'en-US'
+        c = get('en-UK/tests')
+        c.locale.should == 'en-UK'
+      end
+      
+      it "should support longer locales (like zh-Hans-CN)" do
+        c = dispatch_to(TestController, :index, :locale => 'zh-Hans-CN')
+        c.locale.should == 'zh-hans-CN'
+      end
+    
+    end
+  
+    describe 'language' do 
+    
+      it "should be set by default" do
+        c = dispatch_to(TestController, :index)
+        c.language.should == 'en'
+      end
+  
+      it "should be able to be set by passing a param" do
+        c = dispatch_to(TestController, :index, :language => 'fr')
+        c.language.should == 'fr'
+      end
+    
+      it "should bet set when a locale was set by params" do
+        c = dispatch_to(TestController, :index, :locale => 'fr-FR')
+        c.locale.should == 'fr-FR'
+        c.language.should == 'fr'
+      end
+      
+      it "should be set when a locale was set by params even with a long locale" do
+        c = dispatch_to(TestController, :index, :locale => 'zh-Hans-CN')
+        c.language.should == 'zh-hans'
+      end
+      
+      it "should bet set when a locale was set by session" do
+        c = dispatch_to(TestController, :index) do |controller|
+          controller.stub!(:session).and_return( :locale => "es-BO" )
+        end
+        c.language.should == 'es'
+      end
+      
+      it "should be set by the router" do
+        c = get('fr/languages')
+        c.language.should == 'fr'
+        c.locale.should == 'en-US'
+        # c = get('languages')
+        # c.language.should == 'en'
+      end
+  
+    end
+  
+    describe 'country' do
+
+      it "should be set by default" do
+        c = dispatch_to(TestController, :index)
+        c.country.should == 'US'
+      end
+    
+      it "should be able to be set by passing a param" do
+        c = dispatch_to(TestController, :index, :country => 'ES')
+        c.country.should == 'ES'
+      end
+      
+      it "should bet set when a locale was set by params" do
+        c = dispatch_to(TestController, :index, :locale => 'fr-FR')
+        c.country.should == 'FR'
+      end
+      
+      it "should bet set when a locale was set by session" do
+        c = dispatch_to(TestController, :index) do |controller|
+          controller.stub!(:session).and_return( :locale => "es-BO" )
+        end
+        c.country.should == 'BO'
+      end
+  
+    end
+    
+  end
+end
+
+describe 'using set_language, ' do
+  describe 'a controller' do
+    describe 'language' do 
+    
+      it "should be set by default" do
+        c = dispatch_to(LanguageController, :index)
+        c.language.should == 'en'
+      end
+  
+      it "should be able to be set by passing a param" do
+        c = dispatch_to(LanguageController, :index, :language => 'fr')
+        c.language.should == 'fr'
+      end
+  
+    end
+  end
+end

data/spec/other_lang_dir/fr.yml

@@ -0,0 +1,14 @@
+#################################################
+# French localization
+#
+# localization specific must go in their own file
+# see en-US.yml for instance
+#################################################
+mloc_language_code: fr
+# mloc_country:
+#################################################
+
+right: la droite
+left: la gauche
+greetings: Salut
+

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require "rubygems"
+require "spec"
+require "merb-core"
+require File.join(File.dirname(__FILE__), "..", 'lib', 'merb_babel')
+
+default_options = {
+  :environment => 'test',
+  :adapter     => 'runner',
+  :session_store => 'cookie',
+  :session_secret_key => '187a66e27674660418cf4499471d5a0587f360d0'
+}
+
+options = default_options.merge($START_OPTIONS || {})
+
+Merb.disable(:initfile)
+Merb.start_environment(options)
+
+Spec::Runner.configure do |config|
+  config.include Merb::Test::ViewHelper
+  config.include Merb::Test::RouteHelper
+  config.include Merb::Test::RequestHelper
+  config.include Merb::Test::ControllerHelper
+end
+
+Merb.load_dependencies(:environment => 'test')
+
+Merb::Router.prepare do |r|
+  r.match(/\/?(en\-US|en\-UK|es\-ES|es\-AR)?/).to(:locale => "[1]") do |l|
+    l.match("/tests").to(:controller => "test_controller")
+  end
+  r.match(/\/?(en|es|fr|de)?/).to(:language => "[1]") do |l|
+    l.match("/languages").to(:controller => "language_controller")
+  end
+end
+
+
+
+class TestController < Merb::Controller
+  
+  before :set_locale
+  def index; end
+end
+
+class LanguageController < Merb::Controller
+  
+  before :set_language
+  def index; end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: merb_babel
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Matt Aimonetti
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-16 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: locale
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.0
+    version: 
+description: Merb plugin that provides simple localization/internationalisation
+email: mattaimonetti@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- TODO
+- lib/merb_babel
+- lib/merb_babel/locale_detector.rb
+- lib/merb_babel/m_i18n.rb
+- lib/merb_babel/m_l10n.rb
+- lib/merb_babel/m_locale.rb
+- lib/merb_babel/merbtasks.rb
+- lib/merb_babel.rb
+- spec/lang
+- spec/lang/en-UK.yml
+- spec/lang/en-US.yml
+- spec/lang/en.yml
+- spec/lang/ja.yml
+- spec/locale_detector_spec.rb
+- spec/m_i18n_spec.rb
+- spec/m_l10n_spec.rb
+- spec/merb_babel_spec.rb
+- spec/other_lang_dir
+- spec/other_lang_dir/fr.yml
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mattetti/merb_babel/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: merb
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Merb plugin that provides simple localization/internationalisation
+test_files: []
+