lit 0.2.4 → 0.2.5

data/app/helpers/lit/application_helper.rb

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

data/app/helpers/lit/localizations_helper.rb

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

data/app/models/lit/incomming_localization.rb

@@ -15,45 +15,47 @@ module Lit
     ## BEFORE & AFTER
     before_create :set_localization_id
 
-
     def get_value
-      self.translated_value
+      translated_value
     end
 
     def full_key
-      [self.locale_str, self.localization_key_str].join('.')
+      [locale_str, localization_key_str].join('.')
     end
 
     def accept
-      if self.localization.present?
-        self.localization.translated_value = self.translated_value
-        self.localization.save
+      if localization.present?
+        localization.translated_value = translated_value
+        localization.is_changed = true
+        localization.save
       else
-        unless self.locale.present?
-          self.locale = Lit::Locale.new
-          self.locale.locale = self.locale_str
-          self.locale.save!
+        unless locale.present?
+          self.locale = Lit::Locale.where(locale: locale_str).first_or_create
         end
-        unless self.localization_key.present?
-          self.localization_key = Lit::LocalizationKey.new
-          self.localization_key.localization_key = self.localization_key_str
-          self.localization_key.save!
+        unless localization_key.present?
+          self.localization_key = Lit::LocalizationKey.
+                where(localization_key: localization_key_str).
+                first_or_create
         end
-        unless self.localization.present?
-          self.localization = Lit::Localization.new
-          self.localization.locale = self.locale
-          self.localization.localization_key = self.localization_key
-          self.localization.default_value = self.translated_value
-          self.localization.save!
+        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
-      self.destroy
+      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')
+        translated_value = localization.
+                read_attribute_before_type_cast('translated_value')
         if localization.is_changed? && !translated_value.nil?
           translated_value == val
         else
@@ -65,10 +67,11 @@ module Lit
     end
 
     private
-      def set_localization_id
-        if self.locale.present? and self.localization_key.present?
-          self.localization = self.localization_key.localizations.where(:locale_id=>self.locale_id).first
-        end
+
+    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

@@ -1,17 +1,20 @@
 module Lit
   class Locale < ActiveRecord::Base
-
     ## SCOPES
-    scope :ordered, proc{ order('locale ASC') }
-    scope :visible, proc{ where(:is_hidden=>false) }
+    scope :ordered, proc { order('locale ASC') }
+    scope :visible, proc { where(is_hidden: false) }
 
     ## ASSOCIATIONS
-    has_many :localizations, :dependent=>:destroy
+    has_many :localizations, dependent: :destroy
 
     ## VALIDATIONS
     validates :locale,
-              :presence=>true,
-              :uniqueness=>true
+              presence: true,
+              uniqueness: true
+
+    ## BEFORE & AFTER
+    after_save :reset_available_locales_cache
+    after_destroy :reset_available_locales_cache
 
     unless defined?(::ActionController::StrongParameters)
       ## ACCESSIBLE
@@ -19,20 +22,27 @@ module Lit
     end
 
     def to_s
-      self.locale
+      locale
     end
 
     def get_translated_percentage
-      total = self.get_all_localizations_count
-      total > 0 ? (self.get_changed_localizations_count * 100 / total) : 0
+      total = get_all_localizations_count
+      total > 0 ? (get_changed_localizations_count * 100 / total) : 0
     end
 
     def get_changed_localizations_count
-      self.localizations.changed.count(:id)
+      localizations.changed.count(:id)
     end
 
     def get_all_localizations_count
-      self.localizations.count(:id)
+      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

@@ -4,19 +4,19 @@ module Lit
     serialize :default_value
 
     ## SCOPES
-    scope :changed, proc{ where(:is_changed=>true) }
+    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) }
+    scope :after, proc { |dt| where('updated_at >= ?', dt + 1.second) }
 
     ## ASSOCIATIONS
     belongs_to :locale
-    belongs_to :localization_key
+    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
+              presence: true
 
     unless defined?(::ActionController::StrongParameters)
       ## ACCESSIBLE
@@ -24,22 +24,22 @@ module Lit
     end
 
     ## BEFORE & AFTER
-    with_options :if=>:translated_value_changed? do |o|
-      o.before_update :update_is_changed
+    with_options if: :translated_value_changed? do |o|
+      o.before_update :update_is_changed_attribute
       o.before_update :create_version
     end
     after_update :mark_localization_key_completed
 
     def to_s
-      self.get_value
+      get_value
     end
 
     def full_key
-      [self.locale.locale, self.localization_key.localization_key].join('.')
+      [locale.locale, localization_key.localization_key].join('.')
     end
 
     def get_value
-      (is_changed? && (not self.translated_value.nil?)) ? self.translated_value : self.default_value
+      (is_changed? && (!translated_value.nil?)) ? translated_value : default_value
     end
 
     def value
@@ -47,15 +47,15 @@ module Lit
     end
 
     def localization_key_str
-      self.localization_key.localization_key
+      localization_key.localization_key
     end
 
     def locale_str
-      self.locale.locale
+      locale.locale
     end
 
     def last_change
-      self.updated_at.to_s(:db)
+      updated_at.to_s(:db)
     end
 
     def update_default_value(value)
@@ -65,22 +65,23 @@ module Lit
     end
 
     private
-      def update_is_changed
-        unless is_changed?
-          self.is_changed = true
-          @should_mark_localization_key_completed = true
-        end
-      end
 
-      def mark_localization_key_completed
-        self.localization_key.mark_completed! if @should_mark_localization_key_completed
-      end
+    def update_is_changed_attribute
+      return if attributes['is_changed'] == true
+
+      self[:is_changed] = true
+      @should_mark_localization_key_completed = true
+    end
+
+    def mark_localization_key_completed
+      localization_key.mark_completed! if @should_mark_localization_key_completed
+    end
 
-      def create_version
-        if self.translated_value.present?
-          l = self.localization_versions.new
-          l.translated_value = self.translated_value_was || self.default_value
-        end
+    def create_version
+      if translated_value.present?
+        l = localization_versions.new
+        l.translated_value = translated_value_was || default_value
       end
+    end
   end
 end

data/app/models/lit/localization_key.rb

@@ -3,19 +3,19 @@ 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| where('updated_at >= ?', dt) }
+    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| where('updated_at >= ?', dt) }
 
     ## ASSOCIATIONS
-    has_many :localizations, :dependent=>:destroy
+    has_many :localizations, dependent: :destroy
 
     ## VALIDATIONS
     validates :localization_key,
-              :presence=>true,
-              :uniqueness=>{:if=>:localization_key_changed?}
+              presence: true,
+              uniqueness: { if: :localization_key_changed? }
 
     unless defined?(::ActionController::StrongParameters)
       ## ACCESSIBLE
@@ -23,37 +23,37 @@ module Lit
     end
 
     def to_s
-      self.localization_key
+      localization_key
     end
 
     def clone_localizations
       new_created = false
       Lit::Locale.find_each do |locale|
-        self.localizations.where(:locale_id=>locale.id).first_or_create do |l|
+        localizations.where(locale_id: locale.id).first_or_create do |l|
           l.default_value = interpolated_key
           new_created = true
         end
       end
       if new_created
-        Lit::LocalizationKey.update_all ['is_completed=?', false], ['id=? and is_completed=?', self.id, false]
+        Lit::LocalizationKey.update_all ['is_completed=?', false], ['id=? and is_completed=?', id, false]
       end
     end
 
     def mark_completed
-      self.is_completed = self.localizations.changed.count(:id) == self.localizations.count
+      self.is_completed = localizations.changed.count(:id) == localizations.count
     end
 
     def mark_completed!
-      self.save if self.mark_completed
+      save if mark_completed
     end
 
     def mark_all_completed!
-      self.localizations.update_all(['is_changed=?', true])
+      localizations.update_all(['is_changed=?', true])
       mark_completed!
     end
 
     def self.order_options
-      ["localization_key asc", "localization_key desc", "created_at asc", "created_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"}
@@ -61,12 +61,12 @@ module Lit
       {}
     end
 
-    def self.search(options={})
+    def self.search(options = {})
       options = options.reverse_merge(default_search_options)
       s = self
       if options[:order] && order_options.include?(options[:order])
-        column, order = options[:order].split(" ")
-        s = s.order("#{Lit::LocalizationKey.quoted_table_name}.#{connection.quote_column_name(column)} #{order}" )
+        column, order = options[:order].split(' ')
+        s = s.order("#{Lit::LocalizationKey.quoted_table_name}.#{connection.quote_column_name(column)} #{order}")
       else
         s = s.ordered
       end
@@ -86,11 +86,10 @@ module Lit
         )
         s = s.joins([:localizations]).where(cond)
       end
-      if not options[:include_completed].to_i==1
+      unless options[:include_completed].to_i == 1
         s = s.not_completed
       end
       s
     end
-
   end
 end

data/app/models/lit/localization_version.rb

@@ -6,7 +6,7 @@ module Lit
     belongs_to :localization
 
     def to_s
-      self.translated_value
+      translated_value
     end
   end
 end

data/app/models/lit/source.rb

@@ -1,19 +1,19 @@
 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'
+    LOCALIZATION_KEYS_PATH = '/api/v1/localization_keys.json'
+    LOCALIZATIONS_PATH = '/api/v1/localizations.json'
+    LAST_CHANGE_PATH = '/api/v1/last_change.json'
 
     ## ASSOCIATIONS
     has_many :incomming_localizations
 
     ## VALIDATIONS
     validates :api_key, :identifier, :url,
-              :presence=>true
+              presence: true
     validates :url,
-              :format=>{:with=>/\Ahttps?:\/\/.*\/.*[^\/]\Z/i}
+              format: { with: /\Ahttps?:\/\/.*\/.*[^\/]\Z/i }
 
     unless defined?(::ActionController::StrongParameters)
       attr_accessible :api_key, :identifier, :url
@@ -23,33 +23,32 @@ 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)
-      result["last_change"] unless result.nil?
+      result['last_change'] unless result.nil?
     end
 
     def synchronize
-      after = self.last_updated_at.nil? ? nil : self.last_updated_at.to_s(:db)
-      result = get_from_remote(LOCALIZATIONS_PATH, {:after=>after})
+      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
+              il = IncommingLocalization.where(incomming_id: r['id']).first_or_initialize
             else
-              il = IncommingLocalization.find_or_initialize_by(:incomming_id=>r["id"])
+              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
+            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"]]
+              IncommingLocalization.where(id: il.id).
+                update_all ['translated_value=?', r['value']]
             end
           end
           last_change = get_last_change
@@ -66,41 +65,46 @@ module Lit
     end
 
     private
-      def touch_last_updated_at(time=nil)
-        self.last_updated_at = time || Time.now
-      end
 
-      def check_if_url_is_valid
-        if self.errors.empty? && (self.new_record? || self.url_changed?)
-            self.errors.add(:url, "is not accessible") if get_last_change.nil?
-        end
+    def touch_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
 
-      def get_from_remote(path, query_values={})
-        result = nil
-        begin
-          uri = URI(self.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="#{self.api_key}"))
-          res = Net::HTTP.new(uri.host, uri.port).start do |http|
-            http.request(req)
-          end
-          if res.is_a?(Net::HTTPSuccess)
-            result = JSON.parse(res.body)
-          end
-        rescue
+    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|
+          http.request(req)
+        end
+        if res.is_a?(Net::HTTPSuccess)
+          result = JSON.parse(res.body)
         end
-        result
+      rescue => e
+        ::Rails.logger.error { "Lit remote error: #{e}" } if defined?(Rails)
       end
+      result
+    end
 
-      def set_last_updated_at_upon_creation
-        if self.last_updated_at.blank?
-          touch_last_updated_at if Lit.set_last_updated_at_upon_creation
-        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
+    end
   end
 end