lit 0.3.3 → 0.4.0.pre.alpha

data/app/models/lit/localization_key.rb

@@ -3,11 +3,14 @@ module Lit
     attr_accessor :interpolated_key
 
     ## SCOPES
-    scope :completed, proc { where(is_completed: true) }
-    scope :not_completed, proc { where(is_completed: false) }
-    scope :starred, proc { where(is_starred: true) }
-    scope :ordered, proc { order('localization_key asc') }
-    scope :after, proc { |dt|
+    scope :completed, -> { where(is_completed: true) }
+    scope :not_completed, -> { where(is_completed: false) }
+    scope :starred, -> { where(is_starred: true) }
+    scope :ordered, -> { order(localization_key: :asc) }
+    scope :active, -> { where(is_deleted: false) }
+    scope :not_active, -> { where(is_deleted: true) }
+    scope :visited_again, -> { where(is_visited_again: true) }
+    scope :after, lambda { |dt|
       joins(:localizations)
         .where('lit_localization_keys.updated_at >= ?', dt)
         .where('lit_localizations.is_changed = true')
@@ -21,11 +24,14 @@ module Lit
               presence: true,
               uniqueness: { if: :localization_key_changed? }
 
+    ## ACCESSORS
     unless defined?(::ActionController::StrongParameters)
-      ## ACCESSIBLE
       attr_accessible :localization_key
     end
 
+    ## BEFORE AND AFTER
+    after_commit :check_completed, on: :update
+
     def to_s
       localization_key
     end
@@ -38,70 +44,55 @@ module Lit
           new_created = true
         end
       end
-      if new_created
-        Lit::LocalizationKey.update_all ['is_completed=?', false], ['id=? and is_completed=?', id, false]
-      end
-    end
-
-    def mark_completed
-      self.is_completed = localizations.changed.count(:id) == localizations.count
-    end
-
-    def mark_completed!
-      save if mark_completed
-    end
-
-    def mark_all_completed!
-      localizations.update_all(['is_changed=?', true])
-      mark_completed!
+      return unless new_created
+      Lit::LocalizationKey.update_all ['is_completed=?', false],
+                                      ['id=? and is_completed=?', id, false]
     end
 
     def self.order_options
-      ['localization_key asc', 'localization_key desc', 'created_at asc', 'created_at desc', 'updated_at asc', 'updated_at desc']
+      ['localization_key asc', 'localization_key desc', 'created_at asc',
+       'created_at desc', 'updated_at asc', 'updated_at desc']
     end
 
-    # it can be overridden in parent application, for example: {:order => "created_at desc"}
+    # it can be overridden in parent application,
+    # for example: {:order => "created_at desc"}
     def self.default_search_options
       {}
     end
 
     def self.search(options = {})
-      options = options.to_h.reverse_merge(default_search_options).with_indifferent_access
-      s = self
-      if options[:order] && order_options.include?(options[:order])
-        column, order = options[:order].split(' ')
-        s = s.order(FakeLocalizationKey.arel_table[column.to_sym].send(order.to_sym))
-      else
-        s = s.ordered
-      end
-      localization_key_col = FakeLocalizationKey.arel_table[:localization_key]
-      default_value_col = FakeLocalization.arel_table[:default_value]
-      translated_value_col = FakeLocalization.arel_table[:translated_value]
-      if options[:key_prefix].present?
-        q = "#{options[:key_prefix]}%"
-        s = s.where(localization_key_col.matches(q))
-      end
-      if options[:key].present?
-        q = "%#{options[:key]}%"
-        q_underscore = "%#{options[:key].parameterize.underscore}%"
-        cond = localization_key_col.matches(q).or(
-            default_value_col.matches(q).or(
-                translated_value_col.matches(q)
-            )
-        ).or(localization_key_col.matches(q_underscore))
-        s = s.joins([:localizations]).where(cond)
+      LocalizationKeySearchQuery.new(self, options).perform
+    end
+
+    def change_all_completed
+      self.class.transaction do
+        toggle(:is_completed).save!
+        localizations.update_all is_changed: is_completed
       end
-      unless options[:include_completed].to_i == 1
-        s = s.not_completed
+    end
+
+    def soft_destroy
+      ActiveRecord::Base.transaction do
+        update is_deleted: true
+        change_all_completed
+        I18n.backend.available_locales.each do |l|
+          Lit.init.cache.delete_key "#{l}.#{localization_key}"
+        end
       end
-      s
     end
 
-    class FakeLocalizationKey < ActiveRecord::Base
-      self.table_name = 'lit_localization_keys'
+    def restore
+      ActiveRecord::Base.transaction do
+        update is_deleted: false, is_completed: false, is_visited_again: false
+        localizations.update_all is_changed: false
+      end
     end
-    class FakeLocalization < ActiveRecord::Base
-      self.table_name = 'lit_localizations'
+
+    private
+
+    def check_completed
+      self.is_completed = localizations.changed.count == localizations.count
+      save! if is_completed_changed?
     end
   end
 end

data/app/models/lit/source.rb

@@ -1,10 +1,10 @@
 require 'net/http'
 module Lit
   class Source < ActiveRecord::Base
-    LOCALES_PATH = '/api/v1/locales.json'
-    LOCALIZATION_KEYS_PATH = '/api/v1/localization_keys.json'
-    LOCALIZATIONS_PATH = '/api/v1/localizations.json'
-    LAST_CHANGE_PATH = '/api/v1/last_change.json'
+    LOCALES_PATH = '/api/v1/locales.json'.freeze
+    LOCALIZATION_KEYS_PATH = '/api/v1/localization_keys.json'.freeze
+    LOCALIZATIONS_PATH = '/api/v1/localizations.json'.freeze
+    LAST_CHANGE_PATH = '/api/v1/last_change.json'.freeze
 
     ## ASSOCIATIONS
     has_many :incomming_localizations
@@ -13,8 +13,9 @@ module Lit
     validates :api_key, :identifier, :url,
               presence: true
     validates :url,
-              format: { with: /\Ahttps?:\/\/.*\/.*[^\/]\Z/i }
+              format: { with: %r{\Ahttps?://.*/.*[^/]\Z}i }
 
+    ## ACCESSORS
     unless defined?(::ActionController::StrongParameters)
       attr_accessible :api_key, :identifier, :url
     end
@@ -23,89 +24,31 @@ module Lit
     before_create :set_last_updated_at_upon_creation
     after_validation :check_if_url_is_valid
 
-    def get_last_change
-      result = get_from_remote(LAST_CHANGE_PATH)
+    def last_change
+      result = RemoteInteractorService.new(self).send_request(LAST_CHANGE_PATH)
       result['last_change'] unless result.nil?
     end
 
-    def synchronize
-      after = last_updated_at.nil? ? nil : last_updated_at.to_s(:db)
-      result = get_from_remote(LOCALIZATIONS_PATH, after: after)
-      unless result.nil?
-        if result.is_a?(Array)
-          result.each do |r|
-            il = IncommingLocalization.new
-            if ::Rails::VERSION::MAJOR < 4
-              il = IncommingLocalization.where(incomming_id: r['id']).first_or_initialize
-            else
-              il = IncommingLocalization.find_or_initialize_by(incomming_id: r['id'])
-            end
-            il.source = self
-            il.locale_str = r['locale_str']
-            il.locale = Locale.where(locale: il.locale_str).first
-            il.localization_key_str = r['localization_key_str']
-            il.localization_key = LocalizationKey.where(localization_key: il.localization_key_str).first
-            unless il.is_duplicate?(r['value'])
-              il.save!
-              IncommingLocalization.where(id: il.id).
-                update_all(translated_value: r['value'])
-            end
-          end
-          last_change = get_last_change
-          last_change = DateTime.parse(last_change) unless last_change.nil?
-          touch_last_updated_at(last_change)
-          update_column(:sync_complete, true)
-          save
-        end
-      end
-    end
-
     def touch_last_updated_at!
-      touch_last_updated_at
+      assign_last_updated_at
       save
     end
 
-    private
-
-    def touch_last_updated_at(time = nil)
+    def assign_last_updated_at(time = nil)
       self.last_updated_at = time || Time.now
     end
 
-    def check_if_url_is_valid
-      if errors.empty? && (self.new_record? || self.url_changed?)
-        errors.add(:url, 'is not accessible') if get_last_change.nil?
-      end
-    end
+    private
 
-    def get_from_remote(path, query_values = {})
-      result = nil
-      begin
-        uri = URI(url + path)
-        query_values.each do |k, v|
-          params = URI.decode_www_form(uri.query || '') << [k, v]
-          uri.query = URI.encode_www_form(params)
-        end
-        req = Net::HTTP::Get.new(uri.request_uri)
-        req.add_field('Authorization', %(Token token="#{api_key}"))
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.port == 443)
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        res = http.start do |http_started|
-          http_started.request(req)
-        end
-        if res.is_a?(Net::HTTPSuccess)
-          result = JSON.parse(res.body)
-        end
-      rescue => e
-        ::Rails.logger.error { "Lit remote error: #{e}" } if defined?(Rails)
-      end
-      result
+    def check_if_url_is_valid
+      return if errors.present? || !(new_record? || url_changed?) ||
+                last_change.present?
+      errors.add :url, 'is not accessible'
     end
 
     def set_last_updated_at_upon_creation
-      if last_updated_at.blank?
-        touch_last_updated_at if Lit.set_last_updated_at_upon_creation
-      end
+      return if last_updated_at.blank? && !Lit.set_last_updated_at_upon_creation
+      assign_last_updated_at
     end
   end
 end

data/app/queries/localization_key_search_query.rb

@@ -0,0 +1,80 @@
+class LocalizationKeySearchQuery
+  def initialize(scope, params = {})
+    @scope = scope
+    @params = params.to_h
+                    .reverse_merge(@scope.default_search_options)
+                    .with_indifferent_access
+  end
+
+  def perform
+    order_data
+    search_key_prefix
+    search_key
+    search_completed
+    @scope
+  end
+
+  private
+
+  def order_data
+    if @params[:order] && order_options.include?(@params[:order])
+      column, order = @params[:order].split(' ')
+      @scope = @scope.order(
+        localization_key_arel[column.to_sym].send(order.to_sym)
+      )
+    else
+      @scope = @scope.ordered
+    end
+  end
+
+  def search_key_prefix
+    return if @params[:key_prefix].blank?
+    q = Arel::Nodes.build_quoted("#{@params[:key_prefix]}%")
+    @scope = @scope.where(localization_key_col.matches(q))
+  end
+
+  def search_key
+    return if @params[:key].blank?
+    q = Arel::Nodes.build_quoted("%#{@params[:key]}%")
+    q_underscore = Arel::Nodes.build_quoted("%#{@params[:key].parameterize.underscore}%")
+    cond = search_key_conditions(q, q_underscore)
+    @scope = @scope.joins([:localizations]).where(cond)
+  end
+
+  def search_key_conditions(query, q_underscore)
+    localization_key_col.matches(query).or(
+      default_value_col.matches(query).or(
+        translated_value_col.matches(query)
+      )
+    ).or(localization_key_col.matches(q_underscore))
+  end
+
+  def search_completed
+    return if @params[:include_completed].to_i != 1
+    @scope = @scope.not_completed
+  end
+
+  def localization_key_col
+    localization_key_arel[:localization_key]
+  end
+
+  def default_value_col
+    localization_arel[:default_value]
+  end
+
+  def translated_value_col
+    localization_arel[:translated_value]
+  end
+
+  def localization_key_arel
+    Arel::Table.new 'lit_localization_keys'
+  end
+
+  def localization_arel
+    Arel::Table.new 'lit_localizations'
+  end
+
+  def order_options
+    Lit::LocalizationKey.order_options
+  end
+end

data/app/services/remote_interactor_service.rb

@@ -0,0 +1,45 @@
+class RemoteInteractorService
+  def initialize(source)
+    @source = source
+  end
+
+  def send_request(path, query_values = {})
+    uri = initialize_uri(path, query_values)
+    req = initialize_request(uri)
+    connection = initialize_connection(uri)
+    perform_request(connection, req)
+  rescue => e
+    return unless defined?(Rails)
+    ::Rails.logger.error { "Lit remote error: #{e}" }
+  end
+
+  private
+
+  def initialize_uri(path, query_values)
+    uri = URI(@source.url + path)
+    query_values.each do |k, v|
+      params = URI.decode_www_form(uri.query || '') << [k, v]
+      uri.query = URI.encode_www_form(params)
+    end
+    uri
+  end
+
+  def initialize_request(uri)
+    req = Net::HTTP::Get.new(uri.request_uri)
+    req.add_field('Authorization', %(Token token="#{@source.api_key}"))
+    req
+  end
+
+  def initialize_connection(uri)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = (uri.port == 443)
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    http
+  end
+
+  def perform_request(connection, request)
+    res = connection.start { |http| http.request(request) }
+    return res unless res.is_a?(Net::HTTPSuccess)
+    JSON.parse(res.body)
+  end
+end

data/app/services/synchronize_source_service.rb

@@ -0,0 +1,63 @@
+class SynchronizeSourceService
+  def initialize(source)
+    @source = source
+  end
+
+  def execute
+    synchronize_localizations
+    update_timestamps
+  end
+
+  private
+
+  def synchronize_localizations
+    after_date = @source.last_updated_at&.to_s(:db)
+    result = interactor.send_request Lit::Source::LOCALIZATIONS_PATH,
+                                     after: after_date
+    return unless result&.is_a?(Array)
+    result.each { |loc| synchronize_localization loc }
+  end
+
+  def synchronize_localization(loc)
+    inc_loc = find_incomming_localization(loc)
+    inc_loc.source = @source
+    inc_loc.locale_str = loc['locale_str']
+    inc_loc.locale = Lit::Locale.find_by(locale: loc['locale_str'])
+    inc_loc.localization_key_str = loc['localization_key_str']
+    inc_loc.localization_key_is_deleted = localization_key_deleted?(loc)
+    inc_loc.localization_key = find_localization_key(inc_loc)
+    inc_loc.translated_value = loc['value']
+    return if inc_loc.duplicated?(loc['value'])
+    inc_loc.save!
+  end
+
+  def find_incomming_localization(localization)
+    Lit::IncommingLocalization.find_or_initialize_by(
+      incomming_id: localization['id']
+    )
+  end
+
+  def find_localization_key(inc_loc)
+    Lit::LocalizationKey.find_by(
+      localization_key: inc_loc.localization_key_str
+    )
+  end
+
+  def localization_key_deleted?(loc)
+    loc['localization_key_is_deleted'] || false
+  end
+
+  def update_timestamps
+    @source.assign_last_updated_at(fetch_last_change)
+    @source.sync_complete = true
+    @source.save!
+  end
+
+  def fetch_last_change
+    interactor.send_request(Lit::Source::LAST_CHANGE_PATH)['last_change']
+  end
+
+  def interactor
+    RemoteInteractorService.new(@source)
+  end
+end