zlocalize 4.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ce7804e560ece2fb93d685c350d22beea6e1fdf
+  data.tar.gz: 0cc0ca863ae4fec576455a364a76c2a5840eba27
+SHA512:
+  metadata.gz: a362c71b9dbb6d90cb37c60005066a85f92360879aef6a734622c7a70ff14723c9e14f6b84c513c2472fb5b2228ab9eec18f26e3949b4078b111930b3ca7d1cd
+  data.tar.gz: 81ea38ffc8fbf24ee4ed99f6b011e33af4a2d2e52fc7ddb6e3f8248d022f0738eff2a87424588dea9a38bde47f99832fb12d030ed949c1d8ee5e3c95260ba8a3

data/lib/zlocalize/backend.rb

@@ -0,0 +1,246 @@
+# -*- encoding : utf-8 -*-
+
+require 'yaml'
+require 'zlocalize/translation_file'
+require 'zlocalize/config'
+require 'i18n'
+
+module ZLocalize
+
+  class MissingTranslationDataError < StandardError
+
+    def initialize(locale, key, options)
+      super "No translation exists in '#{locale}' for key \"#{key}\""
+    end
+
+  end
+
+  @@load_mutex = Mutex.new
+
+  class << self
+
+    INTERPOLATE_MATCH = /(\\)?\{\{([^\}]+)\}\}/
+    SCOPE_MATCH = /(.*?)(\\)?::(.+)/
+
+    DEFAULT_PLURAL_SELECT_PROC = lambda { |n| n <= 0 ? 0 : (n > 1 ? 2 : 1) }
+    DEFAULT_TITLEIZE_PROC      = lambda { |s| s.to_s.titleize }
+    DEFAULT_CONVERT_FLOAT_PROC = lambda { |s| s.to_s.gsub(",", "") }
+
+    def config
+      @config ||= ZLocalize::Config.new
+    end
+
+    def locale
+      I18n.locale
+    end
+
+    def locale=(value)
+      I18n.locale = value
+    end
+
+    def default_locale
+      I18n.default_locale
+    end
+
+    def default_locale=(value)
+      I18n.default_locale = value
+    end
+
+    def translate(key, options = {})
+      loc = options[:locale] || self.locale
+      translate_with_locale(loc,key,options)
+    end
+    alias :t :translate
+
+    def pluralize(key,count,options = {})
+      loc = options[:locale] || self.locale
+      pluralize_with_locale(loc,key,count,options)
+    end
+    alias :p :pluralize
+
+    # Change locale inside a block
+    def switch_locale(new_locale,&block)
+      @@switch_locale_stack ||= []
+      if block_given?
+        @@switch_locale_stack.push self.locale
+        self.locale = new_locale
+        yield
+        self.locale = @@switch_locale_stack.pop
+      else
+        self.locale = new_locale
+      end
+    end
+
+    def translate_with_locale(locale, key, options = {})
+      entry = lookup(locale,"#{key}")
+      if entry.nil?
+        if (default = options.delete(:default))
+          entry = default
+        elsif (options.delete(:return_source_on_missing) || @return_source_on_missing) == true
+          entry = remove_scope(key)
+        else
+          raise ZLocalize::MissingTranslationDataError.new(locale, key, options)
+        end
+      end
+      return interpolate(locale, entry, options).html_safe
+    end
+
+    # n_(["...","...","..."],count)
+    def pluralize_with_locale(locale, key, count, options = {})
+
+      entry = lookup(locale,key)
+      if entry.nil?
+        if (default = options.delete(:default))
+          entry = default
+        elsif (options.delete(:return_source_on_missing) || @return_source_on_missing) == true
+          entry = key
+        else
+          raise ZLocalize::MissingTranslationDataError.new(locale,key,options)
+        end
+      end
+      n = translation_procs[locale.to_sym][:plural_select].call(count)
+      options[:count] ||= count
+      return interpolate(locale, entry[n], options).html_safe
+    end
+
+    def titleize(locale,s)
+      translation_procs[locale.to_sym][:titleize].call(s).html_safe
+    end
+
+    def convert_float(locale,s)
+      translation_procs[locale.to_sym][:convert_float].call(s)
+    end
+
+    def multi_lookup(locale,values,options = {})
+      result = {}
+      values.each do |val|
+        s = lookup(locale,"#{val}")
+        result[val] = s.html_safe unless s.nil?
+      end
+      result
+    end
+
+    # Interpolates values into a given string.
+    #
+    #   interpolate "file {{file}} opened by \\{{user}}", :file => 'test.txt', :user => 'Mr. X'
+    #   # => "file test.txt opened by {{user}}"
+    #
+    # Note that you have to double escape the <tt>\\</tt> when you want to escape
+    # the <tt>{{...}}</tt> key in a string (once for the string and once for the
+    # interpolation).
+    def interpolate(locale, string, values = {})
+      return string unless string.is_a?(String)
+
+      result = string.gsub(INTERPOLATE_MATCH) do
+        escaped, pattern, key = $1, $2, $2.to_sym
+
+        if escaped
+          "{{#{pattern}}}"
+        elsif !values.include?(key)
+          raise ArgumentError, "The #{key} argument is missing in the interpolation of '#{string}'"
+        else
+          values[key].to_s
+        end
+      end
+
+      result
+    end
+
+    def initialized?
+      @initialized ||= false
+    end
+
+    def reload!(force = false)
+      if force || !@initialized || (self.config.reload_per_request[Rails.env.to_sym] == true)
+        @initialized = false
+        @translations = nil
+        @translation_procs = nil
+      end
+    end
+
+    def locales
+      init_translations unless initialized?
+      translations.keys.map { |k| k.to_s }
+    end
+
+    alias :available_locales :locales
+
+    def translations
+      init_translations unless initialized?
+      @translations
+    end
+
+    def translation_procs
+      init_translations unless initialized?
+      @translation_procs
+    end
+
+    protected
+      # init_translations manipulates the translation data and is triggered by lazy-loading, meaning
+      # that on a busy multi-threaded environment, you might get 2 different threads trying to load the
+      # data concurrently. Therefore, this method is wrapped inside a mutex, which effectively ensures
+      # only 1 Thread will initialize the translation data Hash.
+      # The rest of all operations on translation data is read-only, so no concurrency issues except here
+      def init_translations
+        @@load_mutex.synchronize do
+          unless @initialized
+            @translation_procs = {}
+            @translations = {}
+
+            config.locales.keys.each do |locale|
+              cfg = self.config.locales[locale]
+              loc = locale.to_sym
+              @translation_procs[loc] = {
+                :plural_select => cfg[:plural_select].is_a?(Proc) ? cfg[:plural_select] : DEFAULT_PLURAL_SELECT_PROC,
+                :titleize      => cfg[:titleize].is_a?(Proc) ? cfg[:titleize] : DEFAULT_TITLEIZE_PROC,
+                :convert_float => cfg[:convert_float].is_a?(Proc) ? cfg[:convert_float] : DEFAULT_CONVERT_FLOAT_PROC,
+              }
+              files = [cfg[:translations]].flatten.compact
+              load_translations(loc,files)
+            end
+
+            @return_source_on_missing = config.return_source_on_missing[Rails.env.to_sym]
+
+            @initialized = true
+          end
+        end
+      end
+
+      def load_translations(locale,filenames)
+        @translations ||= {}
+        @translations[locale] ||= {}
+        filenames.each do |file|
+          unless file.nil?
+            tf = ZLocalize::TranslationFile.new
+            tf.load(file)
+            tf.entries.each do |key,entry|
+              @translations[locale][entry.source] = entry.translation unless entry.ignore || entry.translation.to_s.empty?
+            end
+          end
+        end
+      end
+
+      def lookup(locale, key)
+        return unless key
+        init_translations unless @initialized
+        return @translations[locale.to_sym][key]
+      end
+
+      def remove_scope(key)
+        return key unless key.is_a?(String)
+
+        result = key.gsub(SCOPE_MATCH) do
+          scope, escaped, unscoped = $1, $2, $3
+          if $2 # escaped with \\::
+            # $~[0]
+            scope + '::' + $3
+          else
+            $3
+          end
+        end
+      end
+
+  end # class << self
+
+end # module ZLocalize
+

data/lib/zlocalize/config.rb

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+module ZLocalize
+
+  class Config
+
+    attr_reader :reload_per_request
+    attr_reader :return_source_on_missing
+    attr_reader :reload_per_request
+    attr_reader :locales
+    attr_reader :define_gettext_methods
+
+    def initialize
+      @reload_per_request = { :development => true, :test => false, :production => false, :staging => false }
+      @return_source_on_missing = { :development => true, :test => false, :production => false, :staging => false }
+      @locales = {}
+      @use_global_gettext_methods = true
+    end
+
+    def reload_per_request=(value)
+      if value === true || value === false
+        [:development,:test,:production,:staging].each do |env|
+          @reload_per_request[env] = value
+        end
+      elsif value.is_a?(Hash)
+        @reload_per_request.merge!(value)
+      end
+    end
+
+    def return_source_on_missing=(value)
+      if value === true || value === false
+        [:development,:test,:production,:staging].each do |env|
+          @return_source_on_missing[env] = value
+        end
+      elsif value.is_a?(Hash)
+        @return_source_on_missing.merge!(value)
+      end
+    end
+
+    def locales=(value)
+      @locales = value
+    end
+
+    def define_gettext_methods=(value)
+      @define_gettext_methods = value ? true : false
+      please_define_gettext_methods if @define_gettext_methods
+    end
+
+    def please_define_gettext_methods
+      Object.class_eval <<-EOV
+         def _(key,options = {})
+           ZLocalize.translate(key, options)
+         end
+
+         def n_(key,count,options = {})
+           ZLocalize.pluralize(key,count,options)
+         end
+      EOV
+    end
+
+  end # class Config
+
+end # module ZLocalize

data/lib/zlocalize/harvester.rb

@@ -0,0 +1,123 @@
+# -*- encoding : utf-8 -*-
+
+require 'rubygems'
+require 'erb'
+require File.join(File.dirname(__FILE__),'source_parser')
+require File.join(File.dirname(__FILE__),'translation_file')
+
+module ZLocalize
+
+   INDENT_STEP = 3
+
+   class HarvesterError < StandardError
+   end
+
+   # Harvester will parse and extract all calls to translation methods in "app/models/",
+   # "app/controllers/" and "app/views/"
+   class Harvester
+
+     attr_accessor :rails_root
+
+     DEFAULT_HARVEST_OPTIONS = { :models => true, :controllers => true,
+                                 :views => true, :helpers => true,
+                                 :output => 'config/locales/app-strings.yml',
+                                 :overwrite_existing => false,
+                                 :add_paths   => [],
+                                 :silent => false,
+                                 :purge => false }
+
+     HARVEST_SECTIONS = { :models      => [ "app/models/**/*.rb" ],
+                          :controllers => [ "app/controllers/**/*.rb" ],
+                          :helpers     => [ "app/helpers/**/*.rb" ],
+                          :views       => [ "app/views/**/*.erb", "app/views/**/*.rhtml" ],
+                          :lib         => [ "lib/**/*.rb"]
+                        }
+
+     def initialize(rails_root, options = {})
+        @rails_root = rails_root
+        @options = DEFAULT_HARVEST_OPTIONS.merge(options)
+     end
+
+     def progress(msg)
+        print msg unless @options[:silent]
+     end
+
+     def harvest_section(section,filespecs)
+       progress("Harvesting localizable strings from #{section}:\n")
+       filespecs.each do |spec|
+         progress("#{spec}: ")
+         Dir.glob(File.join(@rails_root,spec)) do |f|
+           progress('.')
+           collect_entries(f,@rails_root,is_erb?(f))
+         end
+         progress("\n")
+       end
+     end
+
+     def is_erb?(filename)
+       ['.erb','.rhtml'].include?(File.extname(filename))
+     end
+
+     def harvest
+        @new_entries = TranslationEntryCollection.new
+        HARVEST_SECTIONS.each_pair do |section,paths|
+          harvest_section(section,paths)
+          progress("\n")
+        end
+        if @options[:add_paths].is_a?(Array) && @options.size > 0
+          harvest_section("additional paths",@options[:add_paths])
+          progress("\n")
+        end
+
+        @translation_file = ZLocalize::TranslationFile.new
+        unless @options[:overwrite_existing]
+           progress("Merging existing translations from #{@options[:output]}...\n")
+           begin
+             @translation_file.load(File.join(@rails_root,@options[:output]))
+           rescue
+           end
+        end
+
+        @translation_file.entries.synchronize_with(@new_entries,@options[:purge])
+
+        progress("Writing new translation file...\n")
+        File.open(File.join(@rails_root,@options[:output]),"w") do |f|
+           f.write(@translation_file.to_yaml)
+        end
+
+        progress("Done!\n\n")
+     end
+
+     def harvest_file(filename)
+       @new_entries = TranslationEntryCollection.new
+       collect_entries(filename,@rails_root,false)
+
+       @translation_file = ZLocalize::TranslationFile.new
+       # merge
+       @translation_file.load(File.join(@rails_root,@options[:output]))
+       @translation_file.entries.synchronize_with(@new_entries,@options[:purge])
+       File.open(File.join(@rails_root,@options[:output]),"w") do |f|
+          f.write(@translation_file.to_yaml)
+       end
+     end
+
+     # collect entries in a source file
+     def collect_entries(filename,root,is_erb = false)
+        sp = ZLocalize::SourceParser.new(filename,root,is_erb)
+        sp.parse
+        sp.translation_entries.each do |key,te|
+          if @new_entries[key]
+             te.references.each do |ref|
+                @new_entries[key].add_reference(ref)
+             end
+          else
+            @new_entries[key] = te.dup
+          end
+        end
+     end
+
+   end
+
+end # module Harvester
+
+

data/lib/zlocalize/rails/active_record.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+
+require 'zlocalize/rails/attached_translations'
+ActiveRecord::Base.send(:include, ZLocalize::Translatable::AttachedTranslations)
+
+require 'zlocalize/rails/translated_columns'
+ActiveRecord::Base.send(:include, ZLocalize::Translatable::TranslatedColumns)
+
+require 'zlocalize/rails/decimal_attributes'
+ActiveRecord::Base.send(:include, ZLocalize::Translatable::LocalizedDecimalAttributes)
+

data/lib/zlocalize/rails/attached_translations.rb

@@ -0,0 +1,122 @@
+# -*- encoding : utf-8 -*-
+
+#
+#  === Translation of attributes values for ActiveRecord ===
+#
+#  Allows a model to have multiple values (one for each given locale) stored for one or more attributes
+#
+#  Uses a Translation model, declared as a polymorphic association
+#
+#  Example use:
+#
+#  class Article < ActiveRecord::Base
+#    ....
+#    has_translations
+#    ....
+#  end
+#
+#
+#  > @article = Article.new
+#  > @article.insert_translations(:fr => { :title => "L'année en revue" }, :en => { :title => "The Year in Review" })
+#  > @article.translate('title','fr')
+#    => "L'année en revue"
+#  > @article.translate('title','en')
+#    => "The year in review"
+#
+#  It is also possible to declare the translations as nested_attributes:
+#
+#
+#  has_translations
+#  accepts_nested_attributes_for :translations, :allow_destroy => true
+#
+#  which would allow to assign translations from within a form (using fields_for helper).
+#
+#  params[:article][:translations_attributes] = [ { :locale => :fr, :name => 'title', :value => "L'année en revue" },
+#                                                 { :locale => :en, :name => 'title', :value => "The Year in Review" } ]
+#
+module ZLocalize
+  module Translatable #:nodoc:
+
+    class TranslationError < StandardError #:nodoc:
+    end
+
+    module AttachedTranslations #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def has_translations
+          has_many :translations, :as => :translated, :dependent => :destroy
+          include ZLocalize::Translatable::AttachedTranslations::InstanceMethods
+        end
+
+      end
+
+      module InstanceMethods
+
+        def translate(attr_name,locale = nil)
+          locale ||= ZLocalize.locale
+          if tr = find_translation(attr_name,locale)
+            tr.value
+          else
+            ''
+          end
+        end
+
+        def add_translation(name,locale,value)
+          if tr = find_translation(name,locale)
+            tr.value = value.to_s
+          else
+            tr = translations.build(:translated => self, :name => name.to_s, :locale => locale.to_s, :value => value.to_s)
+          end
+          tr
+        end
+
+        # convenience method to accept a Hash containing the translations for multiple columns and
+        # locales. +locales+ must have the locales as keys and its value is another Hash of name-value pairs.
+        # Example:
+        #    @article.insert_translations(
+        #         { 'en' => { 'title'    => "What's new this week",
+        #                     'synopsis' => "Learn what has happened this week in our little world"},
+        #           'fr' => { 'title'    => "Quoi de neuf cette semaine",
+        #                     'synopsis' => "Apprenez tout sur ce qui s'est passé cette semaine dans notre petit monde" }
+        #
+        # If you have user-generated content, for example, you can quickly
+        # create a form to edit the translatable content as follows:
+        # in the view:
+        #    <label>Title in English</label>
+        #    <%= text_field 'translations[en][title]', @article.translate('title','en') %>
+        #    <label>Title in French</label>
+        #    <%= text_field 'translations[fr][title]', @article.translate('title','fr') %>
+        #
+        # in the controller:
+        #
+        # def update
+        #   ...
+        #   @article.insert_translations(params['translations'])
+        #   @article.save
+        # end
+        #
+        # make sure your content is sanitized!
+        #
+        def insert_translations(locales = {})
+          Translation.transaction do
+            locales.each do |locale,terms|
+              terms.each do |name,value|
+                add_translation(name,locale,value)
+              end
+            end
+          end
+        end
+
+        protected
+          def find_translation(name,locale)
+            translations.detect { |t| (t.name == name.to_s) && (t.locale == locale.to_s) }
+          end
+      end
+
+    end
+  end
+end

data/lib/zlocalize/rails/decimal_attributes.rb

@@ -0,0 +1,76 @@
+# -*- encoding : utf-8 -*-
+
+#  == Localized Decimal Attributes ==
+#
+# Provides a way to ensure Float attributes on ActiveRecord are converted to the internal format
+# used by Ruby and Rails.
+#
+# Each locale defines a method to convert a String representing a float in a given locale into an actual Float
+#
+# Example with :fr (French) locale:
+#
+# 1) configuration (somewhere in an initializer):
+#
+#  ZLocalize.config.locales = {
+#  :fr => {
+#     :plural_select    => lambda { |n| n <= 0 ? 0 : (n > 1 ? 2 : 1) },
+#     .....
+#     :titleize         => lambda { |s| s.capitalize.to_s },
+#     :convert_float    => lambda { |s| s.to_s.gsub(' ','').gsub(',','.') }
+#  },
+#
+# 2) An Order model:
+#
+#   class Order < ActiveRecord::Base
+#      ....
+#      localize_decimal_attributes [:sub_total, :taxes]
+#      ....
+#   end
+#
+#
+# 3) This allows to assign attributes with their French representation of a decimal number:
+#
+#  > order.attributes = {:sub_total => "1 222,54", :taxes => "1,23" }
+#  > order.sub_total   # => 1222.54
+#  > order.taxes       # => 1.23
+#
+#
+module ZLocalize
+  module Translatable #:nodoc:
+
+    module LocalizedDecimalAttributes #:nodoc:
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def localize_decimal_attributes(column_names)
+
+          [column_names].flatten.each do |col_name|
+            class_eval "def #{col_name}=(value)
+                          write_localized_decimal_attribute('#{col_name}',value)
+                        end"
+          end
+
+          include ZLocalize::Translatable::LocalizedDecimalAttributes::InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+
+        def write_localized_decimal_attribute(col_name,value,locale = nil)
+          s = value.nil? ? nil : ZLocalize.convert_float(locale || ZLocalize.locale,value)
+          self.send(:write_attribute, col_name,s)
+        end
+
+      end # module InstanceMethods
+
+    end # module TranslatedColumns
+  end # module Translatable
+end # module ZLocalize
+
+
+
+

data/lib/zlocalize/rails/generators/initializer.rb

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/base'
+
+# module here is deliberately named Zlocalize (as opposed to ZLocalize), for consistency
+# between the namespacing of rake tasks and rails generators
+ module Zlocalize
+    module Generators
+      class InitializerGenerator < Rails::Generators::Base
+
+        desc "Create ZLocalize initializer for your Rails application"
+
+        source_root File.join(File.dirname(__FILE__),'templates')
+
+        def create_initializer_file
+          template "initializer_template.rb", "config/initializers/zlocalize.rb"
+        end
+
+      end
+   end
+end