lit 0.0.4.3 → 0.1.0

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

@@ -0,0 +1,18 @@
+<p id="notice"><%= notice %></p>
+
+<strong>Indetifier:</strong>
+<%= @source.identifier %>
+<br/>
+<strong>Url:</strong>
+<%= @source.url %>
+<br/>
+<strong>API key:</strong>
+<%= @source.api_key %>
+<br/>
+<strong>Last updated at:</strong>
+<%= @source.last_updated_at.to_s(:db) unless @source.last_updated_at.nil? %>
+<br/>
+
+
+<%= link_to 'Edit', edit_source_path(@source) %> |
+<%= link_to 'Back', sources_path %>

data/config/routes.rb

@@ -1,5 +1,18 @@
 Lit::Engine.routes.draw do
 
+
+  if Lit.api_enabled
+    namespace :api do
+      namespace :v1 do
+        get '/last_change' => 'localizations#last_change'
+        resources :locales, :only=>[:index]
+        resources :localization_keys, :only=>[:index]
+        resources :localizations, :only=>[:index] do
+          get 'last_change', :on=>:collection
+        end
+      end
+    end
+  end
   resources :locales, :only=>[:index, :destroy] do
     put :hide, :on=>:member
   end
@@ -10,7 +23,25 @@ Lit::Engine.routes.draw do
     collection do
       get :starred
     end
-    resources :localizations
+    resources :localizations, :only=>[:edit, :update] do
+      member do
+        get :previous_versions
+      end
+    end
+  end
+  resources :sources do
+    member do
+      get :synchronize
+    end
+    resources :incomming_localizations, :only=>[:index, :destroy] do
+      member do
+        get :accept
+      end
+      collection do
+        get :accept_all
+        post :reject_all
+      end
+    end
   end
 
   root :to=>"dashboard#index"

data/db/migrate/20130921071304_create_lit_localization_versions.rb

@@ -0,0 +1,11 @@
+class CreateLitLocalizationVersions < ActiveRecord::Migration
+  def change
+    create_table :lit_localization_versions do |t|
+      t.text :translated_value
+      t.references :localization
+
+      t.timestamps
+    end
+    add_index :lit_localization_versions, :localization_id
+  end
+end

data/db/migrate/20130923162141_create_lit_sources.rb

@@ -0,0 +1,12 @@
+class CreateLitSources < ActiveRecord::Migration
+  def change
+    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
+end

data/db/migrate/20130924151910_create_lit_incomming_localizations.rb

@@ -0,0 +1,21 @@
+class CreateLitIncommingLocalizations < ActiveRecord::Migration
+  def change
+    create_table :lit_incomming_localizations do |t|
+      t.text :translated_value
+      t.references :locale
+      t.references :localization_key
+      t.references :localization
+      t.string :locale_str
+      t.string :localization_key_str
+      t.references :source
+      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
+end

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

@@ -0,0 +1,34 @@
+
+# Which authentication function to use (ie. :authenticate_user!)? When set to
+# `nil` will let everyone in.
+Lit.authentication_function = <%= @authentication_function || '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" }
+
+# 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
+
+# Decide if missing translations will fallback to first found translated value
+# (same key, different language)
+Lit.fallback = 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 %>"
+
+# Initialize lit
+Lit.init
+
+

data/lib/generators/lit/install_generator.rb

@@ -0,0 +1,73 @@
+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 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 ||
+              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.exists?(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

@@ -7,6 +7,8 @@ module Lit
   mattr_accessor :storage_options
   mattr_accessor :humanize_key
   mattr_accessor :fallback
+  mattr_accessor :api_enabled
+  mattr_accessor :api_key
   class << self
     attr_accessor :loader
   end

data/lib/lit/adapters/hash_storage.rb

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

data/lib/lit/adapters/redis_storage.rb

@@ -11,15 +11,29 @@ module Lit
     end
 
     def [](key)
-      Lit.redis.get(_prefixed_key(key))
+      if Lit.redis.exists(_prefixed_key_for_array(key))
+        Lit.redis.lrange(_prefixed_key(key), 0, -1)
+      else
+        Lit.redis.get(_prefixed_key(key))
+      end
     end
 
     def []=(k, v)
-      Lit.redis.set(_prefixed_key(k).to_s, v.to_s)
+      if v.is_a?(Array)
+        delete(k)
+        Lit.redis.set(_prefixed_key_for_array(k), "1")
+        v.each do |ve|
+          Lit.redis.rpush(_prefixed_key(k), ve.to_s)
+        end
+      else
+        Lit.redis.del(_prefixed_key_for_array(k))
+        Lit.redis.set(_prefixed_key(k), v) unless v.nil?
+      end
     end
 
     def delete(k)
-      Lit.redis.del k
+      Lit.redis.del(_prefixed_key_for_array(k))
+      Lit.redis.del(_prefixed_key(k))
     end
 
     def clear
@@ -45,12 +59,18 @@ module Lit
     end
 
     private
-      def _prefixed_key(key="")
+      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+key
+        prefix
+      end
+      def _prefixed_key(key="")
+        _prefix+key.to_s
+      end
+      def _prefixed_key_for_array(key="")
+        _prefix+"array_flags:"+key.to_s
       end
   end
 end

data/lib/lit/cache.rb

@@ -9,13 +9,23 @@ module Lit
 
     def [](key)
       update_hits_count(key)
-      @localizations[key] 
+      ret = @localizations[key]
+      ret
     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)
+      # @TODO: change into correct has_key? call
+      @localizations.has_key?(key)
+    end
+
     def sync
       @localizations.clear
     end
@@ -24,16 +34,15 @@ module Lit
       @localizations.keys
     end
 
-    def update_locale(key, value)
+    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)
+      localization = find_localization(locale, key_without_locale, value, force_array, true)
       @localizations[key] = localization.get_value if localization
     end
 
     def load_all_translations(oninit=false)
-      Lit.init.logger.info "loading all translations"
       doinit = false
       first = Localization.order('id ASC').first
       last = Localization.order('id DESC').first
@@ -51,7 +60,6 @@ module Lit
 
     def refresh_key(key)
       key = key.to_s
-      Lit.init.logger.info "refreshing key: #{key}"
       locale_key, key_without_locale = split_key(key)
       locale = find_locale(locale_key)
       localization = find_localization(locale, key_without_locale)
@@ -60,7 +68,6 @@ module Lit
 
     def delete_key(key)
       key = key.to_s
-      Lit.init.logger.info "deleting key: #{key}"
       @localizations.delete(key)
       key_without_locale = split_key(key).last
       @localization_keys.delete(key_without_locale)
@@ -80,7 +87,6 @@ module Lit
       locale_key = locale_key.to_s
       @locale_cache ||= {}
       unless @locale_cache.has_key?(locale_key)
-        #Lit.init.logger.info "looking for locale: #{locale_key}"
         locale = Lit::Locale.where(:locale=>locale_key).first_or_create!
         @locale_cache[locale_key] = locale
       end
@@ -131,19 +137,22 @@ module Lit
 
     private
 
-      def find_localization(locale, key_without_locale, value=nil)
+      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_create do |l|
+                            where(:localization_key_id=>localization_key.id).first_or_initialize
+          if update_value || localization.new_record?
             if value.is_a?(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?
+              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
-              value = new_value
             else
               value = parse_value(value, locale) unless value.nil?
             end
@@ -157,14 +166,14 @@ module Lit
                   end
                 end
               end
-              value = key_without_locale.split('.').last.humanize if value.nil? && 
+              value = key_without_locale.split('.').last.humanize if value.nil? &&
                                                                     Lit.humanize_key
             end
-            l.default_value = value
+            localization.default_value = value
+            localization.save!
           end
-          localization
+          return localization
         else
-          Lit.init.logger.info "returning value for hash: #{key_without_locale}: #{value.to_s}"
           nil
         end
       end
@@ -211,14 +220,13 @@ module Lit
       end
 
       def find_or_create_localization_key(key_without_locale)
-        #Lit.init.logger.info "creating key: #{key_without_locale} with id #{localization_key.id}"
-        localization_key = Lit::LocalizationKey.where(:localization_key=>key_without_locale).first_or_create! 
+        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 
+        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)

data/lib/lit/i18n_backend.rb

@@ -27,7 +27,6 @@ module Lit
     # @param [Hash] data nested key-value pairs to be added as blurbs
     def store_translations(locale, data, options = {})
       super
-      #Lit.init.logger.info "store translation: #{locale}, data: #{data}, options: #{options}"
       store_item(locale, data)
     end
 
@@ -37,14 +36,17 @@ module Lit
     def lookup(locale, key, scope = [], options = {})
       parts = I18n.normalize_keys(locale, key, scope, options[:separator])
       key_with_locale = parts.join('.')
-      
+
       ## check in cache or in simple backend
       content = @cache[key_with_locale] || super
-      
-      ## store value if not found
-      if content.nil?
-        @cache[key_with_locale] = options[:default] 
-        content = @cache[key_with_locale] 
+      newly_created = false
+      unless @cache.has_key?(key_with_locale)
+        @cache.init_key_with_value(key_with_locale, content)
+        newly_created = true
+      end
+      if content.nil? || (newly_created && options[:default].present?)
+        @cache[key_with_locale] = options[:default]
+        content = @cache[key_with_locale]
       end
       ## return translated content
       content