rails-i18nterface 0.1.3 → 0.1.4

data/README.md

@@ -8,21 +8,23 @@ This is a fork of an overhaul of a fork of a fork of rails-translate.
 
 It was originally created by [Peter Marklund and Joakim Westerlund @ mynewsdesk](https://github.com/mynewsdesk/translate)
 and later adapted to rails 3.0 by [Claudius Coenen](https://github.com/ccoenen/rails-translate).
-This version is a spinoff of Claudius Coenen's version by [Larry Sprock](https://github.com/lardawge/rails-i18nterface).
+This version is a spin-off of Claudius Coenen's version by [Larry Sprock](https://github.com/lardawge/rails-i18nterface).
 It was renamed, refactored and prepared for rails 3.1 as an Engine. Over this work
 [Michal Hantl](https://github.com/hakunin/rails-i18nterface) made a bunch of nice UI modifications
-on his fork. Since then it was more or less abandonned.
+on his fork. Since then it was more or less abandoned.
 
 I took over the evolution with some new features:
 
 * testing using [combustion](https://github.com/pat/combustion) and [rspec](https://github.com/rspec/rspec)
 * redesign of the layout
-* navigation overhaul, spliting the namespaces in a foldable menu
+* navigation overhaul, splitting the name-spaces in a foldable menu
 * gathering of first-level translations under a ROOT container
 * gemification and release of a version 0.1.0
 * (the 0.0.1 was the work from Larry Sprock but was not published as a gem)
 * compatibility with rails 4 and ruby 2
 
+Check the [Changelog](https://github.com/mose/rails-i18nterface/blob/master/changelog.md) for details about further changes.
+
 ![rails-i18nterface](http://mose.fr/rails-i18nterface.png)
 
 ## Usage
@@ -65,7 +67,7 @@ end
 (this example is for devise users, but you can adjust it to return true or false
 according to your own context).
 
-### Confifuration
+### Configuration
 
 You can configure `from_locales` and `to_locales` explicitly in your
 `environments/development.rb` by adding
@@ -81,6 +83,8 @@ Where `[:en]` and `[:ja, :es, :fr]` could be replaced by locale list of your cho
   * extract code from the controller to a lib
   * refactor the libs in a cleaner way
   * apply rubocop and follow his law
+* make the application thread-safe
+* remove those damn global variables
 * extend testing to refactored libs
 * change navigation to an ajax-driven reload
 * add a way to gather .one and .other and .few under same translation line

data/app/controllers/rails_i18nterface/translate_controller.rb

@@ -1,12 +1,14 @@
 module RailsI18nterface
   class TranslateController < RailsI18nterface::ApplicationController
 
+    include Utils
+
     before_filter :init_translations
     before_filter :set_locale
 
     def index
       @dbvalues = {}
-      initialize_keys
+      @keys = initialize_keys
       load_db_translations
       @deep_keys = RailsI18nterface::Keys.to_deep_hash(@keys)
       filter_by_key_pattern
@@ -46,61 +48,15 @@ module RailsI18nterface
       locale = params[:locale].to_sym
       keys = {locale => I18n.backend.send(:translations)[locale] || {}}
       Translation.where(:locale => @to_locale).each { |translation|
-        next if translation.value == ''
-        next if !translation.value
+        next if !translation.value or translation.value == ''
         set_nested(keys[locale], translation.key.split("."), translation.value)
       }
       remove_blanks keys
-      yaml = keys_to_yaml(deep_stringify_keys(keys))
+      yaml = RailsI18nterface::Yamlfile.new.keys_to_yaml(keys)
       response.headers['Content-Disposition'] = "attachment; filename=#{locale}.yml"
       render :text => yaml
     end
 
-    def remove_blanks hash
-      hash.each { |k, v|
-        if !v || v == ''
-          hash.delete k
-        end
-        if v.is_a? Hash
-          remove_blanks v
-          if v == {}
-            hash.delete k
-          end
-        end
-      }
-    end
-
-    def set_nested(hash, key, value)
-      if key.length == 1
-        hash[key[0]] = value
-      else
-        k = key.shift
-        set_nested(hash[k] ||= {}, key, value)
-      end
-    end
-
-  private
-
-    # Stringifying keys for prettier YAML
-    def deep_stringify_keys(hash)
-      hash.inject({}) { |result, (key, value)|
-        value = deep_stringify_keys(value) if value.is_a? Hash
-        result[(key.to_s rescue key) || key] = value
-        result
-      }
-    end
-
-    def keys_to_yaml(keys)
-      # Using ya2yaml, if available, for UTF8 support
-      if keys.respond_to?(:ya2yaml)
-        keys.ya2yaml(:escape_as_utf8 => true)
-      else
-        keys.to_yaml
-      end
-    end
-
-  public
-
     def update
       params[:key].each { |k, v|
         t = Translation.where(:key => k, :locale => @to_locale).first
@@ -134,8 +90,8 @@ module RailsI18nterface
 
     def initialize_keys
       @files = RailsI18nterface::Keys.files
-      @keys = (@files.keys.map(&:to_s) + RailsI18nterface::Keys.new.i18n_keys(@from_locale)).uniq
-      @keys.reject! do |key|
+      keys = (@files.keys.map(&:to_s) + RailsI18nterface::Keys.new.i18n_keys(@from_locale)).uniq
+      keys.reject! do |key|
         from_text = lookup(@from_locale, key)
         # When translating from one language to another, make sure there is a text to translate from.
         # Always exclude non string translation objects as we don't support editing them in the UI.
@@ -227,7 +183,7 @@ module RailsI18nterface
     end
 
     def per_page
-      50
+      params[:per_page] ? params[:per_page].to_i : 50
     end
     helper_method :per_page
 

data/lib/rails-i18nterface.rb

@@ -1,8 +1,10 @@
 require "rails-i18nterface/engine"
-require "rails-i18nterface/file"
+require "rails-i18nterface/yamlfile"
+require "rails-i18nterface/sourcefiles"
 require "rails-i18nterface/keys"
 require "rails-i18nterface/log"
 require "rails-i18nterface/storage"
+require "rails-i18nterface/utils"
 
 module RailsI18nterface
 end

data/lib/rails-i18nterface/keys.rb

@@ -1,192 +1,143 @@
 #require 'pathname'
 
-class RailsI18nterface::Keys
-  # Allows keys extracted from lookups in files to be cached
-  def self.files
-    @@files ||= new.files
-  end
-
-  def self.names
-    @@names || new.names
-  end
-  # Allows flushing of the files cache
-  def self.files=(files)
-    @@files = files
-  end
-
-  def files
-    @files ||= extract_files
-  end
-  alias_method :to_hash, :files
-
-  def names
-    @names ||= build_namespaces
-  end
-  alias_method :to_tree, :names
+module RailsI18nterface
+  class Keys
 
-  def keys
-    files.keys
-  end
-  alias_method :to_a, :keys
+    # Allows keys extracted from lookups in files to be cached
+    def self.files
+      @@files ||= new.files
+    end
 
-  def i18n_keys(locale)
-    I18n.backend.send(:init_translations) unless I18n.backend.initialized?
-    self.class.to_shallow_hash(I18n.backend.send(:translations)[locale.to_sym]).keys.sort
-  end
+    def self.names
+      @@names || new.names
+    end
+    # Allows flushing of the files cache
+    def self.files=(files)
+      @@files = files
+    end
 
-  def untranslated_keys
-    self.class.translated_locales.inject({}) do |missing, locale|
-      missing[locale] = i18n_keys(I18n.default_locale).map do |key|
-        I18n.backend.send(:lookup, locale, key).nil? ? key : nil
-      end.compact
-      missing
+    def files
+      @files ||= RailsI18nterface::Sourcefiles.extract_files
     end
-  end
+    alias_method :to_hash, :files
 
-  def missing_keys
-    locale = I18n.default_locale
-    yaml_keys = {}
-    yaml_keys = RailsI18nterface::Storage.file_paths(locale).inject({}) do |keys, path|
-      keys = keys.deep_merge(RailsI18nterface::File.new(path).read[locale.to_s])
+    def names
+      @names ||= i18n_keys
     end
-    files.reject { |key, file| self.class.contains_key?(yaml_keys, key) }
-  end
+    alias_method :to_tree, :names
 
-  def self.translated_locales
-    I18n.available_locales.reject { |locale| [:root, I18n.default_locale.to_sym].include?(locale) }
-  end
+    def keys
+      files.keys
+    end
+    alias_method :to_a, :keys
 
-  # Checks if a nested hash contains the keys in dot separated I18n key.
-  #
-  # Example:
-  #
-  # hash = {
-  #   :foo => {
-  #     :bar => {
-  #       :baz => 1
-  #     }
-  #   }
-  # }
-  #
-  # contains_key?("foo", key) # => true
-  # contains_key?("foo.bar", key) # => true
-  # contains_key?("foo.bar.baz", key) # => true
-  # contains_key?("foo.bar.baz.bla", key) # => false
-  #
-  def self.contains_key?(hash, key)
-    keys = key.to_s.split(".")
-    return false if keys.empty?
-    !keys.inject(HashWithIndifferentAccess.new(hash)) do |memo, key|
-      memo.is_a?(Hash) ? memo.try(:[], key) : nil
-    end.nil?
-  end
+    def i18n_keys(locale)
+      I18n.backend.send(:init_translations) unless I18n.backend.initialized?
+      self.class.to_shallow_hash(I18n.backend.send(:translations)[locale.to_sym]).keys.sort
+    end
 
-  # Convert something like:
-  #
-  # {
-  #  :pressrelease => {
-  #    :label => {
-  #      :one => "Pressmeddelande"
-  #    }
-  #   }
-  # }
-  #
-  # to:
-  #
-  #  {'pressrelease.label.one' => "Pressmeddelande"}
-  #
-  def self.to_shallow_hash(hash)
-    hash.inject({}) do |shallow_hash, (key, value)|
-      if value.is_a?(Hash)
-        to_shallow_hash(value).each do |sub_key, sub_value|
-          shallow_hash[[key, sub_key].join(".")] = sub_value
-        end
-      else
-        shallow_hash[key.to_s] = value
+    def untranslated_keys
+      self.class.translated_locales.inject({}) do |missing, locale|
+        missing[locale] = i18n_keys(I18n.default_locale).map do |key|
+          I18n.backend.send(:lookup, locale, key).nil? ? key : nil
+        end.compact
+        missing
       end
-      shallow_hash
     end
-  end
 
-  # Convert something like:
-  #
-  #  {'pressrelease.label.one' => "Pressmeddelande"}
-  #
-  # to:
-  #
-  # {
-  #  :pressrelease => {
-  #    :label => {
-  #      :one => "Pressmeddelande"
-  #    }
-  #   }
-  # }
-  def self.to_deep_hash(hash)
-    hash.inject({}) do |deep_hash, (key, value)|
-      keys = key.to_s.split('.').reverse
-      leaf_key = keys.shift
-      key_hash = keys.inject({leaf_key.to_sym => value}) { |hash, key| {key.to_sym => hash} }
-      deep_merge!(deep_hash, key_hash)
-      deep_hash
+    def missing_keys
+      locale = I18n.default_locale
+      yaml_keys = {}
+      yaml_keys = Storage.file_paths(locale).inject({}) do |keys, path|
+        keys = keys.deep_merge(Yamlfile.new(path).read[locale.to_s])
+      end
+      files.reject { |key, file| self.class.contains_key?(yaml_keys, key) }
     end
-  end
 
-  # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-  def self.deep_merge!(hash1, hash2)
-    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-    hash1.merge!(hash2, &merger)
-  end
+    def self.translated_locales
+      I18n.available_locales.reject { |locale| [:root, I18n.default_locale.to_sym].include?(locale) }
+    end
 
-  private
+    # Checks if a nested hash contains the keys in dot separated I18n key.
+    #
+    # Example:
+    #
+    # hash = {
+    #   :foo => {
+    #     :bar => {
+    #       :baz => 1
+    #     }
+    #   }
+    # }
+    #
+    # contains_key?("foo", key) # => true
+    # contains_key?("foo.bar", key) # => true
+    # contains_key?("foo.bar.baz", key) # => true
+    # contains_key?("foo.bar.baz.bla", key) # => false
+    #
+    def self.contains_key?(hash, key)
+      keys = key.to_s.split(".")
+      return false if keys.empty?
+      !keys.inject(HashWithIndifferentAccess.new(hash)) do |memo, key|
+        memo.is_a?(Hash) ? memo.try(:[], key) : nil
+      end.nil?
+    end
 
-  def extract_files
-    files_to_scan.inject(HashWithIndifferentAccess.new) do |files, file|
-      begin#hack to avoid UTF-8 error
-        IO.read(file).scan(i18n_lookup_pattern).flatten.map(&:to_sym).each do |key|
-          path = Pathname.new(File.expand_path(file)).relative_path_from(Pathname.new(Rails.root)).to_s
-          #puts path
-          if key[0] == '.'
-            key = guess_namespace(path) + key.to_s
+    # Convert something like:
+    #
+    # {
+    #  :pressrelease => {
+    #    :label => {
+    #      :one => "Pressmeddelande"
+    #    }
+    #   }
+    # }
+    #
+    # to:
+    #
+    #  {'pressrelease.label.one' => "Pressmeddelande"}
+    #
+    def self.to_shallow_hash(hash)
+      hash.inject({}) do |shallow_hash, (key, value)|
+        if value.is_a?(Hash)
+          to_shallow_hash(value).each do |sub_key, sub_value|
+            shallow_hash[[key, sub_key].join(".")] = sub_value
           end
-          #puts key
-          #puts
-          files[key] ||= []
-          files[key] << path if !files[key].include?(path)
+        else
+          shallow_hash[key.to_s] = value
         end
-      rescue Exception => e
-        puts e.inspect
-        puts e.backtrace
-        puts "bug in Translation plugin, please debug, informations :"
-        puts file.inspect
-        puts i18n_lookup_pattern.inspect
+        shallow_hash
       end
-      files
     end
-  end
 
-  def guess_namespace(path)
-    parts = path.split(/\//)
-    case parts[0]
-    when 'app'
-      parts.shift
-      if parts[0] == 'views'
-        parts.shift
-        parts[-1].gsub!(/\.(erb|haml|slim)$/,'')
+    # Convert something like:
+    #
+    #  {'pressrelease.label.one' => "Pressmeddelande"}
+    #
+    # to:
+    #
+    # {
+    #  :pressrelease => {
+    #    :label => {
+    #      :one => "Pressmeddelande"
+    #    }
+    #   }
+    # }
+    def self.to_deep_hash(hash)
+      hash.inject({}) do |deep_hash, (key, value)|
+        keys = key.to_s.split('.').reverse
+        leaf_key = keys.shift
+        key_hash = keys.inject({leaf_key.to_sym => value}) { |hash, key| {key.to_sym => hash} }
+        deep_merge!(deep_hash, key_hash)
+        deep_hash
       end
     end
-    parts.join('.')
-  end
 
-  def build_namespaces
-    i18n_keys
-  end
-
-  def i18n_lookup_pattern
-    /\b(?:I18n\.t|I18n\.translate|t)(?:\s|\():?(?:'|")(\.?[a-z0-9_\.]+)(?:'|")/
-  end
+    # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+    def self.deep_merge!(hash1, hash2)
+      merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+      hash1.merge!(hash2, &merger)
+    end
 
-  def files_to_scan
-    Dir.glob(File.join(RailsI18nterface::Storage.root_dir, "{app,config,lib}", "**","*.{rb,erb,haml,slim,rhtml}")) +
-      Dir.glob(File.join(RailsI18nterface::Storage.root_dir, "{public,app/assets}", "javascripts", "**","*.{js,coffee}"))
   end
-end
+end