motorefi-lit 0.3.3

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

@@ -0,0 +1,52 @@
+
+# Which authentication function to use (ie. :authenticate_user!)? When set to
+# `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 %>'
+
+# Pass extra options to key_value_neinge, ie. prefix for redis (only one
+# supported at the moment)
+# Lit.storage_options = { prefix: "my_project" }
+
+# If true all translations are returned as html_safe strings
+Lit.all_translations_are_html_safe = false
+
+# Translations without default will be humanized (default string will be added)
+# ie. scope.page_header will become "Page header"
+# If `false` then will serve nil instead (but translation will be wrapped in
+# <span title="translation missing string"></span>
+Lit.humanize_key = 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 %>'
+
+# 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

@@ -0,0 +1,66 @@
+require 'rails/generators'
+module Lit
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      class_option 'key-value-engine', type: :string
+      class_option 'authentication-function', type: :string
+      class_option 'no-migrate', type: :boolean
+
+      source_root File.expand_path('../install/templates', __FILE__)
+
+      desc 'Automates Lit installation'
+
+      def set_authentication_function
+        @authentication_function = options['authentication-function'].presence ||
+              ask("What's the authentication function, ie. :authenticate_user! :").presence ||
+              nil
+      end
+
+      def set_key_value_engine
+        @key_value_engine = options['key-value-engine'].presence ||
+              ask("What's the key value engine? ([hash] OR redis):").presence ||
+              :hash
+      end
+
+      def add_redis_dependency
+        if @key_value_engine == 'redis'
+          puts 'Adding redis dependency'
+          gem 'redis'
+          Bundler.with_clean_env do
+            run 'bundle install'
+          end
+        end
+      end
+
+      def generate_api_key
+        @api_key = SecureRandom.base64 32
+      end
+
+      def add_lit_initializer
+        path = "#{::Rails.root}/config/initializers/lit.rb"
+        if File.exist?(path)
+          puts 'Skipping config/initializers/lit.rb creation, file already exists!'
+        else
+          puts 'Adding lit initializer (config/initializers/lit.rb)...'
+          template 'initializer.rb', path
+        end
+      end
+
+      def run_migrations
+        unless options['no-migrate']
+          puts 'Running rake db:migrate'
+          `rake db:migrate`
+        end
+      end
+
+      def clear_cache
+        Lit.init.cache.reset
+      end
+
+      def mount_engine
+        puts "Mounting Lit::Engine at \"/lit\" in config/routes.rb..."
+        route "mount Lit::Engine => '/lit'"
+      end
+    end
+  end
+end

data/lib/lit.rb

@@ -0,0 +1,65 @@
+require 'lit/engine'
+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 :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?
+      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
+      # self.loader.cache.load_all_translations
+      Lit.storage_options ||= {}
+    end
+    self.loader
+  end
+
+  def self.check_if_table_exists
+    Lit::Locale.table_exists?
+  rescue
+    false
+  end
+
+  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
+    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
+  require 'lit/rails'
+end

data/lib/lit/adapters/hash_storage.rb

@@ -0,0 +1,12 @@
+module Lit
+  class HashStorage < Hash
+    def incr(key)
+      self[key] ||= 0
+      self[key] += 1
+    end
+
+    def prefix
+      nil
+    end
+  end
+end

data/lib/lit/adapters/redis_storage.rb

@@ -0,0 +1,99 @@
+require 'redis'
+module Lit
+  extend self
+  def redis
+    $redis ||= nil
+    $redis = Redis.new(url: determine_redis_provider) unless $redis
+    $redis
+  end
+
+  def determine_redis_provider
+    ENV[ENV['REDIS_PROVIDER'] || 'REDIS_URL']
+  end
+
+  class RedisStorage
+    def initialize
+      Lit.redis
+    end
+
+    def [](key)
+      if Lit.redis.exists(_prefixed_key_for_array(key))
+        Lit.redis.lrange(_prefixed_key(key), 0, -1)
+      elsif Lit.redis.exists(_prefixed_key_for_nil(key))
+        nil
+      else
+        Lit.redis.get(_prefixed_key(key))
+      end
+    end
+
+    def []=(k, v)
+      delete(k)
+      if v.is_a?(Array)
+        Lit.redis.set(_prefixed_key_for_array(k), '1')
+        v.each do |ve|
+          Lit.redis.rpush(_prefixed_key(k), ve.to_s)
+        end
+      elsif v.nil?
+        Lit.redis.set(_prefixed_key_for_nil(k), '1')
+        Lit.redis.set(_prefixed_key(k), '')
+      else
+        Lit.redis.set(_prefixed_key(k), v)
+      end
+    end
+
+    def delete(k)
+      Lit.redis.del(_prefixed_key_for_array(k))
+      Lit.redis.del(_prefixed_key_for_nil(k))
+      Lit.redis.del(_prefixed_key(k))
+    end
+
+    def clear
+      Lit.redis.del(keys) unless keys.empty?
+    end
+
+    def keys
+      Lit.redis.keys(_prefixed_key + '*')
+    end
+
+    def has_key?(key)
+      Lit.redis.exists(_prefixed_key(key))
+    end
+    alias key? has_key?
+
+    def incr(key)
+      Lit.redis.incr(_prefixed_key(key))
+    end
+
+    def sort
+      Lit.redis.keys.sort.map do |k|
+        [k, self.[](k)]
+      end
+    end
+
+    def prefix
+      _prefix
+    end
+
+    private
+
+    def _prefix
+      prefix = 'lit:'
+      if Lit.storage_options.is_a?(Hash) && Lit.storage_options.key?(:prefix)
+        prefix += "#{Lit.storage_options[:prefix]}:"
+      end
+      prefix
+    end
+
+    def _prefixed_key(key = '')
+      _prefix + key.to_s
+    end
+
+    def _prefixed_key_for_array(key = '')
+      _prefix + 'array_flags:' + key.to_s
+    end
+
+    def _prefixed_key_for_nil(key = '')
+      _prefix + 'nil_flags:' + key.to_s
+    end
+  end
+end

data/lib/lit/cache.rb

@@ -0,0 +1,356 @@
+module I18n
+  class << self
+    @@cache_store = nil
+
+    def cache_store
+      @@cache_store || I18n.backend.cache
+    end
+
+    def cache_store=(store)
+      @@cache_store = store
+    end
+
+    def perform_caching?
+      !cache_store.nil?
+    end
+  end
+end
+
+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)
+      store_request_info(key_without_locale)
+      localization = localizations[key]
+      update_request_keys(key_without_locale, localization)
+      localization
+    end
+
+    def []=(key, value)
+      update_locale(key, value)
+    end
+
+    def init_key_with_value(key, value)
+      update_locale(key, value, true)
+    end
+
+    def has_key?(key)
+      localizations.has_key?(key)
+    end
+
+    def sync
+      localizations.clear
+    end
+
+    def 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, 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: 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
+
+    def update_cache(key, value)
+      key = key.to_s
+      localizations[key] = value
+    end
+
+    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 || (!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
+      end
+    end
+
+    def refresh_key(key)
+      key = key.to_s
+      locale_key, key_without_locale = split_key(key)
+      locale = find_locale(locale_key)
+      localization = find_localization(locale, key_without_locale, default_fallback: true)
+      localizations[key] = localization.get_value if localization
+    end
+
+    def delete_key(key)
+      key = key.to_s
+      localizations.delete(key)
+      key_without_locale = split_key(key).last
+      localization_keys.delete(key_without_locale)
+      I18n.backend.reload!
+    end
+
+    def reset
+      @locale_cache = {}
+      localizations.clear
+      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.key?(locale_key)
+        locale = Lit::Locale.where(locale: locale_key).first_or_create!
+        @locale_cache[locale_key] = locale
+      end
+      @locale_cache[locale_key]
+    end
+
+    # this comes directly from copycopter.
+    def export
+      reset
+      localizations_scope = Lit::Localization
+      unless ENV['LOCALES'].blank?
+        locale_keys = ENV['LOCALES'].to_s.split(',') || []
+        locale_ids = Lit::Locale.where(locale: locale_keys).pluck(:id)
+        localizations_scope = localizations_scope.where(locale_id: locale_ids) unless locale_ids.empty?
+      end
+      db_localizations = {}
+      localizations_scope.find_each do |l|
+        db_localizations[l.full_key] = l.get_value
+      end
+      exported_keys = nested_string_keys_to_hash(db_localizations)
+      exported_keys.to_yaml
+    end
+
+    def nested_string_keys_to_hash(db_localizations)
+      # http://subtech.g.hatena.ne.jp/cho45/20061122
+      deep_proc = proc do |_k, s, o|
+        if s.is_a?(Hash) && o.is_a?(Hash)
+          next s.merge(o, &deep_proc)
+        end
+        next o
+      end
+      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 } }
+        nested_keys.merge!(converted, &deep_proc)
+      end
+      nested_keys
+    end
+
+    def get_global_hits_counter(key)
+      @hits_counter['global_hits_counter.' + key]
+    end
+
+    def get_hits_counter(key)
+      @hits_counter['hits_counter.' + key]
+    end
+
+    def stop_hits_counter
+      @hits_counter_working = false
+    end
+
+    def restore_hits_counter
+      @hits_counter_working = true
+    end
+
+    private
+
+    def localizations
+      @localizations ||= Lit.get_key_value_engine
+    end
+
+    def localization_keys
+      @localization_keys ||= Lit.get_key_value_engine
+    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
+          end
+          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
+      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.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)
+      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
+    ## symbols are beeing looked up in db
+    ## string are returned directly
+    ## procs are beeing called (once)
+    ## hashes are converted do string (for now)
+    def parse_value(v, locale)
+      new_value = nil
+      case v
+        when Symbol then
+          lk = Lit::LocalizationKey.where(localization_key: v.to_s).first
+          if lk
+            loca = Lit::Localization.where(locale_id: locale.id).
+                        where(localization_key_id: lk.id).first
+            new_value = loca.get_value if loca && loca.get_value.present?
+          end
+        when String then
+          new_value = v
+        when Hash then
+          new_value = nil
+        when Proc then
+          new_value = nil # was v.call - requires more love
+        else
+          new_value = v.to_s
+      end
+      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.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)
+      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.where(localization_key: key_without_locale).first
+    end
+
+    def split_key(key)
+      Lit::Cache.split_key(key)
+    end
+
+    def find_or_create_localization_key(key_without_locale)
+      localization_key = Lit::LocalizationKey.where(localization_key: key_without_locale).first_or_create!
+      localization_keys[key_without_locale] = localization_key.id
+      localization_key
+    end
+
+    def update_hits_count(key)
+      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