lolita-i18n 0.1.3

data/app/assets/stylesheets/lolita/i18n/application.scss

@@ -0,0 +1,102 @@
+/* 
+*= require_self
+*/
+.clear { clear: both; height: 0; }
+
+div.i18n-box div.list {
+  background-color: white;
+  overflow: none;
+}
+.i18n-language-switch{
+  overflow: hidden;
+  list-style: none;
+}
+.i18n-language-switch li{
+  float:left;
+  margin-left:10px;
+  cursor:pointer;
+}
+.i18n-language-switch li a {
+  color: #C3C3C3;
+}
+.i18n-language-switch li.active a{
+  color: #444;
+  font-weight: bold;
+  cursor:default;
+}
+span.hint {
+  font-size: 11px;
+  color: #666;
+  display: block;
+}
+#i18n_edit textarea {
+  height: 100px;
+}
+div.list div.actions {
+  padding: 10px;
+  .filters {
+    float:  left;
+    position: relative;
+    line-height: 35px;
+
+    input {
+      position: absolute;
+      top: 11px;
+    }
+    label {
+      padding-top: 10px;
+      padding-left: 20px;
+    }
+  }
+  button.translate {
+    position: relative;
+    padding-left: 30px;
+    height: 34px;
+    background-image: url(image-path('lolita/i18n/google_translate_icon.png'));
+    background-position: 5px 5px;
+    background-repeat: no-repeat;
+    box-shadow: inset 0 0 1px 1px #eaeaea;
+    text-shadow: 0 1px 0 white;
+    border: 1px solid #bbb;
+    float: right;
+  }
+  button.loading {
+    background-image: none;
+    color: #999;
+  }
+}
+div.list table {
+  table-layout: fixed;
+  clear: both;
+  td span.unapproved {
+    color: red;
+  }
+  tr td:first-child p {
+    min-height: 40px;
+  }
+  td textarea {
+    border: 1px solid #cdcdcd;
+    -moz-border-radius: 3px;
+    -webkit-border-radius: 3px;
+    border-radius: 3px;
+    -moz-box-sizing: border-box;
+    -webkit-box-sizing: border-box;
+    box-sizing: border-box;
+    padding: 3px 10px;
+    width: 100%;
+    min-height: 50px;
+    color: #494949;    
+  }
+  td, th {
+    white-space: normal;
+    padding: 5px 20px;
+    line-height: 20px;
+  }
+  thead th {
+    line-height: 30px;
+    select {
+      float: right;
+      margin-top: 5px;
+    }
+  }
+}

data/app/controllers/lolita/i18n_controller.rb

@@ -0,0 +1,39 @@
+class Lolita::I18nController < ApplicationController
+  include Lolita::Controllers::UserHelpers
+  before_filter :authenticate_lolita_user!, :set_current_locale
+
+  layout "lolita/application"
+
+  def index
+    @translation_keys=Lolita::I18n.flatten_keys
+  end
+
+  def update
+    respond_to do |format|
+      format.json do
+        render :nothing => true, :json => {error: !Lolita::I18n::Backend.set(params[:id],params[:translation])}
+      end
+    end
+  end
+
+  def translate_untranslated
+    respond_to do |format|
+      format.json do
+        google_translate = Lolita::I18n::GoogleTranslate.new @active_locale
+        google_translate.run
+        render :nothing => true, :status => 200, :json => {errors: google_translate.errors, :translated => google_translate.untranslated}
+      end
+    end    
+  end
+
+  private
+
+  def next_locale
+    ::I18n::available_locales.collect{|locale| locale if locale != ::I18n.default_locale}.compact.first
+  end
+
+  def set_current_locale
+    @active_locale = (params[:active_locale] || next_locale).to_sym
+  end
+
+end

data/app/helpers/lolita/i18n_helper.rb

@@ -0,0 +1,25 @@
+module Lolita
+  module I18nHelper
+    def locale_options
+      ::I18n::available_locales.collect{|locale| 
+        [::I18n.t(locale, :default => locale), locale] unless [::I18n.default_locale,@active_locale].include?(locale)
+      }.compact.insert(0,[::I18n.t("lolita-i18n.choose-other-language", :default => "Choose other language"),""])
+    end
+
+    def show_translation key
+      value = ::I18n.t(key, :locale => @active_locale, :default => '')
+      unless value.blank?
+        value
+      else
+        value = Lolita::I18n::GoogleTranslate.get_translation(@active_locale,key)
+        unless value.blank?
+          content_tag(:span, value, :class => "unapproved")
+        end
+      end
+    end
+
+    def is_untranslated key
+      Lolita::I18n::GoogleTranslate.get_translation(@active_locale,key)
+    end
+  end
+end

data/app/views/lolita/i18n/index.html.haml

@@ -0,0 +1,34 @@
+- content_for :style do
+  = stylesheet_link_tag "lolita/i18n/application", :media => "screen,projection"
+- content_for :script do
+  = javascript_include_tag "lolita/i18n/application"
+.box.i18n-bo
+  .boxtitle
+    %h1.black= ::I18n.t('lolita-i18n.title', :default => "Static content translation")
+    .arrow
+  .list
+    %div.actions
+      .filters
+        = check_box_tag "show_untranslated", nil, params[:show_untranslated]
+        = label_tag "show_untranslated", "Show translations that need approval"
+
+      %button.translate{:'data-url' => translate_untranslated_lolita_i18n_index_path, :'data-locale' => @active_locale} Translate empty translations with Google
+      .clear
+    %table
+      %thead
+        %tr
+          %th{:style => "width:450px"}
+            = label_tag :active_locale, I18n.t(@active_locale, :default => @active_locale)
+            - if locale_options.size > 1
+              = select_tag :active_locale, options_for_select(locale_options), :id => "active_locale"
+          %th{:style => "width:90%"}= ::I18n.t(::I18n.default_locale)
+      %tbody
+        - @translation_keys.each do |key|
+          - if !params[:show_untranslated] or is_untranslated(key)
+            %tr
+              %td{:style => "width:450px", :'data-key' => key, :'data-locale' => @active_locale}
+                %p= show_translation key
+              %td{:style => "width:90%", :'data-key' => key, :'data-locale' => ::I18n.default_locale}
+                %p= ::I18n.t(key, :locale => ::I18n.default_locale, :default => "")
+                %span.hint
+                  = key

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  lolita-i18n:
+    title: "Static content translation"
+    choose-other-language: "Choose other language"
+  

data/config/locales/lv.yml

@@ -0,0 +1,4 @@
+lv:
+  lolita-i18n:
+    title: "Statiskā satura tulkošana"
+    choose-other-language: "Izvēlies citu valodu"

data/config/routes.rb

@@ -0,0 +1,11 @@
+Rails.application.routes.draw do
+
+  namespace "lolita" do
+    resources :i18n, :only=>[:update],:constraints=>{:id=>/.*/} do
+      collection do
+        put 'translate_untranslated'
+        get 'index'
+      end
+    end
+  end
+end

data/lib/lolita-i18n.rb

@@ -0,0 +1,81 @@
+$:<<File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
+require 'redis'
+require 'yajl'
+
+module Lolita
+  # === Uses Redis DB as backend
+  # All translations ar stored with full key like "en.home.index.title" -> Hello world.
+  # Translations whitch are translated with Google translate have prefix "g" -> "g.en.home.index.title".
+  # These translations should be accepted/edited and approved then they will become as normal for general use.
+  #
+  # === Other stored data
+  # => :unapproved_keys_<locale> - a SET containing all unapproved keys from GoogleTranslate
+  #
+  module I18n
+    autoload :Backend, 'lolita-i18n/backend'
+    autoload :GoogleTranslate, 'lolita-i18n/google_translate'
+
+    # Loads given key/value engine as backend
+    # place this method in rails initializer lolita.rb
+    # === Example
+    #    
+    #    I18n.backend = Lolita::I18n.load Redis.new
+    #
+    def self.load store
+      @@store=store
+      @@backend=::I18n::Backend::KeyValue.new(@@store)
+      @@yaml_backend=::I18n.backend
+      ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Flatten)
+      ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Memoize)
+      ::I18n::Backend::Chain.new(Lolita::I18n.backend, @@yaml_backend)
+    end
+
+    def self.store
+      @@store
+    end
+
+    def self.backend
+      @@backend
+    end
+
+    def self.yaml_backend
+      @@yaml_backend
+    end
+
+    # returns Array of flattened keys as "home.index.title"
+    def self.flatten_keys
+      @@yaml_backend.flatten_translations(nil, @@yaml_backend.send(:translations)[::I18n.default_locale] || {}, ::I18n::Backend::Flatten::SEPARATOR_ESCAPE_CHAR, false).keys
+    end
+
+  end
+end
+
+module LolitaI18nConfiguration
+  def i18n
+    Lolita::I18n
+  end
+end
+
+Lolita.scope.extend(LolitaI18nConfiguration)
+
+require 'lolita-i18n/module'
+if Lolita.rails3?
+  require 'lolita-i18n/rails'
+end
+
+
+Lolita.after_routes_loaded do
+  if tree=Lolita::Navigation::Tree[:"left_side_navigation"]
+    unless tree.branches.detect{|b| b.title=="System"}
+      branch=tree.append(nil,:title=>"System")
+      #mapping=Lolita::Mapping.new(:i18n_index,:singular=>:i18n,:class_name=>Object,:controller=>"lolita/i18n")
+      branch.append(Object,:title=>"I18n",:url=>Proc.new{|view,branch|
+        view.send(:lolita_i18n_index_path)
+      }, :active=>Proc.new{|view,parent_branch,branch|
+        params=view.send(:params)
+        params[:controller].to_s.match(/lolita\/i18n/)
+      })
+    end
+  end
+end
+

data/lib/lolita-i18n/backend.rb

@@ -0,0 +1,69 @@
+module Lolita
+  module I18n
+    # Allow to operate with I18n keys and values.
+    class Backend
+
+      class << self
+        # Get translation and decode it. Set translate from and to translations.
+        # Return Hash with
+        # * <tt>:key</tt> - translation key
+        # * <tt>:value</tt> - translation
+        # * <tt>:translate_to</tt> - translation locale, like <i>en</i>
+        # * <tt>:translate_from</tt> - translation key for default language
+        def get(key)
+          result={:key=>key}
+          result[:value]=decoded_value(key)
+          result[:original_value]=decoded_value(translate_from(key))
+          result[:translate_to]=translate_to(key)
+          result[:translate_from]=translate_from(key)
+          result
+        end
+
+        # Store translation, decode and store.
+        # Accept:
+        # * <tt>key</tt> - translation key
+        # * <tt>translation</tt> - String with translation
+        def set(key,translation)
+          locale=translate_to(key)
+          translation_key=translation_key(key)
+          value=Yajl::Parser.parse(translation.to_json)
+          if Lolita::I18n.backend.store_translations(locale,{translation_key=>value},:escape=>false)
+            Lolita::I18n::GoogleTranslate.del_translation locale, translation_key
+            true
+          else
+            false
+          end
+        end
+
+        def locale(key)
+          translate_to(key) || ::I18n.default_locale
+        end
+
+        def translation_key(key)
+          (key.to_s.split('.')[1..-1]).join(".")
+        end
+        
+        private
+
+        def keys
+          @keys||=Lolita::I18n.flattened_translations.keys.sort
+        end
+
+        def decoded_value(key)
+          value=Lolita::I18n.backend.store[key]
+          value ? (Yajl::Parser.parse(value) rescue "") : ::I18n.t(key.split('.')[1..-1].join('.'), :default => "", :locale => translate_to(key))
+        end 
+
+        def translate_to(key)
+          key.to_s.split(".").first
+        end
+
+        def translate_from(key,locale=nil)
+          (key.to_s.split('.')[1..-1]).insert(0,locale || ::I18n.default_locale).join(".")
+        end
+
+      end
+
+    end
+  end
+end

data/lib/lolita-i18n/google_translate.rb

@@ -0,0 +1,76 @@
+require 'easy_translate'
+
+module Lolita
+  module I18n
+    # Translates untranslated strings using google translate API
+    class GoogleTranslate
+      attr_reader :untranslated, :errors
+      def initialize locale
+        @locale = locale
+        @untranslated = 0
+        @errors = []
+      end
+
+      def run
+        unless untranslated_translations.empty?
+          @untranslated = untranslated_translations.count
+          untranslated_translations.each_slice(10).to_a.each do |batch|
+            begin
+              EasyTranslate.translate(batch.map(&:last), :to => @locale).each_with_index do |result,index|
+                unless result.blank?
+                  key = batch[index].first
+                  add_translation key, result
+                  add_to_unapproved key
+                end
+              end
+            rescue EasyTranslate::EasyTranslateException => e
+              @errors << e.to_s
+            rescue Exception => e
+              puts "#{e.to_s}\n\n#{$@.join("\n")}"
+              @errors << e.to_s
+              break
+            end
+          end
+        end
+      end
+
+      def untranslated_translations
+        unless @untranslated_translations
+          @untranslated_translations = []
+          Lolita::I18n.flatten_keys.each do |key|
+            unless unapproved_keys.include?(key)
+              if !::I18n.t(key, :locale => ::I18n.default_locale, :default => '').blank? && ::I18n.t(key, :locale => @locale, :default => '').blank? && Lolita::I18n::GoogleTranslate.get_translation(@locale,key).blank?
+                value = ::I18n.t(key, :locale => ::I18n.default_locale, :default => '').to_s
+                @untranslated_translations << [key,value] unless value.blank?
+              end
+            end
+          end
+        end
+        @untranslated_translations
+      end
+      
+      def self.get_translation locale, key
+        Lolita::I18n.store.get :"g.#{locale}.#{key}"
+      end
+
+      def self.del_translation locale, key
+        Lolita::I18n.store.del :"g.#{locale}.#{key}"
+      end
+
+      private
+
+      def unapproved_keys
+        @@unapproved_keys ||= Lolita::I18n.store.smembers(:"unapproved_keys_#{@locale}").map(&:to_sym)
+      end
+
+      def add_translation key, value
+        Lolita::I18n.store.set :"g.#{@locale}.#{key}", value
+      end
+
+      def add_to_unapproved key
+        Lolita::I18n.store.sadd(:"unapproved_keys_#{@locale}",key)
+      end
+
+    end
+  end
+end