tolk 1.2.0 → 2.0.0

data/app/controllers/tolk/searches_controller.rb

@@ -1,15 +1,15 @@
 module Tolk
   class SearchesController < Tolk::ApplicationController
-    before_filter :find_locale
+    before_action :find_locale
   
     def show
-      @phrases = @locale.search_phrases(params[:q], params[:scope].to_sym, params[:k], params[:page])
+      @phrases = @locale.search_phrases(params[:q], params[:scope].to_sym, params[:k], params[pagination_param])
     end
 
     private
 
     def find_locale
-      @locale = Tolk::Locale.find_by_name!(params[:locale])
+      @locale = Tolk::Locale.where('UPPER(name) = UPPER(?)', params[:tolk_locale]).first!
     end
   end
 end

data/app/helpers/tolk/application_helper.rb

@@ -1,27 +1,43 @@
 module Tolk
   module ApplicationHelper
+    include Tolk::Pagination::ViewHelper
+
     def format_i18n_value(value)
-      h(yaml_value(value)).gsub(/\n/, '<br />')
+      value = h(yaml_value(value))
+      value = highlight_linebreaks(value)
+      value = highligh_interpolations(value)
+    end
+
+    def highlight_linebreaks(value)
+      value.gsub(/\n/, '<span class="carriage_return" title="Line break"><br /></span>').html_safe
+    end
+
+    def highligh_interpolations(value)
+      value.gsub(/%{\w+}/, '<span class="interpolation" title="Leave this word untranslated">\0</span>').html_safe
     end
 
     def format_i18n_text_area_value(value)
-      yaml_value(value)
+      yaml_value(value).to_s.force_encoding("UTF-8")
     end
 
     def yaml_value(value)
       if value.present?
-        unless value.is_a?(String)
-          value = value.respond_to?(:ya2yaml) ? value.ya2yaml(:syck_compatible => true) : value.to_yaml
+        unless value.is_a?(String) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          value = Tolk::YAML.dump(value)
         end
       end
-      
+
       value
     end
 
+    def boolean_warning
+      '<span class="boolean">(Do not translate -- Enter true or false)</span>'.html_safe
+    end
+
     def tolk_locale_selection
       existing_locale_names = Tolk::Locale.all.map(&:name)
 
-      pairs = Tolk::Locale::MAPPING.to_a.map(&:reverse).sort_by(&:first)
+      pairs = Tolk.config.mapping.to_a.map(&:reverse).sort_by(&:first)
       pairs.reject {|pair| existing_locale_names.include?(pair.last) }
     end
 

data/app/models/tolk/locale.rb

@@ -1,55 +1,16 @@
+require 'tolk/config'
+require 'tolk/pagination'
+
 module Tolk
   class Locale < ActiveRecord::Base
+    include Tolk::Pagination::Methods
+
     self.table_name = "tolk_locales"
 
-    MAPPING = {
-      'ar'    => 'Arabic',
-      'bs'    => 'Bosnian',
-      'bt'    => 'Bulgarian',
-      'ca'    => 'Catalan',
-      'cz'    => 'Czech',
-      'da'    => 'Danish',
-      'de'    => 'German',
-      'dsb'   => 'Lower Sorbian',
-      'el'    => 'Greek',
-      'en'    => 'English',
-      'es'    => 'Spanish',
-      'et'    => 'Estonian',
-      'fa'    => 'Persian',
-      'fi'    => 'Finnish',
-      'fr'    => 'French',
-      'he'    => 'Hebrew',
-      'hr'    => 'Croatian',
-      'hsb'   => 'Upper Sorbian',
-      'hu'    => 'Hungarian',
-      'id'    => 'Indonesian',
-      'is'    => 'Icelandic',
-      'it'    => 'Italian',
-      'jp'    => 'Japanese',
-      'ko'    => 'Korean',
-      'lo'    => 'Lao',
-      'lt'    => 'Lithuanian',
-      'lv'    => 'Latvian',
-      'mk'    => 'Macedonian',
-      'nl'    => 'Dutch',
-      'no'    => 'Norwegian',
-      'pl'    => 'Polish',
-      'pt-br' => 'Portuguese (Brazilian)',
-      'pt-PT' => 'Portuguese (Portugal)',
-      'ro'    => 'Romanian',
-      'ru'    => 'Russian',
-      'se'    => 'Swedish',
-      'sk'    => 'Slovak',
-      'sl'    => 'Slovenian',
-      'sr'    => 'Serbian',
-      'sw'    => 'Swahili',
-      'th'    => 'Thai',
-      'tr'    => 'Turkish',
-      'uk'    => 'Ukrainian',
-      'vi'    => 'Vietnamese',
-      'zh-CN' => 'Chinese (Simplified)',
-      'zh-TW' => 'Chinese (Traditional)'
-    }
+    def self._dump_path
+      # Necessary to acces rails.root at runtime !
+      @dump_path ||= Tolk.config.dump_path.is_a?(Proc) ? instance_eval(&Tolk.config.dump_path) : Tolk.config.dump_path
+    end
 
     has_many :phrases, :through => :translations, :class_name => 'Tolk::Phrase'
     has_many :translations, :class_name => 'Tolk::Translation', :dependent => :destroy
@@ -57,12 +18,11 @@ module Tolk
     accepts_nested_attributes_for :translations, :reject_if => proc { |attributes| attributes['text'].blank? }
     before_validation :remove_invalid_translations_from_target, :on => :update
 
-    attr_accessible :name
     cattr_accessor :locales_config_path
-    self.locales_config_path = "#{Rails.root}/config/locales"
+    self.locales_config_path = self._dump_path
 
     cattr_accessor :primary_locale_name
-    self.primary_locale_name = I18n.default_locale.to_s
+    self.primary_locale_name = Tolk.config.primary_locale_name || I18n.default_locale.to_s
 
     include Tolk::Sync
     include Tolk::Import
@@ -81,7 +41,7 @@ module Tolk
         @_primary_locale = nil if reload
         @_primary_locale ||= begin
           raise "Primary locale is not set. Please set Locale.primary_locale_name in your application's config file" unless self.primary_locale_name
-          find_or_create_by_name(self.primary_locale_name)
+          where(name: self.primary_locale_name).first_or_create
         end
       end
 
@@ -93,28 +53,32 @@ module Tolk
         all - [primary_locale]
       end
 
-      def dump_all(to = self.locales_config_path)
-        secondary_locales.each do |locale|
-          File.open("#{to}/#{locale.name}.yml", "w+") do |file|
-            data = locale.to_hash
-            data.respond_to?(:ya2yaml) ? file.write(data.ya2yaml(:syck_compatible => true)) : YAML.dump(locale.to_hash, file)
-          end
-        end
+      def dump_all(*args)
+        secondary_locales.each { |locale| locale.dump(*args) }
+      end
+
+      def dump_yaml(name, *args)
+        where(name: name).first.dump(*args)
       end
 
       def special_key_or_prefix?(prefix, key)
         self.special_prefixes.include?(prefix) || self.special_keys.include?(key)
       end
 
-      PLURALIZATION_KEYS = ['none', 'one', 'two', 'few', 'many', 'other']
+      # http://cldr.unicode.org/index/cldr-spec/plural-rules - TODO: usage of 'none' isn't standard-conform
+      PLURALIZATION_KEYS = ['none', 'zero', 'one', 'two', 'few', 'many', 'other']
       def pluralization_data?(data)
         keys = data.keys.map(&:to_s)
         keys.all? {|k| PLURALIZATION_KEYS.include?(k) }
       end
     end
 
+    def dump(to = self.locales_config_path, exporter = Tolk::Export)
+      exporter.dump(name: name, data: to_hash, destination: to)
+    end
+
     def has_updated_translations?
-      translations.count(:conditions => {:'tolk_translations.primary_updated' => true}) > 0
+      translations.where('tolk_translations.primary_updated' => true).count > 0
     end
 
     def phrases_with_translation(page = nil)
@@ -126,22 +90,31 @@ module Tolk
     end
 
     def count_phrases_without_translation
-      existing_ids = self.translations.all(:select => 'tolk_translations.phrase_id').map(&:phrase_id).uniq
+      existing_ids = self.translations(:select => 'tolk_translations.phrase_id').map(&:phrase_id).uniq
       Tolk::Phrase.count - existing_ids.count
     end
 
-    def phrases_without_translation(page = nil, options = {})
-      phrases = Tolk::Phrase.scoped(:order => 'tolk_phrases.key ASC')
+    def count_phrases_with_updated_translation(page = nil)
+      find_phrases_with_translations(page, :'tolk_translations.primary_updated' => true).count
+    end
+
+    def phrases_without_translation(page = nil)
+      phrases = Tolk::Phrase.all.order('tolk_phrases.key ASC')
 
-      existing_ids = self.translations.all(:select => 'tolk_translations.phrase_id').map(&:phrase_id).uniq
-      phrases = phrases.scoped(:conditions => ['tolk_phrases.id NOT IN (?)', existing_ids]) if existing_ids.present?
+      existing_ids = self.translations(:select => 'tolk_translations.phrase_id').map(&:phrase_id).uniq
+      phrases = phrases.where('tolk_phrases.id NOT IN (?)', existing_ids) if existing_ids.present?
+
+      result = phrases.public_send(pagination_method, page)
+      if Rails.version =~ /^4\.0/
+        ActiveRecord::Associations::Preloader.new result, :translations
+      else
+        ActiveRecord::Associations::Preloader.new().preload(result, :translations)
+      end
 
-      result = phrases.paginate({:page => page, :per_page => Phrase.per_page}.merge(options))
-      ActiveRecord::Associations::Preloader.new result, :translations
       result
     end
 
-    def search_phrases(query, scope, key_query, page = nil, options = {})
+    def search_phrases(query, scope, key_query, page = nil)
       return [] unless query.present? || key_query.present?
 
       translations = case scope
@@ -151,35 +124,42 @@ module Tolk
         self.translations.containing_text(query)
       end
 
-      phrases = Tolk::Phrase.scoped(:order => 'tolk_phrases.key ASC')
+      phrases = Tolk::Phrase.all.order('tolk_phrases.key ASC')
       phrases = phrases.containing_text(key_query)
 
-      phrases = phrases.scoped(:conditions => ['tolk_phrases.id IN(?)', translations.map(&:phrase_id).uniq])
-      phrases.paginate({:page => page}.merge(options))
+      phrases = phrases.where('tolk_phrases.id IN(?)', translations.map(&:phrase_id).uniq)
+      phrases.public_send(pagination_method, page)
     end
 
-    def search_phrases_without_translation(query, page = nil, options = {})
-      return phrases_without_translation(page, options) unless query.present?
+    def search_phrases_without_translation(query, page = nil)
+      return phrases_without_translation(page) unless query.present?
 
-      phrases = Tolk::Phrase.scoped(:order => 'tolk_phrases.key ASC')
+      phrases = Tolk::Phrase.all.order('tolk_phrases.key ASC')
 
-      found_translations_ids = Tolk::Locale.primary_locale.translations.all(:conditions => ["tolk_translations.text LIKE ?", "%#{query}%"], :select => 'tolk_translations.phrase_id').map(&:phrase_id).uniq
-      existing_ids = self.translations.all(:select => 'tolk_translations.phrase_id').map(&:phrase_id).uniq
-      phrases = phrases.scoped(:conditions => ['tolk_phrases.id NOT IN (?) AND tolk_phrases.id IN(?)', existing_ids, found_translations_ids]) if existing_ids.present?
+      found_translations_ids = Tolk::Locale.primary_locale.translations.where(["tolk_translations.text LIKE ?", "%#{query}%"]).to_a.map(&:phrase_id).uniq
+      existing_ids = self.translations.select('tolk_translations.phrase_id').to_a.map(&:phrase_id).uniq
+#      phrases = phrases.scoped(:conditions => ['tolk_phrases.id NOT IN (?) AND tolk_phrases.id IN(?)', existing_ids, found_translations_ids]) if existing_ids.present?
+      phrases = phrases.where(['tolk_phrases.id NOT IN (?) AND tolk_phrases.id IN(?)', existing_ids, found_translations_ids]) if existing_ids.present?
+      result = phrases.public_send(pagination_method, page)
+      if Rails.version =~ /^4\.0/
+        ActiveRecord::Associations::Preloader.new result, :translations
+      else
+        ActiveRecord::Associations::Preloader.new().preload(result, :translations)
+      end
 
-      result = phrases.paginate({:page => page}.merge(options))
-      ActiveRecord::Associations::Preloader.new result, :translations
       result
     end
 
     def to_hash
-      { name => translations.each_with_object({}) do |translation, locale|
-        if translation.phrase.key.include?(".")
-          locale.deep_merge!(unsquish(translation.phrase.key, translation.value))
-        else
-          locale[translation.phrase.key] = translation.value
+      data = translations.includes(:phrase).references(:phrases).order(phrases.arel_table[:key]).
+        each_with_object({}) do |translation, locale|
+          if translation.phrase.key.include?(".")
+            locale.deep_merge!(unsquish(translation.phrase.key, translation.value))
+          else
+            locale[translation.phrase.key] = translation.value
+          end
         end
-      end }
+      { name => data }
     end
 
     def to_param
@@ -191,11 +171,11 @@ module Tolk
     end
 
     def language_name
-      MAPPING[self.name] || self.name
+      Tolk.config.mapping[self.name] || self.name
     end
 
     def get(key)
-      if phrase = Tolk::Phrase.find_by_key(key)
+      if phrase = Tolk::Phrase.where(key: key).first
         t = self.translations.where(:phrase_id => phrase.id).first
         t.text if t
       end
@@ -204,18 +184,37 @@ module Tolk
     def translations_with_html
       translations = self.translations.all(:conditions => "tolk_translations.text LIKE '%>%' AND
         tolk_translations.text LIKE '%<%' AND tolk_phrases.key NOT LIKE '%_html'", :joins => :phrase)
-      ActiveRecord::Associations::Preloader.new translations, :phrase
+      if Rails.version =~ /^4\.0/
+        ActiveRecord::Associations::Preloader.new translations, :phrase
+      else
+        ActiveRecord::Associations::Preloader.new().preload(translations, :phrase)
+      end
       translations
     end
 
+    def self.rename(old_name, new_name)
+      if old_name.blank? || new_name.blank?
+        "You need to provide both names, aborting."
+      else
+        if locale = where(name: old_name).first
+          locale.name = new_name
+          locale.save
+          "Locale ' #{old_name}' was renamed '#{new_name}'"
+        else
+          "Locale with name '#{old_name}' not found."
+        end
+      end
+    end
+
     private
 
+
     def remove_invalid_translations_from_target
       self.translations.target.dup.each do |t|
-         unless t.valid?
+        unless t.valid?
           self.translations.target.delete(t)
         else
-          t.updated_at = Time.current # Silly hax to fool autosave into saving the record
+          t.updated_at_will_change!
         end
       end
 
@@ -223,15 +222,17 @@ module Tolk
     end
 
     def find_phrases_with_translations(page, conditions = {})
-      result = Tolk::Phrase.paginate(:page => page,
-        :conditions => { :'tolk_translations.locale_id' => self.id }.merge(conditions),
-        :joins => :translations, :order => 'tolk_phrases.key ASC')
+      result = Tolk::Phrase.where({ :'tolk_translations.locale_id' => self.id }.merge(conditions)).joins(:translations).order('tolk_phrases.key ASC').public_send(pagination_method, page)
 
       result.each do |phrase|
         phrase.translation = phrase.translations.for(self)
       end
 
-      ActiveRecord::Associations::Preloader.new result, :translations
+      if Rails.version =~ /^4\.0/
+        ActiveRecord::Associations::Preloader.new result, :translations
+      else
+        ActiveRecord::Associations::Preloader.new().preload(result, :translations)
+      end
 
       result
     end

data/app/models/tolk/phrase.rb

@@ -2,12 +2,9 @@ module Tolk
   class Phrase < ActiveRecord::Base
     self.table_name = "tolk_phrases"
 
-    attr_accessible :key
-
     validates_uniqueness_of :key
 
-    cattr_accessor :per_page
-    self.per_page = 30
+    paginates_per 30
 
     has_many :translations, :class_name => 'Tolk::Translation', :dependent => :destroy do
       def primary
@@ -21,8 +18,10 @@ module Tolk
 
     attr_accessor :translation
 
+#scope :red, -> { where(color: 'red') } rather than scope :red, -> { { conditions: { color: 'red' } } }
+
     scope :containing_text, lambda { |query|
-      { :conditions => ["tolk_phrases.key LIKE ?", "%#{query}%"] }
+      where("tolk_phrases.key LIKE ?", "%#{query}%")
     }
   end
 end

data/app/models/tolk/translation.rb

@@ -5,7 +5,8 @@ module Tolk
     scope :containing_text, lambda {|query| where("tolk_translations.text LIKE ?", "%#{query}%") }
 
     serialize :text
-    validates_presence_of :text, :if => proc {|r| r.primary.blank? && !r.explicit_nil }
+    serialize :previous_text
+    validate :validate_text_not_nil, :if => proc {|r| r.primary.blank? && !r.explicit_nil && !r.boolean?}
     validate :check_matching_variables, :if => proc { |tr| tr.primary_translation.present? }
 
     validates_uniqueness_of :phrase_id, :scope => :locale_id
@@ -14,9 +15,6 @@ module Tolk
     belongs_to :locale, :class_name => 'Tolk::Locale'
     validates_presence_of :locale_id
 
-    attr_accessible :phrase_id, :locale_id, :text, :primary_updated, :previous_text, :locale, :phrase
-
-    attr_accessor :force_set_primary_update
     before_save :set_primary_updated
 
     before_save :set_previous_text
@@ -27,6 +25,10 @@ module Tolk
     attr_accessor :explicit_nil
     before_validation :set_explicit_nil
 
+    def boolean?
+      text.is_a?(TrueClass) || text.is_a?(FalseClass) || text == 't' || text == 'f'
+    end
+
     def up_to_date?
       not out_of_date?
     end
@@ -45,24 +47,48 @@ module Tolk
 
     def text=(value)
       value = value.to_s if value.kind_of?(Fixnum)
-      super unless value.to_s == text
+      if primary_translation && primary_translation.boolean?
+        value = case value.to_s.downcase.strip
+        when 'true', 't'
+          true
+        when 'false', 'f'
+          false
+        else
+          self.explicit_nil = true
+          nil
+        end
+        super unless value == text
+      else
+        value = value.strip if value.is_a?(String) && Tolk.config.strip_texts
+        super unless value.to_s == text
+      end
     end
 
     def value
       if text.is_a?(String) && /^\d+$/.match(text)
         text.to_i
+      elsif (primary_translation || self).boolean?
+        %w[true t].member?(text.to_s.downcase.strip)
       else
         text
       end
     end
 
     def self.detect_variables(search_in)
-      case search_in
+      variables = case search_in
         when String then Set.new(search_in.scan(/\{\{(\w+)\}\}/).flatten + search_in.scan(/\%\{(\w+)\}/).flatten)
         when Array then search_in.inject(Set[]) { |carry, item| carry + detect_variables(item) }
         when Hash then search_in.values.inject(Set[]) { |carry, item| carry + detect_variables(item) }
         else Set[]
       end
+
+      # delete special i18n variable used for pluralization itself (might not be used in all values of
+      # the pluralization keys, but is essential to use pluralization at all)
+      if search_in.is_a?(Hash) && Tolk::Locale.pluralization_data?(search_in)
+        variables.delete_if {|v| v == 'count' }
+      else
+        variables
+      end
     end
 
     def variables
@@ -92,14 +118,25 @@ module Tolk
           end
         end
 
-        self.text = nil if primary_translation.text.class != self.text.class
+        if primary_translation.boolean?
+          self.text = case self.text.to_s.strip
+          when 'true'
+            true
+          when 'false'
+            false
+          else
+            nil
+          end
+        elsif primary_translation.text.class != self.text.class
+          self.text = nil
+        end
       end
 
       true
     end
 
     def set_primary_updated
-      self.primary_updated = self.force_set_primary_update ? true : false
+      self.primary_updated = false
       true
     end
 
@@ -110,12 +147,17 @@ module Tolk
 
     def check_matching_variables
       unless variables_match?
-        if primary_translation.variables.empty? || primary_translation.variables.class == Set
-          self.errors.add(:text, "The original does not contain variables, so they should not be included.")
+        if primary_translation.variables.empty?
+          self.errors.add(:variables, "The primary translation does not contain substitutions, so this should neither.")
         else
-          self.errors.add(:text, "The translation should contain the variables #{primary_translation.to_a.to_sentence}.")
+          self.errors.add(:variables, "The translation should contain the substitutions of the primary translation: (#{primary_translation.variables.to_a.join(', ')}), found (#{self.variables.to_a.join(', ')}).")
         end
       end
     end
+
+    def validate_text_not_nil
+      return unless text.nil?
+      errors.add :text, :blank
+    end
   end
 end