lolita-i18n 0.1.4 → 0.1.18

data/config/locales/en.yml

@@ -1,4 +1,9 @@
 en:
+  en: English
+  lv: Latvian
+  ru: Russian
+  de: German
+  sv: Swedish
   lolita-i18n:
     title: "Static content translation"
     choose-other-language: "Choose other language"

data/config/locales/lv.yml

@@ -1,4 +1,9 @@
 lv:
+  en: Angļu
+  lv: Latviešu
+  ru: Krievu
+  de: Vācu
+  sv: Zviedru
   lolita-i18n:
     title: "Statiskā satura tulkošana"
     choose-other-language: "Izvēlies citu valodu"

data/config/routes.rb

@@ -1,11 +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
+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/backend.rb

@@ -1,77 +1,77 @@
-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 value.blank?
-            del key
-          else
-            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
-        end
-
-        def del key
-          Lolita::I18n.store.del key
-        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
+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 value.blank?
+            del key
+          else
+            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
+        end
+
+        def del key
+          Lolita.i18n.store.del key
+        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

@@ -37,7 +37,7 @@ module Lolita
       def untranslated_translations
         unless @untranslated_translations
           @untranslated_translations = []
-          Lolita::I18n.flatten_keys.each do |key|
+          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
@@ -50,25 +50,25 @@ module Lolita
       end
       
       def self.get_translation locale, key
-        Lolita::I18n.store.get :"g.#{locale}.#{key}"
+        Lolita.i18n.store.get :"#{locale}.g.#{key}"
       end
 
       def self.del_translation locale, key
-        Lolita::I18n.store.del :"g.#{locale}.#{key}"
+        Lolita.i18n.store.del :"#{locale}.g.#{key}"
       end
 
       private
 
       def unapproved_keys
-        @@unapproved_keys ||= Lolita::I18n.store.smembers(:"unapproved_keys_#{@locale}").map(&:to_sym)
+        @@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
+        Lolita.i18n.store.set :"#{@locale}.g.#{key}", value
       end
 
       def add_to_unapproved key
-        Lolita::I18n.store.sadd(:"unapproved_keys_#{@locale}",key)
+        Lolita.i18n.store.sadd(:"unapproved_keys_#{@locale}",key)
       end
 
     end

data/lib/lolita-i18n/rails.rb

@@ -1,6 +1,7 @@
-
-module LolitaI18n
-  class Engine < Rails::Engine
-
-  end
-end
+
+module LolitaI18n
+  class Engine < Rails::Engine
+    
+  end
+end
+

data/lib/lolita-i18n.rb

@@ -1,81 +1,116 @@
-$:<<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
-
+$:<<File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
+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}
+  #   # or
+  #   config.i18n.store = Redis.new()
+  module I18n
+    autoload :Backend, 'lolita-i18n/backend'
+    autoload :GoogleTranslate, 'lolita-i18n/google_translate'
+
+
+    class Configuration
+
+      attr_accessor :yaml_backend
+
+      def store
+        unless @store
+          warn "Lolita::I18n No store specified. See Lolita::I18n"
+          # warn "No Lolita::I18n store specfied."
+          @store = Redis.new
+          # initialize_chain
+        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
+        if !self.yaml_backend.send(:translations) || self.yaml_backend.send(:translations).empty?
+          self.yaml_backend.load_translations
+        end
+      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::Memoize)
+      end
+
+    end
+  end
+end
+
+module LolitaI18nConfiguration
+  def i18n
+    @i18n ||= Lolita::I18n::Configuration.new
+  end
+end
+
+Lolita.scope.extend(LolitaI18nConfiguration)
+
+Lolita.after_setup do
+  Lolita.i18n.yaml_backend = ::I18n.backend
+  Lolita.i18n.include_modules
+  begin
+    r = Redis.new
+    r.ping
+    ::I18n.backend = Lolita.i18n.initialize_chain
+  rescue Errno::ECONNREFUSED => e
+    warn "Warning: Lolita was unable to connect to Redis DB: #{e}"
+  end
+
+end
+
+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