lit 0.2.6 → 0.3.0

data/db/migrate/20180101010104_lit_add_is_completed_and_is_starred_to_localization_keys.rb

@@ -0,0 +1,17 @@
+class LitAddIsCompletedAndIsStarredToLocalizationKeys < Rails::VERSION::MAJOR >= 5   ?
+                                                        ActiveRecord::Migration[4.2] :
+                                                        ActiveRecord::Migration
+  def up
+    unless column_exists?(:lit_localization_keys, :is_completed)
+      add_column :lit_localization_keys, :is_completed, :boolean, default: false
+    end
+    unless column_exists?(:lit_localization_keys, :is_starred)
+      add_column :lit_localization_keys, :is_starred, :boolean, default: false
+    end
+  end
+
+  def down
+    remove_column :lit_localization_keys, :is_completed
+    remove_column :lit_localization_keys, :is_starred
+  end
+end

data/db/migrate/20180101010105_lit_add_is_hidden_to_locales.rb

@@ -0,0 +1,12 @@
+class LitAddIsHiddenToLocales < Rails::VERSION::MAJOR >= 5   ?
+                                ActiveRecord::Migration[4.2] :
+                                ActiveRecord::Migration
+  def up
+    return if column_exists?(:lit_locales, :is_hidden)
+    add_column :lit_locales, :is_hidden, :boolean, default: false
+  end
+
+  def down
+    remove_column :lit_locales, :is_hidden
+  end
+end

data/db/migrate/20180101010106_lit_create_lit_localization_versions.rb

@@ -0,0 +1,20 @@
+class LitCreateLitLocalizationVersions < Rails::VERSION::MAJOR >= 5   ?
+                                         ActiveRecord::Migration[4.2] :
+                                         ActiveRecord::Migration
+  def up
+    return if table_exists?(:lit_localization_versions)
+    create_table :lit_localization_versions do |t|
+      t.text :translated_value
+      t.integer :localization_id
+
+      t.timestamps
+    end
+
+    add_index :lit_localization_versions, :localization_id
+  end
+
+  def down
+    remove_index :lit_localization_versions, :localization_id
+    drop_table :lit_localization_versions
+  end
+end

data/db/migrate/20180101010107_lit_create_lit_sources.rb

@@ -0,0 +1,19 @@
+class LitCreateLitSources < Rails::VERSION::MAJOR >= 5   ?
+                            ActiveRecord::Migration[4.2] :
+                            ActiveRecord::Migration
+  def up
+    return if table_exists?(:lit_sources)
+    create_table :lit_sources do |t|
+      t.string :identifier
+      t.string :url
+      t.string :api_key
+      t.datetime :last_updated_at
+
+      t.timestamps
+    end
+  end
+
+  def down
+    drop_table :lit_sources
+  end
+end

data/db/migrate/20180101010108_lit_create_lit_incomming_localizations.rb

@@ -0,0 +1,34 @@
+class LitCreateLitIncommingLocalizations < Rails::VERSION::MAJOR >= 5  ?
+                                          ActiveRecord::Migration[4.2] :
+                                          ActiveRecord::Migration
+  def up
+    return if table_exists?(:lit_incomming_localizations)
+    create_table :lit_incomming_localizations do |t|
+      t.text :translated_value
+      t.integer :locale_id
+      t.integer :localization_key_id
+      t.integer :localization_id
+      t.string :locale_str
+      t.string :localization_key_str
+      t.integer :source_id
+      t.integer :incomming_id
+
+      t.timestamps
+    end
+
+    add_index :lit_incomming_localizations, :locale_id
+    add_index :lit_incomming_localizations, :localization_key_id
+    add_index :lit_incomming_localizations, :localization_id
+    add_index :lit_incomming_localizations, :source_id
+    add_index :lit_incomming_localizations, :incomming_id
+  end
+
+  def down
+    remove_index :lit_incomming_localizations, :locale_id
+    remove_index :lit_incomming_localizations, :localization_key_id
+    remove_index :lit_incomming_localizations, :localization_id
+    remove_index :lit_incomming_localizations, :source_id
+    remove_index :lit_incomming_localizations, :incomming_id
+    drop_table :lit_incomming_localizations
+  end
+end

data/db/migrate/20180101010109_lit_add_sync_complete_to_lit_sources.rb

@@ -0,0 +1,12 @@
+class LitAddSyncCompleteToLitSources < Rails::VERSION::MAJOR >= 5   ?
+                                       ActiveRecord::Migration[4.2] :
+                                       ActiveRecord::Migration
+  def up
+    return if column_exists?(:lit_sources, :sync_complete)
+    add_column :lit_sources, :sync_complete, :boolean
+  end
+
+  def down
+    remove_column :lit_sources, :sync_complete
+  end
+end

data/lib/generators/lit/install/templates/initializer.rb

@@ -3,13 +3,18 @@
 # `nil` will let everyone in.
 Lit.authentication_function = <%= @authentication_function || 'nil' %>
 
+# Which authentication verification function to use (ie. :user_signed_in)?
+# This is used together with frontend translation module to determine, if
+# helper button should be applied and translations wrapped in custom span
+Lit.authentication_verification = <%= @authentication_verification || 'nil' %>
+
 # Either 'redis' or 'hash'. Hash is the fastest, but will fail in multiprocess
 # environment
-Lit.key_value_engine = "<%= @key_value_engine %>"
+Lit.key_value_engine = '<%= @key_value_engine %>'
 
 # Pass extra options to key_value_neinge, ie. prefix for redis (only one
 # supported at the moment)
-# Lit.storage_options = { :prefix=>"my_project" }
+# Lit.storage_options = { prefix: "my_project" }
 
 # If true all translations are returned as html_safe strings
 Lit.all_translations_are_html_safe = false
@@ -20,21 +25,27 @@ Lit.all_translations_are_html_safe = false
 # <span title="translation missing string"></span>
 Lit.humanize_key = false
 
-# Decide if missing translations will fallback to first found translated value
-# (same key, different language)
-Lit.fallback = false
+# If set to `true` will always parse yaml files upon startup and update cache
+# values with ones with yaml - but only, if those keys haven't been changed via
+# web ui before
+Lit.ignore_yaml_on_startup = true
 
 # API enabled? API allows third party browsing your translations, as well as
 # synchronizing them between environments
 Lit.api_enabled = false
 
 # API key is required to authorize third party, if API is enabled
-Lit.api_key = "<%= @api_key %>"
+Lit.api_key = '<%= @api_key %>'
 
 # If true, last_updated_at column of synchronizaton source will be set to now
 # upon record creation
 Lit.set_last_updated_at_upon_creation = true
 
+# Store request info - this will store in cache additional info about request
+# path that triggered translation key to be displayed / accessed
+# For more infor please check README.md
+Lit.store_request_info = false
+
 # Initialize lit
 Lit.init
 

data/lib/generators/lit/install_generator.rb

@@ -10,13 +10,6 @@ module Lit
 
       desc 'Automates Lit installation'
 
-      def copy_migrations
-        puts 'Copying Lit migrations...'
-        Dir.chdir(::Rails.root) do
-          `rake lit:install:migrations`
-        end
-      end
-
       def set_authentication_function
         @authentication_function = options['authentication-function'].presence ||
               ask("What's the authentication function, ie. :authenticate_user! :").presence ||

data/lib/lit.rb

@@ -3,29 +3,32 @@ require 'lit/loader'
 
 module Lit
   mattr_accessor :authentication_function
+  mattr_accessor :authentication_verification
   mattr_accessor :key_value_engine
   mattr_accessor :storage_options
   mattr_accessor :humanize_key
   mattr_accessor :ignored_keys
-  mattr_accessor :fallback
+  mattr_accessor :ignore_yaml_on_startup
   mattr_accessor :api_enabled
   mattr_accessor :api_key
   mattr_accessor :all_translations_are_html_safe
   mattr_accessor :set_last_updated_at_upon_creation
+  mattr_accessor :store_request_info
 
   class << self
     attr_accessor :loader
   end
+
   def self.init
     @@table_exists ||= check_if_table_exists
     if loader.nil? && @@table_exists
       self.loader ||= Loader.new
       Lit.humanize_key = false if Lit.humanize_key.nil?
-      Lit.fallback = true if Lit.fallback.nil?
       if Lit.ignored_keys.is_a?(String)
         keys = Lit.ignored_keys.split(',').map(&:strip)
         Lit.ignored_keys = keys
       end
+      Lit.ignore_yaml_on_startup = true if Lit.ignore_yaml_on_startup.nil?
       Lit.ignored_keys = [] unless Lit.ignored_keys.is_a?(Array)
       # if loading all translations on start, migrations have to be already
       # performed, fails on first deploy
@@ -43,14 +46,18 @@ module Lit
 
   def self.get_key_value_engine
     case Lit.key_value_engine
-        when 'redis'
-          require 'lit/adapters/redis_storage'
-          return RedisStorage.new
-        else
-          require 'lit/adapters/hash_storage'
-          return HashStorage.new
+    when 'redis'
+      require 'lit/adapters/redis_storage'
+      return RedisStorage.new
+    else
+      require 'lit/adapters/hash_storage'
+      return HashStorage.new
     end
   end
+
+  def self.fallback=(_value)
+    ::Rails.logger.error "[DEPRECATION] Lit.fallback= has been deprecated, please use `config.i18n.fallbacks` instead"
+  end
 end
 
 if defined? Rails

data/lib/lit/adapters/hash_storage.rb

@@ -4,5 +4,9 @@ module Lit
       self[key] ||= 0
       self[key] += 1
     end
+
+    def prefix
+      nil
+    end
   end
 end

data/lib/lit/adapters/redis_storage.rb

@@ -2,6 +2,7 @@ require 'redis'
 module Lit
   extend self
   def redis
+    $redis ||= nil
     $redis = Redis.new(url: determine_redis_provider) unless $redis
     $redis
   end
@@ -47,7 +48,7 @@ module Lit
     end
 
     def clear
-      Lit.redis.del(keys) if keys.length > 0
+      Lit.redis.del(keys) unless keys.empty?
     end
 
     def keys
@@ -57,6 +58,7 @@ module Lit
     def has_key?(key)
       Lit.redis.exists(_prefixed_key(key))
     end
+    alias key? has_key?
 
     def incr(key)
       Lit.redis.incr(_prefixed_key(key))
@@ -68,12 +70,16 @@ module Lit
       end
     end
 
+    def prefix
+      _prefix
+    end
+
     private
 
     def _prefix
       prefix = 'lit:'
-      if Lit.storage_options.is_a?(Hash)
-        prefix += "#{Lit.storage_options[:prefix]}:" if Lit.storage_options.key?(:prefix)
+      if Lit.storage_options.is_a?(Hash) && Lit.storage_options.key?(:prefix)
+        prefix += "#{Lit.storage_options[:prefix]}:"
       end
       prefix
     end

data/lib/lit/cache.rb

@@ -20,13 +20,18 @@ module Lit
   class Cache
     def initialize
       @hits_counter = Lit.get_key_value_engine
+      @request_info_store = Lit.get_key_value_engine
       @hits_counter_working = true
+      @keys = nil
     end
 
     def [](key)
+      key_without_locale = split_key(key).last
       update_hits_count(key)
-      ret = localizations[key]
-      ret
+      store_request_info(key_without_locale)
+      localization = localizations[key]
+      update_request_keys(key_without_locale, localization)
+      localization
     end
 
     def []=(key, value)
@@ -46,14 +51,20 @@ module Lit
     end
 
     def keys
-      localizations.keys
+      return @keys if @keys.present?
+      @keys = localizations.keys
+      return @keys if localizations.prefix.nil?
+      @keys = @keys.map do |k|
+        k.gsub(/^#{localizations.prefix}/, '')
+      end
     end
 
-    def update_locale(key, value, force_array = false)
+    def update_locale(key, value, force_array = false, startup_process = false)
       key = key.to_s
       locale_key, key_without_locale = split_key(key)
       locale = find_locale(locale_key)
-      localization = find_localization(locale, key_without_locale, value, force_array, true)
+      localization = find_localization(locale, key_without_locale, value: value, force_array: force_array, update_value: true)
+      return localization.get_value if startup_process && localization.is_changed?
       localizations[key] = localization.get_value if localization
     end
 
@@ -64,17 +75,17 @@ module Lit
 
     def delete_locale(key)
       key = key.to_s
+      keys.delete(key)
       locale_key, key_without_locale = split_key(key)
       locale = find_locale(locale_key)
       delete_localization(locale, key_without_locale)
     end
 
     def load_all_translations
-      first = Localization.order('id ASC').first
-      last = Localization.order('id DESC').first
-      if !first || !last || (!localizations.has_key?(first.full_key) ||
+      first = Localization.order(id: :asc).first
+      last = Localization.order(id: :desc).first
+      if !first || (!localizations.has_key?(first.full_key) ||
         !localizations.has_key?(last.full_key))
-
         Localization.includes([:locale, :localization_key]).find_each do |l|
           localizations[l.full_key] = l.get_value
         end
@@ -85,7 +96,7 @@ module Lit
       key = key.to_s
       locale_key, key_without_locale = split_key(key)
       locale = find_locale(locale_key)
-      localization = find_localization(locale, key_without_locale)
+      localization = find_localization(locale, key_without_locale, default_fallback: true)
       localizations[key] = localization.get_value if localization
     end
 
@@ -103,13 +114,12 @@ module Lit
       localization_keys.clear
       load_all_translations
     end
-
     alias_method :clear, :reset
 
     def find_locale(locale_key)
       locale_key = locale_key.to_s
       @locale_cache ||= {}
-      unless @locale_cache.has_key?(locale_key)
+      unless @locale_cache.key?(locale_key)
         locale = Lit::Locale.where(locale: locale_key).first_or_create!
         @locale_cache[locale_key] = locale
       end
@@ -129,8 +139,8 @@ module Lit
       localizations_scope.find_each do |l|
         db_localizations[l.full_key] = l.get_value
       end
-      keys = nested_string_keys_to_hash(db_localizations)
-      keys.to_yaml
+      exported_keys = nested_string_keys_to_hash(db_localizations)
+      exported_keys.to_yaml
     end
 
     def nested_string_keys_to_hash(db_localizations)
@@ -141,13 +151,13 @@ module Lit
         end
         next o
       end
-      keys = {}
+      nested_keys = {}
       db_localizations.sort.each do |k, v|
         key_parts = k.to_s.split('.')
         converted = key_parts.reverse.reduce(v) { |a, n| { n => a } }
-        keys.merge!(converted, &deep_proc)
+        nested_keys.merge!(converted, &deep_proc)
       end
-      keys
+      nested_keys
     end
 
     def get_global_hits_counter(key)
@@ -176,64 +186,66 @@ module Lit
       @localization_keys ||= Lit.get_key_value_engine
     end
 
-    def find_localization(locale, key_without_locale, value = nil, force_array = false, update_value = false)
-      unless value.is_a?(Hash)
-        ActiveRecord::Base.transaction do
-          localization_key = find_localization_key(key_without_locale)
-          localization = Lit::Localization.where(locale_id: locale.id).
-                            where(localization_key_id: localization_key.id).first_or_initialize
-          if update_value || localization.new_record?
-            if value.is_a?(Array)
-              unless force_array
-                new_value = nil
-                value_clone = value.dup
-                while (v = value_clone.shift) && v.present?
-                  pv = parse_value(v, locale)
-                  new_value = pv unless pv.nil?
-                end
-                value = new_value
-              end
-            else
-              value = parse_value(value, locale) unless value.nil?
-            end
-            if value.nil?
-              if Lit.fallback
-                @locale_cache.keys.each do |lc|
-                  if lc != locale.locale
-                    nk = "#{lc}.#{key_without_locale}"
-                    v = localizations[nk]
-                    value = v if v.present? && value.nil?
-                  end
-                end
-              end
-              if value.nil? && Lit.humanize_key
-                value = key_without_locale.split('.').last.humanize
-              end
+    def find_localization(locale, key_without_locale, value: nil, force_array: false, update_value: false, default_fallback: false)
+      return nil if value.is_a?(Hash)
+      ActiveRecord::Base.transaction do
+        localization_key = find_localization_key(key_without_locale)
+        localization = Lit::Localization.where(locale_id: locale.id). \
+                          where(localization_key_id: localization_key.id).first_or_initialize
+        if update_value || localization.new_record?
+          if value.is_a?(Array)
+            value = parse_array_value(value) unless force_array
+          elsif !value.nil?
+            value = parse_value(value, locale)
+          else
+            if ::Rails.application.config.i18n.fallbacks
+              value = fallback_localization(locale, key_without_locale)
+            elsif default_fallback
+              value = fallback_to_default(localization_key, localization)
             end
-            localization.update_default_value(value)
           end
-          return localization
-
+          localization.update_default_value(value)
+        end
+        return localization
+      end
+      nil
+    end
+
+    # fallback to translation in different locale
+    def fallback_localization(locale, key_without_locale)
+      value = nil
+      return nil unless fallbacks = ::Rails.application.config.i18n.fallbacks
+      keys = fallbacks == true ? @locale_cache.keys : fallbacks
+      keys.map(&:to_s).each do |lc|
+        if lc != locale.locale && value.nil?
+          nk = "#{lc}.#{key_without_locale}"
+          v = localizations[nk]
+          value = v if v.present? && value.nil?
         end
-      else
-        nil
       end
+      value
+    end
+
+    # tries to get `default_value` from localization_key - checks other
+    # localizations
+    def fallback_to_default(localization_key, localization)
+      localization_key.localizations.where.not(default_value: nil). \
+        where.not(id: localization.id).first&.default_value
     end
 
     def find_localization_for_delete(locale, key_without_locale)
       localization_key = find_localization_key_for_delete(key_without_locale)
       return nil unless localization_key
-      Lit::Localization.where(locale_id: locale.id).
-          where(localization_key_id: localization_key.id).first
+      Lit::Localization.find_by(locale_id: locale.id,
+                                localization_key_id: localization_key.id)
     end
 
     def delete_localization(locale, key_without_locale)
       localization = find_localization_for_delete(locale, key_without_locale)
-      if localization
-        localizations.delete("#{locale.locale}.#{key_without_locale}")
-        localization_keys.delete(key_without_locale)
-        localization.destroy # or localization.default_value = nil; localization.save!
-      end
+      return unless localization
+      localizations.delete("#{locale.locale}.#{key_without_locale}")
+      localization_keys.delete(key_without_locale)
+      localization.destroy # or localization.default_value = nil; localization.save!
     end
 
     ## checks parameter type and returns value basing on it
@@ -263,16 +275,26 @@ module Lit
       new_value
     end
 
+    def parse_array_value(value)
+      new_value = nil
+      value_clone = value.dup
+      while (v = value_clone.shift) && v.present?
+        pv = parse_value(v, locale)
+        new_value = pv unless pv.nil?
+      end
+      new_value
+    end
+
     def find_localization_key(key_without_locale)
-      unless localization_keys.has_key?(key_without_locale)
+      unless localization_keys.key?(key_without_locale)
         find_or_create_localization_key(key_without_locale)
       else
-        Lit::LocalizationKey.find_by_id(localization_keys[key_without_locale]) || find_or_create_localization_key(key_without_locale)
+        Lit::LocalizationKey.find_by(id: localization_keys[key_without_locale]) || find_or_create_localization_key(key_without_locale)
       end
     end
 
     def find_localization_key_for_delete(key_without_locale)
-      lk = Lit::LocalizationKey.find_by_id(localization_keys[key_without_locale]) if localization_keys.has_key?(key_without_locale)
+      lk = Lit::LocalizationKey.find_by(id: localization_keys[key_without_locale]) if localization_keys.has_key?(key_without_locale)
       lk || Lit::LocalizationKey.where(localization_key: key_without_locale).first
     end
 
@@ -287,14 +309,48 @@ module Lit
     end
 
     def update_hits_count(key)
-      if @hits_counter_working
-        key_without_locale = split_key(key).last
-        @hits_counter.incr('hits_counter.' + key)
-        @hits_counter.incr('global_hits_counter.' + key_without_locale)
-      end
+      return unless @hits_counter_working
+      key_without_locale = split_key(key).last
+      @hits_counter.incr('hits_counter.' + key)
+      @hits_counter.incr('global_hits_counter.' + key_without_locale)
+    end
+
+    def store_request_info(key_without_locale)
+      return unless Lit.store_request_info
+      return unless Thread.current[:lit_current_request_path].present?
+      info = get_request_info(key_without_locale)
+      parts = info.split(' ').push(Thread.current[:lit_current_request_path]).uniq
+      parts.shift if parts.count > 10
+      @request_info_store['request_info.' + key_without_locale] = parts.join ' '
+    end
+
+    def update_request_keys(key_without_locale, localization)
+      return if Thread.current[:lit_request_keys].nil?
+      Thread.current[:lit_request_keys] ||= {}
+      Thread.current[:lit_request_keys][key_without_locale] = localization
+    end
+
+    def request_keys
+      Thread.current[:lit_request_keys] || {}
+    end
+    public :request_keys
+
+    def get_request_info(key_without_locale)
+      @request_info_store['request_info.' + key_without_locale].to_s
     end
+    public :get_request_info
+
     def self.split_key(key)
       key.split('.', 2)
     end
+
+    def self.flatten_hash(hash_to_flatten, parent = [])
+      hash_to_flatten.flat_map do |key, value|
+        case value
+        when Hash then flatten_hash(value, parent + [key])
+        else [(parent + [key]).join('.'), value]
+        end
+      end
+    end
   end
 end