refinerycms-i18n 0.9.8

data/lib/refinery/i18n.rb

@@ -0,0 +1,146 @@
+# Encoding: UTF-8 <-- required, please leave this in.
+require 'refinery'
+
+module Refinery
+  module I18n
+    class Engine < Rails::Engine
+      config.before_initialize do
+        require File.expand_path('../i18n-filter', __FILE__)
+        require File.expand_path('../i18n-js', __FILE__)
+        require File.expand_path('../translate', __FILE__)
+
+        # TODO: Use new method available_locales once Rails is upgraded, see:
+        # http://github.com/svenfuchs/i18n/commit/411f8fe7c8f3f89e9b6b921fa62ed66cb92f3af4
+        def I18n.valid_locales
+          I18n.backend.send(:init_translations) unless I18n.backend.initialized?
+          backend.send(:translations).keys.reject { |locale| locale == :root }
+        end
+      end
+
+      config.to_prepare do
+        ::Refinery::I18n.setup! if defined?(RefinerySetting) and RefinerySetting.table_exists?
+      end
+    end
+
+    class << self
+
+      attr_accessor :enabled, :current_locale, :locales, :default_locale, :default_frontend_locale
+
+      def enabled?
+        # cache this lookup as it gets very expensive.
+        if defined?(@enabled) && !@enabled.nil?
+          @enabled
+        else
+          @enabled = RefinerySetting.find_or_set(:i18n_translation_enabled, true, {
+            :callback_proc_as_string => %q{::Refinery::I18n.setup!},
+            :scoping => 'refinery'
+          })
+        end
+      end
+
+      def current_locale
+        unless enabled?
+          ::Refinery::I18n.current_locale = ::Refinery::I18n.default_locale
+        else
+          @current_locale ||= RefinerySetting.find_or_set(:i18n_translation_current_locale,
+            ::Refinery::I18n.default_locale, {
+            :scoping => 'refinery',
+            :callback_proc_as_string => %q{::Refinery::I18n.setup!}
+          })
+        end
+      end
+
+      def current_locale=(locale)
+        @current_locale = locale.to_sym
+        RefinerySetting[:i18n_translation_current_locale] = {
+          :value => locale.to_sym,
+          :scoping => 'refinery',
+          :callback_proc_as_string => %q{::Refinery::I18n.setup!}
+        }
+        ::I18n.locale = locale.to_sym
+      end
+
+      def default_locale
+        @default_locale ||= RefinerySetting.find_or_set(:i18n_translation_default_locale,
+          :en, {
+          :callback_proc_as_string => %q{::Refinery::I18n.setup!},
+          :scoping => 'refinery'
+        })
+      end
+
+      def default_frontend_locale
+        @default_frontend_locale ||= RefinerySetting.find_or_set(:i18n_translation_default_frontend_locale,
+        :en, {
+          :scoping => 'refinery',
+          :callback_proc_as_string => %q{::Refinery::I18n.setup!}
+        })
+      end
+
+      def locales
+        @locales ||= RefinerySetting.find_or_set(:i18n_translation_locales, {
+            :en => 'English',
+            :fr => 'Français',
+            :nl => 'Nederlands',
+            :'pt-BR' => 'Português',
+            :da => 'Dansk',
+            :nb => 'Norsk Bokmål',
+            :sl => 'Slovenian',
+            :es => 'Español',
+            :it => 'Italiano',
+            :'zh-CN' => 'Simple Chinese',
+            :de => 'Deutsch',
+            :lv => 'Latviski',
+            :ru => 'Русский'
+          },
+          {
+            :scoping => 'refinery',
+            :callback_proc_as_string => %q{::Refinery::I18n.setup!}
+          }
+        )
+      end
+
+      def has_locale?(locale)
+        locales.has_key?(locale.try(:to_sym))
+      end
+
+      def setup!
+        # Re-initialize variables.
+        @enabled = nil
+        @locales = nil
+        @default_locale = nil
+        @default_frontend_locale = nil
+        @current_locale = nil
+
+        self.load_base_locales!
+        self.load_refinery_locales!
+        self.load_app_locales!
+        self.set_default_locale!
+      end
+
+      def load_base_locales!
+        load_locales Pathname.new(__FILE__).parent.join "..", "config", "locales", "*.yml"
+      end
+
+      def load_refinery_locales!
+        load_locales Refinery.root.join "vendor", "engines", "*", "config", "locales", "*.yml"
+      end
+
+      def load_app_locales!
+        load_locales Rails.root.join "config", "locales", "*.yml"
+      end
+
+      def set_default_locale!
+        ::I18n.default_locale = ::Refinery::I18n.default_locale
+      end
+
+      def load_locales(locale_files)
+        locale_files = locale_files.to_s if locale_files.is_a? Pathname
+        locale_files = Dir[locale_files] if locale_files.is_a? String
+        locale_files.each do |locale_file|
+          ::I18n.load_path.unshift locale_file
+        end
+      end
+
+    end
+  end
+end

data/lib/refinery/translate.rb

@@ -0,0 +1,13 @@
+module Translate
+  def self.locales_dir=(dir)
+    @locales_dir = dir.to_s
+  end
+
+  def self.locales_dir
+    @locales_dir || Rails.root.join("config", "locales").to_s
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "translate", "*.rb")].each do |file|
+  require file
+end

data/lib/tasks/i18n-js_tasks.rake

@@ -0,0 +1,16 @@
+namespace :i18n do
+  desc "Copy i18n.js and configuration file"
+  task :setup => :environment do
+    SimplesIdeias::I18n.setup!
+  end
+
+  desc "Export the messages files"
+  task :export => :environment do
+    SimplesIdeias::I18n.export!
+  end
+
+  desc "Update the JavaScript library"
+  task :update => :environment do
+    SimplesIdeias::I18n.update!
+  end
+end

data/lib/tasks/translate.rake

@@ -0,0 +1,200 @@
+require 'yaml'
+
+class Hash
+  def deep_merge(other)
+    # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+    merger = proc { |key, v1, v2| (Hash === v1 && Hash === v2) ? v1.merge(v2, &merger) : v2 }
+    merge(other, &merger)
+  end
+
+  def set(keys, value)
+    key = keys.shift
+    if keys.empty?
+      self[key] = value
+    else
+      self[key] ||= {}
+      self[key].set keys, value
+    end
+  end
+
+  if ENV['SORT']
+    # copy of ruby's to_yaml method, prepending sort.
+    # before each so we get an ordered yaml file
+    def to_yaml( opts = {} )
+      YAML::quick_emit( self, opts ) do |out|
+        out.map( taguri, to_yaml_style ) do |map|
+          sort.each do |k, v| #<- Adding sort.
+            map.add( k, v )
+          end
+        end
+      end
+    end
+  end
+end
+
+namespace :translate do
+
+  def find_missing_translations(locale)
+    keys        = []
+    result      = []
+    locale_hash = {}
+
+    puts "Searching for missing translations for the locale: #{locale}"
+    default_locale_files = Dir.glob(Rails.root.join('vendor', 'plugins', '*', 'config', 'locales', "#{locale}.yml").to_s)
+    default_locale_files += Dir.glob(Refinery.root.join('vendor', 'plugins', '*', 'config', 'locales', "#{locale}.yml").to_s)
+    default_locale_files += Dir.glob(Refinery.root.join('vendor', 'refinerycms', '*', 'config', 'locales', "#{locale}.yml").to_s)
+    default_locale_files += Dir.glob(File.join(Translate.locales_dir, "**","#{locale}.yml").to_s)
+
+    default_locale_files.uniq.each do |locale_file_name|
+      yaml = YAML::load(File.open(locale_file_name))
+      locale_hash = locale_hash.deep_merge(yaml[locale.to_s])
+    end
+
+    lookup_pattern = /\b(?:I18n\.t|I18n\.translate|t)(?:\s|\():?'([a-z0-9_]*.[a-z0-9_.]+)'\)?/
+    templates = Dir.glob(Rails.root.join('app', '**', '*.{erb,rb}').to_s)
+    templates += Dir.glob(Rails.root.join.join('vendor', 'plugins', '**', 'app', '**', '*.{erb,rb}').to_s)
+    templates += Dir.glob(Refinery.root.join('vendor', 'plugins', '**', 'app', '**', '*.{erb,rb}').to_s)
+    templates += Dir.glob(Refinery.root.join('vendor', 'refinerycms', '**', 'app', '**', '*.{erb,rb}').to_s)
+
+    templates.reject{|t| t =~ /\/lib\/generators\/.+?\/templates\//}.uniq.each do |file_name|
+      File.open(file_name, "r+").each do |line|
+        line.scan(lookup_pattern) do |key_string|
+          # qualify the namespace if beginning with . like t('.log_out')
+          if key_string.first =~ /^\./
+            namespace = file_name.split("app/").last.split(/^.+?\//).last.split('/')
+            namespace = namespace | [namespace.pop.gsub(/^\_/, '').split('.').first]
+            key_string = ["#{namespace.join('.')}#{key_string.first}"]
+          end
+
+          unless key_exist?(key_string.first.split("."), locale_hash)
+            result << "#{key_string} in \t  #{file_name} \t is not in any #{locale} locale file"
+          end
+        end
+      end unless file_name =~ /translate\/spec/
+    end
+    puts result.empty? ? "No missing translations for locale: #{locale}" : "#{result.join("\n\n")}\n\nNumber of missing translations for #{locale}: #{result.length}"
+  end
+
+  desc "Show I18n keys that are missing in the specified locale YAML file. Defaults to I18n.default_locale, unless LOCALE env is specified"
+  task :lost_in_translation => :environment do
+    locale      = ENV['LOCALE'] || I18n.default_locale
+    find_missing_translations(locale)
+  end
+
+  desc "Show I18n keys that are missing in all locale YAML files."
+  task :lost_in_translation_all => :environment do
+    ::Refinery::I18n.locales.keys.each do |locale|
+      find_missing_translations(locale)
+      puts "--"
+    end
+  end
+
+  def key_exist?(key_arr, locale_hash)
+    key = key_arr.slice!(0)
+    if key
+      key_exist?(key_arr, locale_hash[key]) if locale_hash && locale_hash.include?(key)
+    elsif locale_hash
+      true
+    else
+      false
+    end
+  end
+
+  desc "Merge I18n keys from log/translations.yml into config/locales/*.yml (for use with the Rails I18n TextMate bundle)"
+  task :merge_keys => :environment do
+    I18n.backend.send(:init_translations)
+    new_translations = YAML::load(IO.read(File.join(Rails.root, "log", "translations.yml")))
+    raise("Can only merge in translations in single locale") if new_translations.keys.size > 1
+    locale = new_translations.keys.first
+
+    overwrites = false
+    Translate::Keys.new.send(:extract_i18n_keys, new_translations[locale]).each do |key|
+      new_text = key.split(".").inject(new_translations[locale]) { |hash, sub_key| hash[sub_key] }
+      existing_text = I18n.backend.send(:lookup, locale.to_sym, key)
+      if existing_text && new_text != existing_text
+        puts "ERROR: key #{key} already exists with text '#{existing_text.inspect}' and would be overwritten by new text '#{new_text}'. " +
+          "Set environment variable OVERWRITE=1 if you really want to do this."
+        overwrites = true
+      end
+    end
+
+    if !overwrites || ENV['OVERWRITE']
+      I18n.backend.store_translations(locale, new_translations[locale])
+      Translate::Storage.new(locale).write_to_file
+    end
+  end
+
+  desc "Apply Google translate to auto translate all texts in locale ENV['FROM'] to locale ENV['TO']"
+  task :google => :environment do
+    raise "Please specify FROM and TO locales as environment variables" if ENV['FROM'].blank? || ENV['TO'].blank?
+
+    # Depends on httparty gem
+    # http://www.robbyonrails.com/articles/2009/03/16/httparty-goes-foreign
+    class GoogleApi
+      include HTTParty
+      base_uri 'ajax.googleapis.com'
+      def self.translate(string, to, from)
+        tries = 0
+        begin
+          get("/ajax/services/language/translate",
+            :query => {:langpair => "#{from}|#{to}", :q => string, :v => 1.0},
+            :format => :json)
+        rescue
+          tries += 1
+          puts("SLEEPING - retrying in 5...")
+          sleep(5)
+          retry if tries < 10
+        end
+      end
+    end
+
+    I18n.backend.send(:init_translations)
+
+    start_at = Time.now
+    translations = {}
+    Translate::Keys.new.i18n_keys(ENV['FROM']).each do |key|
+      from_text = I18n.backend.send(:lookup, ENV['FROM'], key).to_s
+      to_text = I18n.backend.send(:lookup, ENV['TO'], key)
+      if !from_text.blank? && to_text.blank?
+        print "#{key}: '#{from_text[0, 40]}' => "
+        if !translations[from_text]
+          response = GoogleApi.translate(from_text, ENV['TO'], ENV['FROM'])
+          translations[from_text] = response["responseData"] && response["responseData"]["translatedText"]
+        end
+        if !(translation = translations[from_text]).blank?
+          translation.gsub!(/\(\(([a-z_.]+)\)\)/i, '{{\1}}')
+          # Google translate sometimes replaces %{foobar} with (()) foobar. We skip these
+          if translation !~ /\(\(\)\)/
+            puts "'#{translation[0, 40]}'"
+            I18n.backend.store_translations(ENV['TO'].to_sym, Translate::Keys.to_deep_hash({key => translation}))
+          else
+            puts "SKIPPING since interpolations were messed up: '#{translation[0,40]}'"
+          end
+        else
+          puts "NO TRANSLATION - #{response.inspect}"
+        end
+      end
+    end
+
+    puts "\nTime elapsed: #{(((Time.now - start_at) / 60) * 10).to_i / 10.to_f} minutes"
+    Translate::Storage.new(ENV['TO'].to_sym).write_to_file
+  end
+
+  desc "List keys that have changed I18n texts between YAML file ENV['FROM_FILE'] and YAML file ENV['TO_FILE']. Set ENV['VERBOSE'] to see changes"
+  task :changed => :environment do
+    from_hash = Translate::Keys.to_shallow_hash(Translate::File.new(ENV['FROM_FILE']).read)
+    to_hash = Translate::Keys.to_shallow_hash(Translate::File.new(ENV['TO_FILE']).read)
+    from_hash.each do |key, from_value|
+      if (to_value = to_hash[key]) && to_value != from_value
+        key_without_locale = key[/^[^.]+\.(.+)$/, 1]
+        if ENV['VERBOSE']
+          puts "KEY: #{key_without_locale}"
+          puts "FROM VALUE: '#{from_value}'"
+          puts "TO VALUE: '#{to_value}'"
+        else
+          puts key_without_locale
+        end
+      end
+    end
+  end
+end

data/lib/translate/file.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+class Translate::File
+  attr_accessor :path
+
+  def initialize(path)
+    self.path = path
+  end
+
+  def write(keys)
+    FileUtils.mkdir_p File.dirname(path)
+    File.open(path, "w") do |file|
+      file.puts keys_to_yaml(Translate::File.deep_stringify_keys(keys))
+    end
+  end
+
+  def read
+    File.exists?(path) ? YAML::load(IO.read(path)) : {}
+  end
+
+  # Stringifying keys for prettier YAML
+  def self.deep_stringify_keys(hash)
+    hash.inject({}) { |result, (key, value)|
+      value = deep_stringify_keys(value) if value.is_a? Hash
+      result[(key.to_s rescue key) || key] = value
+      result
+    }
+  end
+
+  private
+  def keys_to_yaml(keys)
+    # Using ya2yaml, if available, for UTF8 support
+    keys.respond_to?(:ya2yaml) ? keys.ya2yaml(:escape_as_utf8 => true) : keys.to_yaml
+  end
+end

data/lib/translate/keys.rb

@@ -0,0 +1,123 @@
+require 'pathname'
+
+class Translate::Keys
+  # Allows keys extracted from lookups in files to be cached
+  def self.files
+    @@files ||= Translate::Keys.new.files
+  end
+
+  # Allows flushing of the files cache
+  def self.files=(files)
+    @@files = files
+  end
+
+  def files
+    @files ||= extract_files
+  end
+  alias_method :to_hash, :files
+
+  def keys
+    files.keys
+  end
+  alias_method :to_a, :keys
+
+  def i18n_keys(locale)
+    I18n.backend.send(:init_translations) unless I18n.backend.initialized?
+    extract_i18n_keys(I18n.backend.send(:translations)[locale.to_sym]).sort
+  end
+
+  # Convert something like:
+  #
+  # {
+  #  :pressrelease => {
+  #    :label => {
+  #      :one => "Pressmeddelande"
+  #    }
+  #   }
+  # }
+  #
+  # to:
+  #
+  #  {'pressrelease.label.one' => "Pressmeddelande"}
+  #
+  def self.to_shallow_hash(hash)
+    hash.inject({}) do |shallow_hash, (key, value)|
+      if value.is_a?(Hash)
+        to_shallow_hash(value).each do |sub_key, sub_value|
+          shallow_hash[[key, sub_key].join(".")] = sub_value
+        end
+      else
+        shallow_hash[key.to_s] = value
+      end
+      shallow_hash
+    end
+  end
+
+  # Convert something like:
+  #
+  #  {'pressrelease.label.one' => "Pressmeddelande"}
+  #
+  # to:
+  #
+  # {
+  #  :pressrelease => {
+  #    :label => {
+  #      :one => "Pressmeddelande"
+  #    }
+  #   }
+  # }
+  def self.to_deep_hash(hash)
+    hash.inject({}) do |deep_hash, (key, value)|
+      keys = key.to_s.split('.').reverse
+      leaf_key = keys.shift
+      key_hash = keys.inject({leaf_key.to_sym => value}) { |hash, key| {key.to_sym => hash} }
+      deep_merge!(deep_hash, key_hash)
+      deep_hash
+    end
+  end
+
+  # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+  def self.deep_merge!(hash1, hash2)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    hash1.merge!(hash2, &merger)
+  end
+
+  private
+  def extract_i18n_keys(hash, parent_keys = [])
+    hash.inject([]) do |keys, (key, value)|
+      full_key = parent_keys + [key]
+      if value.is_a?(Hash)
+        # Nested hash
+        keys += extract_i18n_keys(value, full_key)
+      elsif value.present?
+        # String leaf node
+        keys << full_key.join(".")
+      end
+      keys
+    end
+  end
+
+  def extract_files
+    files_to_scan.inject(HashWithIndifferentAccess.new) do |files, file|
+      IO.read(file).scan(i18n_lookup_pattern).flatten.map(&:to_sym).each do |key|
+        files[key] ||= []
+        path = Pathname.new(File.expand_path(file)).relative_path_from(Pathname.new(Rails.root)).to_s
+        files[key] << path unless files[key].include?(path)
+      end
+      files
+    end
+  end
+
+  def i18n_lookup_pattern
+    /\b(?:I18n\.t|I18n\.translate|t)(?:\s|\():?'([a-z0-9_]+.[a-z0-9_.]+)'\)?/
+  end
+
+  def files_to_scan
+    Dir.glob(File.join(files_root_dir, "{app,config,lib}", "**","*.{rb,erb,rhtml}")) +
+      Dir.glob(File.join(files_root_dir, "public", "javascripts", "**","*.js"))
+  end
+
+  def files_root_dir
+    Rails.root
+  end
+end