lit 0.3.3 → 0.4.0.pre.alpha

data/app/controllers/lit/localizations_controller.rb

@@ -4,46 +4,51 @@ module Lit
     before_action :find_localization
 
     def show
-      render json: { value: @localization.get_value }
+      render json: { value: @localization.translation }
     end
 
     def edit
-      @localization.translated_value = @localization.get_value
+      @localization.translated_value = @localization.translation
       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
+      after_update_operations if @localization.update_attributes(clear_params)
       respond_to do |f|
         f.js
         f.json do
-          render json: { value: @localization.get_value }
+          render json: { value: @localization.reload.translation }
         end
       end
     end
 
+    def change_completed
+      @localization.toggle(:is_changed).save!
+      respond_to :js
+    end
+
     def previous_versions
-      @versions = @localization.versions.order('created_at DESC')
+      @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])
+      @localization_key =
+        Lit::LocalizationKey.active.find(params[:localization_key_id])
     end
 
     def find_localization
       @localization = @localization_key.localizations.find(params[:id])
     end
 
+    def after_update_operations
+      @localization.update_column :is_changed, true
+    end
+
     def clear_params
       if params.respond_to?(:permit)
         # allow translated_value to be an array

data/app/controllers/lit/sources_controller.rb

@@ -2,37 +2,32 @@ require_dependency 'lit/application_controller'
 
 module Lit
   class SourcesController < ApplicationController
+    before_action :find_source, except: %i[index new create]
     def index
       @sources = Source.all
     end
 
-    def show
-      @source = Source.find(params[:id])
-    end
+    def show; end
 
     def new
       @source = Source.new
     end
 
-    def edit
-      @source = Source.find(params[:id])
-    end
+    def edit; end
 
     def synchronize
-      @source = Source.find(params[:id])
       @source.update_column(:sync_complete, false)
       if defined?(ActiveJob)
         SynchronizeSourceJob.perform_later(@source)
       else
-        @source.synchronize
+        SynchronizeSourceService.new(@source).execute
       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
+      redirect_to_back_or_default fallback_location: source_path(@source)
     end
 
     def create
@@ -45,7 +40,6 @@ module Lit
     end
 
     def update
-      @source = Source.find(params[:id])
       if @source.update_attributes(clear_params)
         redirect_to @source, notice: 'Source was successfully updated.'
       else
@@ -54,18 +48,20 @@ module Lit
     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 find_source
+      @source = Source.find(params[:id])
+    end
+
     def clear_params
       if defined?(::ActionController::StrongParameters)
         params.require(:source).permit(:identifier, :url, :api_key)

data/app/helpers/lit/frontend_helper.rb

@@ -1,15 +1,26 @@
 module Lit
   module FrontendHelper
     include ActionView::Helpers::TranslationHelper
+
     module TranslationKeyWrapper
       def translate(key, options = {})
+        count = options[:count]
         options = options.with_indifferent_access
         key = scope_key_by_partial(key)
-        ret = super(key, options)
+        key = pluralized_key(key, count) if count
+
+        content = super(key, options)
         if !options[:skip_lit] && lit_authorized?
-          ret = get_translateable_span(key, ret)
+          content = get_translateable_span(key, content)
         end
-        ret
+        content
+      end
+
+      def pluralized_key(key, count)
+        pluralizer = I18n.backend.send(:pluralizer, locale)
+        return unless pluralizer.respond_to?(:call)
+        last = count.zero? ? :zero : pluralizer.call(count)
+        format '%<key>s.%<last>s', key: key, last: last
       end
 
       def t(key, options = {})
@@ -32,7 +43,7 @@ module Lit
                          '',
                          value: lit.find_localization_localization_keys_path,
                          name: 'lit-url-base'
-      safe_join([javascript_lit_tag, stylesheet_lit_tag, meta])
+      safe_join [javascript_lit_tag, stylesheet_lit_tag, meta]
     end
 
     def lit_translations_info
@@ -41,23 +52,24 @@ module Lit
       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)
+        concat translations_list_content_tag
+      end
+    end
+
+    def translations_list_content_tag
+      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
+      return false if Lit.authentication_verification.blank?
+      send Lit.authentication_verification
     end
 
     def get_translateable_span(key, localization, alternative_text: nil)

data/app/helpers/lit/localizations_helper.rb

@@ -1,7 +1,8 @@
 module Lit
   module LocalizationsHelper
     def draw_icon(icon, opts = {})
-      raw("<i class=\"fa fa-#{icon} #{opts[:class]}\" title=\"#{opts[:title]}\" ></i>")
+      raw "<i class=\"fa fa-#{icon} #{opts[:class]}\" " \
+          "title=\"#{opts[:title]}\" ></i>"
     end
 
     def ejs(val)

data/app/jobs/lit/synchronize_source_job.rb

@@ -4,7 +4,7 @@ module Lit
       queue_as :default
 
       def perform(source)
-        source.synchronize
+        SynchronizeSourceService.new(source).execute
       end
     end
   end

data/app/models/lit/incomming_localization.rb

@@ -8,14 +8,13 @@ module Lit
     belongs_to :localization
     belongs_to :source
 
-    unless defined?(::ActionController::StrongParameters)
-      attr_accessible
-    end
+    ## ACCESSORS
+    attr_accessible unless defined?(::ActionController::StrongParameters)
 
     ## BEFORE & AFTER
-    before_create :set_localization_id
+    before_validation :set_localization, on: :create
 
-    def get_value
+    def translation
       translated_value
     end
 
@@ -25,53 +24,84 @@ module Lit
 
     def accept
       if localization.present?
-        localization.translated_value = translated_value
-        localization.is_changed = true
-        localization.save
+        update_existing_localization_data
+        update_existing_localization_key_data
       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
+        assign_new_localization_data
       end
-      Lit.init.cache.update_cache localization.full_key, localization.get_value
+      update_cache
       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
+    def duplicated?(val)
+      set_localization
+      return false if localization_has_changed?
+      translated_value =
+        localization.read_attribute_before_type_cast('translated_value')
+      if localization.is_changed? && !translated_value.nil?
+        translated_value == val
       else
-        false
+        localization.read_attribute_before_type_cast('default_value') == val
       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
+    def set_localization
+      return if locale.blank? || localization_key.blank?
+      self.localization = localization_key.localizations
+                                          .find_by(locale_id: locale_id)
+    end
+
+    def localization_has_changed?
+      localization.blank? ||
+        localization.is_deleted != localization_key_is_deleted
+    end
+
+    def update_existing_localization_data
+      localization.update_attributes!(
+        translated_value: translated_value,
+        is_changed: true
+      )
+    end
+
+    def update_existing_localization_key_data
+      localization_key.update_attributes!(
+        is_deleted: localization_key_is_deleted
+      )
+    end
+
+    def assign_new_localization_data
+      assign_new_locale unless locale.present?
+      assign_new_localization_key unless localization_key.present?
+      assign_new_localization unless localization.present?
+    end
+
+    def assign_new_locale
+      self.locale = Lit::Locale.where(locale: locale_str).first_or_create
+    end
+
+    def assign_new_localization_key
+      self.localization_key =
+        Lit::LocalizationKey.where(
+          localization_key: localization_key_str,
+          is_deleted: localization_key_is_deleted
+        ).first_or_create!
+    end
+
+    def assign_new_localization
+      self.localization =
+        Lit::Localization.where(localization_key_id: localization_key.id)
+                         .where(locale_id: locale.id)
+                         .first_or_initialize
+      localization.translated_value = translated_value
+      localization.is_changed = true
+      localization.save!
+    end
+
+    def update_cache
+      Lit.init.cache.update_cache localization.full_key,
+                                  localization.translation
     end
   end
 end

data/app/models/lit/locale.rb

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

data/app/models/lit/localization.rb

@@ -4,11 +4,16 @@ module Lit
     serialize :default_value
 
     ## SCOPES
-    scope :changed, proc { where(is_changed: true) }
+    scope :changed, -> { where is_changed: true }
+    scope :not_changed, -> { where is_changed: false }
     # @HACK: dirty, find a way to round date to full second
-    scope :after, proc { |dt|
+    scope :after, lambda { |dt|
       where('updated_at >= ?', dt + 1.second)
-        .where('is_changed = true')
+        .where(is_changed: true)
+    }
+    scope :active, lambda {
+      joins(:localization_key)
+        .where(Lit::LocalizationKey.table_name => { is_deleted: false })
     }
 
     ## ASSOCIATIONS
@@ -17,42 +22,47 @@ module Lit
     has_many :localization_versions, dependent: :destroy
     has_many :versions, class_name: '::Lit::LocalizationVersion'
 
+    ## DELEGATIONS
+    delegate :is_deleted, to: :localization_key
+
     ## VALIDATIONS
-    validates :locale_id,
-              presence: true
+    validates :locale, presence: true
 
+    ## ACCESSORS
     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_cache, on: :update
 
     def to_s
-      get_value
+      translation
     end
 
     def full_key
       [locale.locale, localization_key.localization_key].join('.')
     end
 
-    def get_value
+    def translation
       is_changed? && !translated_value.nil? ? translated_value : default_value
     end
 
     def value
-      get_value
+      translation
     end
 
     def localization_key_str
       localization_key.localization_key
     end
 
+    def localization_key_is_deleted
+      localization_key.is_deleted
+    end
+
     def locale_str
       locale.locale
     end
@@ -73,22 +83,14 @@ module Lit
 
     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!
+    def update_cache
+      Lit.init.cache.update_cache full_key, translation
     end
 
     def create_version
-      if translated_value.present?
-        l = localization_versions.new
-        l.translated_value = translated_value_was || default_value
-      end
+      return if translated_value.blank?
+      translated_value = translated_value_was || default_value
+      localization_versions.new(translated_value: translated_value)
     end
   end
 end