lit 0.2.4 → 0.2.5

data/app/views/lit/incomming_localizations/accept.js.erb

@@ -0,0 +1,2 @@
+$('table.incomming-localizations-table tr[data-id="<%= @incomming_localization.id %>"]').remove();
+

data/app/views/lit/incomming_localizations/destroy.js.erb

@@ -0,0 +1 @@
+$('table.incomming-localizations-table tr[data-id="<%= @incomming_localization.id %>"]').remove();

data/app/views/lit/incomming_localizations/index.html.erb

@@ -10,20 +10,20 @@
   </span>
 </div>
 
-<table class="table table-bordered table-striped">
+<table class="table table-bordered table-striped incomming-localizations-table">
   <tr>
     <th>Current value</th>
     <th>Imported value</th>
     <th width="200px"></th>
   </tr>
   <% @incomming_localizations.each do |il| %>
-    <tr>
+    <tr data-id="<%= il.id %>">
       <td colspan="3">
         <%= image_tag "lit/famfamfam_flags/#{il.locale_str[0,2]}.png" %>
         <strong><%= il.full_key %></strong>
       </td>
     </tr>
-    <tr>
+    <tr data-id="<%= il.id %>">
       <td>
         <% if il.localization %>
           <%= render :partial=>"/lit/localization_keys/localization_row", :locals=>{:localization=>il.localization.get_value} %>
@@ -33,11 +33,11 @@
         <%= render :partial=>"/lit/localization_keys/localization_row", :locals=>{:localization=>il.get_value} %>
       </td>
       <td>
-        <%= link_to accept_source_incomming_localization_path(@source, il), :class=>"btn btn-success btn-sm" do %>
+        <%= link_to accept_source_incomming_localization_path(@source, il), :class=>"btn btn-success btn-sm", :remote=>true do %>
           <%= draw_icon "check", :class=>"icon-white" %>
           <%= t('lit.common.accept', :default=>"Accept") %>
         <% end %>
-        <%= link_to source_incomming_localization_path(@source, il), :class=>"btn btn-danger btn-sm", :method=>:delete, :data=>{:confirm=>t('lit.common.you_sure', :default=>"Are you sure?")} do %>
+        <%= link_to source_incomming_localization_path(@source, il), :class=>"btn btn-danger btn-sm", :remote=>true, :method=>:delete, :data=>{:confirm=>t('lit.common.you_sure', :default=>"Are you sure?")} do %>
           <%= draw_icon "times", :class=>"icon-white" %>
           <%= t('lit.common.reject', :default=>"Reject") %>
         <% end %>

data/app/views/lit/localization_keys/index.html.erb

@@ -88,7 +88,7 @@
       <li class="nav-header">Narrow with prefix</li>
       <% if @search_options[:key_prefix].present? %>
         <li>
-          <%= link_to url_for(@search_options.merge(:key_prefix=>p)), :title=>(@parent_prefix.present? ? @parent_prefix : 'show all') do %>
+          <%= link_to url_for(@search_options.merge(:key_prefix=>@parent_prefix.present? ? @parent_prefix : nil)), :title=>(@parent_prefix.present? ? @parent_prefix : 'show all') do %>
             <%= draw_icon('chevron-left') %>
             <%= @parent_prefix.present? ? @parent_prefix.split('.').last : 'show all' %>
           <% end %>

data/app/views/lit/localizations/_form.html.erb

@@ -18,6 +18,6 @@
   <% end %>
 
   <button class="btn btn-primary btn-sm" type="submit"><%= t('lit.common.update', :default=>"Update") %></button>
-  <button class="btn btn-default btn-sm"><%= t('lit.common.cancel', :default=>'Cancel') %></button>
+  <button class="btn btn-default btn-sm cancel" type="reset"><%= t('lit.common.cancel', :default=>'Cancel') %></button>
 <% end %>
 

data/app/views/lit/localizations/_previous_versions_rows.html.erb

@@ -2,14 +2,14 @@
 <table class="table table-condensed">
   <tr>
     <th><%= t('lit.common.previous_versions') %></th>
-    <th width="25%"><%= t('lit.common.created_at') %></th>
+    <th width="25%"><%= t('lit.common.changed_at') %></th>
   </tr>
   <% @versions.each do |v| %>
     <tr>
       <td>
         <%= render :partial=>"/lit/localization_keys/localization_row", :locals=>{:localization=>v.translated_value} %>
       </td>
-      <td><%= v.created_at %></td>
+      <td><%= I18n.l v.created_at, format: :long %></td>
     </tr>
   <% end %>
 </table>

data/app/views/lit/sources/index.html.erb

@@ -5,7 +5,7 @@
     <th>Identifier</th>
     <th>Last synchronization</th>
     <th>Last change (remote)</th>
-    <th width="80px"></th>
+    <th width="95px"></th>
   </tr>
 
 <% @sources.each do |source| %>
@@ -14,6 +14,9 @@
     <td><%= source.last_updated_at.to_s(:db) unless source.last_updated_at.nil? %></td>
     <td><%= source.get_last_change %></td>
     <td>
+      <%= link_to lit.source_incomming_localizations_path(source), :title=>t('lit.common.browse_incomming', :default=>"Browse incomming localizations") do %>
+        <%= draw_icon 'search' %>
+      <% end %>
       <%= link_to lit.synchronize_source_path(source), :title=>t('lit.common.synchronize', :default=>"Synchronize") do %>
         <%= draw_icon 'refresh' %>
       <% end %>

data/lib/generators/lit/install_generator.rb

@@ -2,39 +2,39 @@ 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
+      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__)
+      source_root File.expand_path('../install/templates', __FILE__)
 
-      desc "Automates Lit installation"
+      desc 'Automates Lit installation'
 
       def copy_migrations
-        puts "Copying Lit 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 ||
+        @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 ||
+        @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"
+          puts 'Adding redis dependency'
           gem 'redis'
           Bundler.with_clean_env do
-            run "bundle install"
+            run 'bundle install'
           end
         end
       end
@@ -45,17 +45,17 @@ module Lit
 
       def add_lit_initializer
         path = "#{::Rails.root}/config/initializers/lit.rb"
-        if File.exists?(path)
-          puts "Skipping config/initializers/lit.rb creation, file already exists!"
+        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
+          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"
+        unless options['no-migrate']
+          puts 'Running rake db:migrate'
           `rake db:migrate`
         end
       end

data/lib/lit.rb

@@ -1,4 +1,4 @@
-require "lit/engine"
+require 'lit/engine'
 require 'lit/loader'
 
 module Lit
@@ -6,6 +6,7 @@ module Lit
   mattr_accessor :key_value_engine
   mattr_accessor :storage_options
   mattr_accessor :humanize_key
+  mattr_accessor :ignored_keys
   mattr_accessor :fallback
   mattr_accessor :api_enabled
   mattr_accessor :api_key
@@ -16,10 +17,16 @@ module Lit
     attr_accessor :loader
   end
   def self.init
-    @@table_exists ||= self.check_if_table_exists
-    if self.loader.nil? && @@table_exists
+    @@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.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
@@ -29,11 +36,9 @@ module Lit
   end
 
   def self.check_if_table_exists
-    begin
-      Lit::Locale.table_exists?
-    rescue
-      false
-    end
+    Lit::Locale.table_exists?
+  rescue
+    false
   end
 
   def self.get_key_value_engine

data/lib/lit/adapters/hash_storage.rb

@@ -5,4 +5,4 @@ module Lit
       self[key] += 1
     end
   end
-end
+end

data/lib/lit/adapters/redis_storage.rb

@@ -2,9 +2,14 @@ require 'redis'
 module Lit
   extend self
   def redis
-    $redis = Redis.new(url: ENV['REDIS_URL']) unless $redis
+    $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
@@ -21,16 +26,15 @@ module Lit
     end
 
     def []=(k, v)
-
       delete(k)
       if v.is_a?(Array)
-        Lit.redis.set(_prefixed_key_for_array(k), "1")
+        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), "")
+        Lit.redis.set(_prefixed_key_for_nil(k), '1')
+        Lit.redis.set(_prefixed_key(k), '')
       else
         Lit.redis.set(_prefixed_key(k), v)
       end
@@ -43,11 +47,11 @@ module Lit
     end
 
     def clear
-      Lit.redis.del(self.keys) if self.keys.length > 0
+      Lit.redis.del(keys) if keys.length > 0
     end
 
     def keys
-      Lit.redis.keys(_prefixed_key+"*")
+      Lit.redis.keys(_prefixed_key + '*')
     end
 
     def has_key?(key)
@@ -65,21 +69,25 @@ module Lit
     end
 
     private
-      def _prefix
-        prefix = "lit:"
-        if Lit.storage_options.is_a?(Hash)
-          prefix += "#{Lit.storage_options[:prefix]}:" if Lit.storage_options.has_key?(: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
+
+    def _prefix
+      prefix = 'lit:'
+      if Lit.storage_options.is_a?(Hash)
+        prefix += "#{Lit.storage_options[:prefix]}:" if Lit.storage_options.key?(: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

@@ -18,16 +18,14 @@ end
 
 module Lit
   class Cache
-
     def initialize
-      @localizations = Lit.get_key_value_engine
       @hits_counter = Lit.get_key_value_engine
       @hits_counter_working = true
     end
 
     def [](key)
       update_hits_count(key)
-      ret = @localizations[key]
+      ret = localizations[key]
       ret
     end
 
@@ -40,28 +38,28 @@ module Lit
     end
 
     def has_key?(key)
-      @localizations.has_key?(key)
+      localizations.has_key?(key)
     end
 
     def sync
-      @localizations.clear
+      localizations.clear
     end
 
     def keys
-      @localizations.keys
+      localizations.keys
     end
 
-    def update_locale(key, value, force_array=false)
+    def update_locale(key, value, force_array = 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)
-      @localizations[key] = localization.get_value if localization
+      localizations[key] = localization.get_value if localization
     end
 
     def update_cache(key, value)
       key = key.to_s
-      @localizations[key] = value
+      localizations[key] = value
     end
 
     def delete_locale(key)
@@ -74,11 +72,11 @@ module Lit
     def load_all_translations
       first = Localization.order('id ASC').first
       last = Localization.order('id DESC').first
-      if not first or not last or (not @localizations.has_key?(first.full_key) or
-        not @localizations.has_key?(last.full_key))
+      if !first || !last || (!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
+          localizations[l.full_key] = l.get_value
         end
       end
     end
@@ -88,23 +86,21 @@ module Lit
       locale_key, key_without_locale = split_key(key)
       locale = find_locale(locale_key)
       localization = find_localization(locale, key_without_locale)
-      @localizations[key] = localization.get_value if localization
+      localizations[key] = localization.get_value if localization
     end
 
     def delete_key(key)
       key = key.to_s
-      @localizations.delete(key)
+      localizations.delete(key)
       key_without_locale = split_key(key).last
-      @localization_keys.delete(key_without_locale)
+      localization_keys.delete(key_without_locale)
       I18n.backend.reload!
     end
 
     def reset
       @locale_cache = {}
-      @localizations = Lit.get_key_value_engine
-      @localizations.clear
-      @localization_keys = Lit.get_key_value_engine
-      @localization_keys.clear
+      localizations.clear
+      localization_keys.clear
       load_all_translations
     end
 
@@ -114,13 +110,12 @@ module Lit
       locale_key = locale_key.to_s
       @locale_cache ||= {}
       unless @locale_cache.has_key?(locale_key)
-        locale = Lit::Locale.where(:locale=>locale_key).first_or_create!
+        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
@@ -140,27 +135,27 @@ module Lit
 
     def nested_string_keys_to_hash(db_localizations)
       # http://subtech.g.hatena.ne.jp/cho45/20061122
-      deep_proc = Proc.new { |k, s, o|
-        if s.kind_of?(Hash) && o.kind_of?(Hash)
+      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
       keys = {}
-      db_localizations.sort.each do |k,v|
+      db_localizations.sort.each do |k, v|
         key_parts = k.to_s.split('.')
-        converted = key_parts.reverse.inject(v) { |a, n| { n => a } }
+        converted = key_parts.reverse.reduce(v) { |a, n| { n => a } }
         keys.merge!(converted, &deep_proc)
       end
       keys
     end
 
     def get_global_hits_counter(key)
-      @hits_counter['global_hits_counter.'+key]
+      @hits_counter['global_hits_counter.' + key]
     end
 
     def get_hits_counter(key)
-      @hits_counter['hits_counter.'+key]
+      @hits_counter['hits_counter.' + key]
     end
 
     def stop_hits_counter
@@ -173,122 +168,130 @@ module Lit
 
     private
 
-      def find_localization(locale, key_without_locale, value=nil, force_array=false, update_value=false)
-        unless value.is_a?(Hash)
-          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
+    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)
+      unless value.is_a?(Hash)
+        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
-            else
-              value = parse_value(value, locale) unless value.nil?
+              value = new_value
             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? and value.nil?
-                  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
-              if value.nil? && Lit.humanize_key
-                value = key_without_locale.split('.').last.humanize
-              end
             end
-            localization.update_default_value(value)
+            if value.nil? && Lit.humanize_key
+              value = key_without_locale.split('.').last.humanize
+            end
           end
-          return localization
-        else
-          nil
+          localization.update_default_value(value)
         end
+        return localization
+      else
+        nil
       end
+    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
-      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
+    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
-      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 and 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
+    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
+    end
 
-      def find_localization_key(key_without_locale)
-        @localization_keys ||= Lit.get_key_value_engine
-        unless @localization_keys.has_key?(key_without_locale)
-          find_or_create_localization_key(key_without_locale)
+    ## 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
-          Lit::LocalizationKey.find_by_id(@localization_keys[key_without_locale]) || find_or_create_localization_key(key_without_locale)
-        end
+          new_value = v.to_s
       end
+      new_value
+    end
 
-      def find_localization_key_for_delete(key_without_locale)
-        @localization_keys ||= Lit.get_key_value_engine
-        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
+    def find_localization_key(key_without_locale)
+      unless localization_keys.has_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 split_key(key)
-        key.split('.', 2)
-      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 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 split_key(key)
+      Lit::Cache.split_key(key)
+    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
-      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)
+      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
+    end
+    def self.split_key(key)
+      key.split('.', 2)
+    end
   end
 end