motorefi-lit 0.3.3

data/app/controllers/lit/localizations_controller.rb

@@ -0,0 +1,60 @@
+module Lit
+  class LocalizationsController < ::Lit::ApplicationController
+    before_action :find_localization_key
+    before_action :find_localization
+
+    def show
+      render json: { value: @localization.get_value }
+    end
+
+    def edit
+      @localization.translated_value = @localization.get_value
+      respond_to do |format|
+        format.js
+      end
+    end
+
+    def update
+      if @localization.update_attributes(clear_params)
+        @localization.update_column :is_changed, true
+        Lit.init.cache.update_cache @localization.full_key, @localization.get_value
+      end
+      @localization.reload
+      respond_to do |f|
+        f.js
+        f.json do
+          render json: { value: @localization.get_value }
+        end
+      end
+    end
+
+    def previous_versions
+      @versions = @localization.versions.order('created_at DESC')
+      respond_to :js
+    end
+
+    private
+
+    def find_localization_key
+      @localization_key = Lit::LocalizationKey. \
+                          find(params[:localization_key_id])
+    end
+
+    def find_localization
+      @localization = @localization_key.localizations.find(params[:id])
+    end
+
+    def clear_params
+      if params.respond_to?(:permit)
+        # allow translated_value to be an array
+        if @localization.value.is_a?(Array)
+          params.require(:localization).permit(:locale_id, translated_value: [])
+        else
+          params.require(:localization).permit(:locale_id, :translated_value)
+        end
+      else
+        params[:localization].is_a?(Hash) ? params[:localization].slice(:translated_value, :locale_id) : {}
+      end
+    end
+  end
+end

data/app/controllers/lit/sources_controller.rb

@@ -0,0 +1,77 @@
+require_dependency 'lit/application_controller'
+
+module Lit
+  class SourcesController < ApplicationController
+    def index
+      @sources = Source.all
+    end
+
+    def show
+      @source = Source.find(params[:id])
+    end
+
+    def new
+      @source = Source.new
+    end
+
+    def edit
+      @source = Source.find(params[:id])
+    end
+
+    def synchronize
+      @source = Source.find(params[:id])
+      @source.update_column(:sync_complete, false)
+      if defined?(ActiveJob)
+        SynchronizeSourceJob.perform_later(@source)
+      else
+        @source.synchronize
+      end
+      redirect_to lit.source_incomming_localizations_path(@source)
+    end
+
+    def touch
+      @source = Source.find(params[:id])
+      @source.touch_last_updated_at!
+      redirect_to request.env['HTTP_REFERER'].present? ? :back : @source
+    end
+
+    def create
+      @source = Source.new(clear_params)
+      if @source.save
+        redirect_to @source, notice: 'Source was successfully created.'
+      else
+        render action: 'new'
+      end
+    end
+
+    def update
+      @source = Source.find(params[:id])
+      if @source.update_attributes(clear_params)
+        redirect_to @source, notice: 'Source was successfully updated.'
+      else
+        render action: 'edit'
+      end
+    end
+
+    def destroy
+      @source = Source.find(params[:id])
+      @source.destroy
+      redirect_to sources_url
+    end
+
+    def sync_complete
+      @source = Source.find(params[:id])
+      render json: { sync_complete: @source.sync_complete }
+    end
+
+    private
+
+    def clear_params
+      if defined?(::ActionController::StrongParameters)
+        params.require(:source).permit(:identifier, :url, :api_key)
+      else
+        params[:source]
+      end
+    end
+  end
+end

data/app/helpers/lit/application_helper.rb

@@ -0,0 +1,4 @@
+module Lit
+  module ApplicationHelper
+  end
+end

data/app/helpers/lit/dashboard_helper.rb

@@ -0,0 +1,4 @@
+module Lit
+  module DashboardHelper
+  end
+end

data/app/helpers/lit/frontend_helper.rb

@@ -0,0 +1,71 @@
+module Lit
+  module FrontendHelper
+    include ActionView::Helpers::TranslationHelper
+    module TranslationKeyWrapper
+      def translate(key, options = {})
+        options = options.with_indifferent_access
+        key = scope_key_by_partial(key)
+        ret = super(key, options)
+        if !options[:skip_lit] && lit_authorized?
+          ret = get_translateable_span(key, ret)
+        end
+        ret
+      end
+
+      def t(key, options = {})
+        translate(key, options)
+      end
+    end
+    prepend Lit::FrontendHelper::TranslationKeyWrapper
+
+    def javascript_lit_tag
+      javascript_include_tag 'lit/lit_frontend'
+    end
+
+    def stylesheet_lit_tag
+      stylesheet_link_tag 'lit/lit_frontend'
+    end
+
+    def lit_frontend_assets
+      return unless lit_authorized?
+      meta = content_tag :meta,
+                         '',
+                         value: lit.find_localization_localization_keys_path,
+                         name: 'lit-url-base'
+      safe_join([javascript_lit_tag, stylesheet_lit_tag, meta])
+    end
+
+    def lit_translations_info
+      return if Thread.current[:lit_request_keys].nil?
+      return unless lit_authorized?
+      content_tag :div, class: 'lit-translations-info collapsed' do
+        concat content_tag :span, 'Show translations', class: 'lit-open-button'
+        concat content_tag :span, 'X', class: 'lit-close-button'
+        concat(content_tag(:ul, class: 'lit-translations-list') do
+          Lit.init.cache.request_keys.each do |k, v|
+            concat(content_tag(:li) do
+              concat content_tag :code, "#{k}:"
+              concat get_translateable_span(k, v, alternative_text: '[empty]')
+            end)
+          end
+        end)
+      end
+    end
+
+    def lit_authorized?
+      if Lit.authentication_verification.present?
+        send(Lit.authentication_verification)
+      else
+        true
+      end
+    end
+
+    def get_translateable_span(key, localization, alternative_text: nil)
+      content_tag :span,
+                  class: 'lit-key-generic',
+                  data: { key: key, locale: I18n.locale } do
+        localization.blank? ? alternative_text : localization
+      end
+    end
+  end
+end

data/app/helpers/lit/localization_keys_helper.rb

@@ -0,0 +1,5 @@
+module Lit
+  module LocalizationKeysHelper
+    include LocalizationsHelper
+  end
+end

data/app/helpers/lit/localizations_helper.rb

@@ -0,0 +1,15 @@
+module Lit
+  module LocalizationsHelper
+    def draw_icon(icon, opts = {})
+      raw("<i class=\"fa fa-#{icon} #{opts[:class]}\" title=\"#{opts[:title]}\" ></i>")
+    end
+
+    def ejs(val)
+      escape_javascript val.to_s
+    end
+
+    def allow_wysiwyg_editor?(key)
+      Lit.all_translations_are_html_safe || key.to_s =~ /(\b|_|\.)html$/
+    end
+  end
+end

data/app/helpers/lit/sources_helper.rb

@@ -0,0 +1,7 @@
+module Lit
+  module SourcesHelper
+    def source_loading_class(source)
+      source.sync_complete ? 'loaded' : 'loading'
+    end
+  end
+end

data/app/jobs/lit/synchronize_source_job.rb

@@ -0,0 +1,11 @@
+module Lit
+  if defined?(::ActiveJob)
+    class SynchronizeSourceJob < ::ActiveJob::Base
+      queue_as :default
+
+      def perform(source)
+        source.synchronize
+      end
+    end
+  end
+end

data/app/models/lit/incomming_localization.rb

@@ -0,0 +1,77 @@
+module Lit
+  class IncommingLocalization < ActiveRecord::Base
+    serialize :translated_value
+
+    ## ASSOCIATIONS
+    belongs_to :locale
+    belongs_to :localization_key
+    belongs_to :localization
+    belongs_to :source
+
+    unless defined?(::ActionController::StrongParameters)
+      attr_accessible
+    end
+
+    ## BEFORE & AFTER
+    before_create :set_localization_id
+
+    def get_value
+      translated_value
+    end
+
+    def full_key
+      [locale_str, localization_key_str].join('.')
+    end
+
+    def accept
+      if localization.present?
+        localization.translated_value = translated_value
+        localization.is_changed = true
+        localization.save
+      else
+        unless locale.present?
+          self.locale = Lit::Locale.where(locale: locale_str).first_or_create
+        end
+        unless localization_key.present?
+          self.localization_key = Lit::LocalizationKey.
+                where(localization_key: localization_key_str).
+                first_or_create
+        end
+        unless localization.present?
+          self.localization = Lit::Localization.
+                where(localization_key_id: self.localization_key.id).
+                where(locale_id: self.locale.id).
+                first_or_initialize
+          localization.translated_value = translated_value
+          localization.is_changed = true
+          localization.save!
+        end
+      end
+      Lit.init.cache.update_cache localization.full_key, localization.get_value
+      destroy
+    end
+
+    def is_duplicate?(val)
+      set_localization_id unless localization.present?
+      if localization
+        translated_value = localization.
+                read_attribute_before_type_cast('translated_value')
+        if localization.is_changed? && !translated_value.nil?
+          translated_value == val
+        else
+          localization.read_attribute_before_type_cast('default_value') == val
+        end
+      else
+        false
+      end
+    end
+
+    private
+
+    def set_localization_id
+      if locale.present? && localization_key.present?
+        self.localization = localization_key.localizations.where(locale_id: locale_id).first
+      end
+    end
+  end
+end

data/app/models/lit/locale.rb

@@ -0,0 +1,48 @@
+module Lit
+  class Locale < ActiveRecord::Base
+    ## SCOPES
+    scope :ordered, proc { order('locale ASC') }
+    scope :visible, proc { where(is_hidden: false) }
+
+    ## ASSOCIATIONS
+    has_many :localizations, dependent: :destroy
+
+    ## VALIDATIONS
+    validates :locale,
+              presence: true,
+              uniqueness: true
+
+    ## BEFORE & AFTER
+    after_save :reset_available_locales_cache
+    after_destroy :reset_available_locales_cache
+
+    unless defined?(::ActionController::StrongParameters)
+      ## ACCESSIBLE
+      attr_accessible :locale
+    end
+
+    def to_s
+      locale
+    end
+
+    def get_translated_percentage
+      total = get_all_localizations_count
+      total > 0 ? (get_changed_localizations_count * 100 / total) : 0
+    end
+
+    def get_changed_localizations_count
+      localizations.changed.count(:id)
+    end
+
+    def get_all_localizations_count
+      localizations.count(:id)
+    end
+
+    private
+
+    def reset_available_locales_cache
+      return unless I18n.backend.respond_to?(:reset_available_locales_cache)
+      I18n.backend.reset_available_locales_cache
+    end
+  end
+end

data/app/models/lit/localization.rb

@@ -0,0 +1,103 @@
+module Lit
+  class Localization < ActiveRecord::Base
+    serialize :translated_value
+    serialize :default_value
+
+    ## SCOPES
+    scope :changed, proc { where(is_changed: true) }
+    # @HACK: dirty, find a way to round date to full second
+    scope :after, proc { |dt|
+      where('updated_at >= ?', dt + 1.second)
+        .where('is_changed = true')
+    }
+
+    ## ASSOCIATIONS
+    belongs_to :locale
+    belongs_to :localization_key, touch: true
+    has_many :localization_versions, dependent: :destroy
+    has_many :versions, class_name: '::Lit::LocalizationVersion'
+
+    ## VALIDATIONS
+    validates :locale_id,
+              presence: true
+
+    unless defined?(::ActionController::StrongParameters)
+      ## ACCESSIBLE
+      attr_accessible :translated_value, :locale_id
+    end
+
+    ## BEFORE & AFTER
+    with_options if: :translated_value_changed? do |o|
+      o.before_update :update_should_mark_localization_key_completed
+      o.before_update :create_version
+    end
+    after_update :mark_localization_key_completed
+    after_commit :update_redis_version
+
+    def translated_value
+      read_attribute(:translated_value) || default_value
+    end
+
+    def update_redis_version
+      LIT_REDIS_VERSION.increment
+    end
+
+    def to_s
+      get_value
+    end
+
+    def full_key
+      [locale.locale, localization_key.localization_key].join('.')
+    end
+
+    def get_value
+      is_changed? && !translated_value.nil? ? translated_value : default_value
+    end
+
+    def value
+      get_value
+    end
+
+    def localization_key_str
+      localization_key.localization_key
+    end
+
+    def locale_str
+      locale.locale
+    end
+
+    def last_change
+      updated_at.to_s(:db)
+    end
+
+    def update_default_value(value)
+      return true if persisted? && default_value == value
+      if persisted?
+        update_column(:default_value, value)
+      else
+        self.default_value = value
+        save!
+      end
+    end
+
+    private
+
+    def update_should_mark_localization_key_completed
+      return if translated_value == translated_value_was
+      @should_mark_localization_key_completed = true
+    end
+
+    def mark_localization_key_completed
+      return if !instance_variable_defined?(:@should_mark_localization_key_completed) || \
+                @should_mark_localization_key_completed
+      localization_key.mark_completed!
+    end
+
+    def create_version
+      if translated_value.present?
+        l = localization_versions.new
+        l.translated_value = translated_value_was || default_value
+      end
+    end
+  end
+end