lolita-i18n 0.3.2 → 0.4.0

data/config/locales/en.yml

@@ -4,9 +4,14 @@ en:
   ru: Russian
   de: German
   sv: Swedish
+  lt: Lithuanian
+  ee: Estonian
   lolita-i18n:
     title: "Static content translation"
     choose-other-language: "Choose other language"
-    show-untranslated: "Show only untranslated translations"
-    remove-old: "Remove old translations"
+    "Successful update": "Successful update"
+    show-untranslated: "Show only untranslated"
+  lolita:
+    navigation:
+      system: "System"
   

data/config/locales/lv.yml

@@ -4,8 +4,13 @@ lv:
   ru: Krievu
   de: Vācu
   sv: Zviedru
+  lt: Lietuviešu
+  ee: Igauņu
   lolita-i18n:
     title: "Statiskā satura tulkošana"
     choose-other-language: "Izvēlies citu valodu"
-    show-untranslated: "Rādīt tikai neiztulkotos tulkojumus"
-    remove-old: "Noņemt vecos tulkojumus"
+    "Successful update": "Atslēga saglabāta veiksmīgi"
+    show-untranslated: "Rādīt tikai neiztulkotos"
+  lolita:
+    navigation:
+      system: "Sistēma"

data/config/routes.rb

@@ -1,11 +1,3 @@
-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
+Rails.application.routes.draw do
+  lolita_for :i18n, :append_to => "system", :to => "Lolita::I18n", :only => [:update, :index], :controller => "lolita/i18n", :title => "I18n"
 end

data/lib/lolita-i18n.rb

@@ -3,71 +3,19 @@ require 'redis'
 require 'yajl'
 require 'lolita'
 
+
 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
-  #
+
   # In your lolita initializer add this line in setup block.
-  #   config.i18n.store = {:db => 1}
+  #   config.i18n.store = {redis_confguration_goes_here}
   #   # or
-  #   config.i18n.store = Redis.new()
+  #   config.i18n.store = Redis.new() # default store 
   module I18n
-    autoload :Backend, 'lolita-i18n/backend'
+    autoload :Request, 'lolita-i18n/request'
     autoload :Exceptions, 'lolita-i18n/exceptions'
-    
-    class Configuration
-
-      attr_accessor :yaml_backend
-
-      def store
-        unless @store
-          warn "Lolita::I18n No store specified. See Lolita::I18n"
-          @store = Redis.new
-        end
-        @store
-      end
-
-      def store=(possible_store)
-        @store = if possible_store.is_a?(Hash)
-                   Redis.new(possible_store)
-                 else
-                   possible_store
-                 end
-        @store
-      end
-
-      def backend
-        @backend ||= ::I18n::Backend::KeyValue.new(self.store)
-      end
-
-      # returns Array of flattened keys as "home.index.title"
-      def flatten_keys
-        load_translations
-        self.yaml_backend.flatten_translations(nil, self.yaml_backend.send(:translations)[::I18n.default_locale] || {}, ::I18n::Backend::Flatten::SEPARATOR_ESCAPE_CHAR, false).keys
-      end
-
-      def load_translations
-        # don't cache
-        self.yaml_backend.load_translations
-      end
-
-      def initialize_chain
-        ::I18n::Backend::Chain.new(self.backend, self.yaml_backend)
-      end
-
-      def include_modules
-        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Flatten)
-        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Pluralization)
-        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Metadata)
-        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::InterpolationCompiler)
-      end
-
-    end
+    autoload :Configuration, 'lolita-i18n/configuration'
   end
 end
 
@@ -77,7 +25,7 @@ module LolitaI18nConfiguration
   end
 end
 
-Lolita.scope.extend(LolitaI18nConfiguration)
+Lolita.configuration.extend(LolitaI18nConfiguration)
 
 Lolita.after_setup do
   Lolita.i18n.yaml_backend = ::I18n.backend
@@ -89,25 +37,11 @@ Lolita.after_setup do
   rescue Errno::ECONNREFUSED => e
     warn "Warning: Lolita was unable to connect to Redis DB: #{e}"
   end
-
+  true
 end
 
-require 'lolita-i18n/module'
+Lolita.i18n.load_rails!
 
-if Lolita.rails3?
-  require 'lolita-i18n/rails'
-end
+require 'lolita-i18n/module'
+require 'lolita-i18n/version'
 
-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")
-      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/configuration.rb

@@ -0,0 +1,56 @@
+module Lolita
+  module I18n
+    class Configuration
+
+      attr_accessor :yaml_backend
+
+      def load_rails!
+        if Lolita.rails3?
+          require 'lolita-i18n/rails'
+        end
+      end 
+      # Rerturn existing store or create new Redis connection without any arguments.
+      def store
+        unless @store
+          warn "Lolita::I18n No store specified. See Lolita::I18n"
+          @store = Redis.new
+        end
+        @store
+      end
+
+      # Set current store to new Redis connection with given Hash options or accept Redis connection itself.
+      def store=(possible_store)
+        @store = if possible_store.is_a?(Hash)
+           Redis.new(possible_store)
+         else
+           possible_store
+         end
+        @store
+      end
+
+      # Lazy create new KeyValue backend with current store.
+      def backend
+        @backend ||= ::I18n::Backend::KeyValue.new(self.store)
+      end
+
+      # Load translation from yaml.
+      def load_translations
+        self.yaml_backend.load_translations
+      end
+
+      # Create chain where new KeyValue backend is first and Yaml backend is second.
+      def initialize_chain
+        ::I18n::Backend::Chain.new(self.backend, self.yaml_backend)
+      end
+
+      # Add modules for SimpleBackend that is used for Yaml translations
+      def include_modules
+        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Flatten)
+        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Pluralization)
+        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Metadata)
+        ::I18n::Backend::Simple.send(:include, ::I18n::Backend::InterpolationCompiler)
+      end
+    end
+
+  end
+end

data/lib/lolita-i18n/exceptions.rb

@@ -6,6 +6,12 @@ module Lolita
           super "Translation should contain all these variables #{missing_arguments.join(', ')}"
         end
       end
+
+      class TranslationDoesNotMatch < ArgumentError
+        def initialize translation, original
+          super "Translation #{translation} does not match #{original}"
+        end
+      end
     end
   end
 end

data/lib/lolita-i18n/rails.rb

@@ -1,4 +1,3 @@
-
 module LolitaI18n
   class Engine < Rails::Engine
     

data/lib/lolita-i18n/request.rb

@@ -0,0 +1,219 @@
+require "json"
+require "unicode_utils/upcase"
+
+module Lolita
+  module I18n
+    class Request
+
+      class Validator
+
+        def validate(key,value)
+          if value.is_a?(Array)
+            validate_array(key,value)
+          elsif value.is_a?(Hash)
+            validate_hash(key,value)
+          else
+            validate_value(key,value)
+          end
+        end
+
+        private
+
+        def validate_array(key,values)
+          translation = Translation.new(key,values)
+          if translation.original.class != values.class || translation.original.size != values.size
+            raise Exceptions::TranslationDoesNotMatch.new(values,translation.original) 
+          end
+          values.each_with_index do |value,index|
+            validate_value(key,value,:index => index)
+          end
+        end
+
+        def validate_hash(key,hash)
+          translation = Translation.new(key,hash)
+          if translation.original.class != hash.class || (hash.keys.map(&:to_sym) - translation.original.keys).any?
+            raise Exceptions::TranslationDoesNotMatch.new(hash,translation.original) 
+          end
+          hash.each do |hash_key,value|
+            validate_value(key,value, :key => hash_key)
+          end
+        end
+
+        def validate_value(key,value, options = {})
+          value = value.to_s 
+          original_value = current_value_for_original(key,value,options)
+          unless interpolations(value) == interpolations(original_value)
+            raise Exceptions::MissingInterpolationArgument.new(interpolations(original_value))
+          end
+        end
+
+        def current_value_for_original(key,value,options = {})
+          translation = Translation.new(key,value)
+          original = translation.original
+          if original.is_a?(Hash)
+            original[options[:key].to_sym]
+          elsif original.is_a?(Array)
+            original[options[:index].to_i]
+          else
+            original
+          end
+        end
+
+        def interpolations(value)
+          value.to_s.scan(/(%{\w+})/).map{|m| m.first}.sort
+        end
+      end
+
+      class Translation
+
+        def initialize(key,translation)
+          @key,@translation = key, translation
+          @key_parts = @key.to_s.split(".")
+        end
+
+        def value
+          Yajl::Parser.parse(@translation.to_json)
+        end
+
+        def locale
+          (locale_from_key || ::I18n.default_locale).to_sym
+        end
+
+        def for_store
+          [locale, { key => value }, :escape => false]
+        end
+
+        def key
+          @key_parts[1..-1].join(".")
+        end
+
+        def original
+          @original ||= ::I18n.t(self.key, :locale => ::I18n.default_locale)
+        end
+
+        private
+
+        def locale_from_key
+          @key_parts.first
+        end
+
+      end
+
+      class Translations
+        def initialize(translations_hash)
+          @translations = translations_hash
+        end
+
+        def normalized(locale)
+          unless @normalized
+            @normalized = {}
+            flatten_keys(@translations,locale) do |key,value,original_value|
+              @normalized[key] = {:translation => value, :original_translation => original_value}
+            end
+          end
+          @normalized
+        end
+
+        def flatten_keys hash,locale, prev_key = nil, &block
+          hash.each_pair do |key,value|
+            current_key = [prev_key, key].compact.join(".").to_sym
+            if final_value?(value)
+              yield current_key, translation_value(current_key,value,locale), original_translation_value(current_key,value)
+            else
+              flatten_keys(value,locale,current_key, &block)
+            end
+          end
+        end
+
+        def final_value?(value)
+          !value.is_a?(Hash) || 
+          (value.is_a?(Hash) && value.keys.map(&:to_sym).include?(:other) && value.keys.size > 1 && !value.values.detect{|value| value.is_a?(Array) || value.is_a?(Hash)}) 
+        end
+
+        def translation_value key, value, locale
+          translation_value = ::I18n.t(key,:locale => locale, :default => default_value_from(value))
+          translation_value = {} if value.is_a?(Hash) && !translation_value.is_a?(Hash)
+          translation_value = [] if value.is_a?(Array) && !translation_value.is_a?(Array)
+          translation_value
+        end
+
+        private
+
+        def original_translation_value(key,value)
+          options = {:locale => ::I18n.default_locale}
+          if value.is_a?(Hash) # workaround for I18n::Chain, this allow to load Hash from translations.
+            options = options.merge(:count => nil)
+          end
+          ::I18n.t(key, options)
+        end
+
+        def default_value_from value
+          if value.is_a?(Array)
+            []
+          elsif value.is_a?(Hash)
+            {}
+          else
+            ""
+          end
+        end
+      end
+
+      attr_accessor :params
+
+      def initialize(params)
+        self.params = params
+      end
+
+      def translations locale
+        Lolita.i18n.load_translations
+        translations = Translations.new(Lolita.i18n.yaml_backend.send(:translations)[::I18n.default_locale]) 
+        translations.normalized(locale)
+      end
+
+      def sort_translations(unsorted_translations)
+        unsorted_translations.sort do |pair_a,pair_b|
+          value_a,value_b = pair_a[1][:original_translation],pair_b[1][:original_translation]
+
+          if both_values_complex?(value_a, value_b)
+            0
+          elsif complex_value?(value_a,value_b)
+            -1
+          elsif complex_value?(value_b,value_a)
+            1
+          else
+            UnicodeUtils.upcase(value_a.to_s) <=> UnicodeUtils.upcase(value_b.to_s)
+          end
+        end
+      end
+
+      def update_key
+        set(Base64.decode64(params[:id]),params[:translation])
+      end
+
+      def validator
+        @validator ||= Validator.new()
+      end
+
+      def del key
+        Lolita.i18n.store.del key
+      end
+
+      private 
+
+      def both_values_complex?(value_a, value_b)
+        (value_a.is_a?(Hash) || value_a.is_a?(Array)) && [Array,Hash].include?(value_b.class)
+      end
+
+      def complex_value?(value_a, value_b)
+        (value_a.is_a?(Hash) || value_a.is_a?(Array)) && ![Array,Hash].include?(value_b.class)
+      end
+      
+      def set(key,value)
+        translation = Translation.new(key,value)
+        validator.validate(key,translation.value)
+        !!Lolita.i18n.backend.store_translations(*translation.for_store)
+      end
+
+    end
+  end
+end