rails-i18nterface 0.1.7 → 0.2.0

data/README.md

@@ -40,11 +40,7 @@ In routes.rb
 ```ruby
 mount RailsI18nterface::Engine => "/translate", :as => "translate_engine"
 ```
-Copy migration to store translated values and migrate
-```
-rake railties:install:migrations
-rake db:migrate
-```
+
 ### Protect access
 
 You may want to protect the translation engine to admin and create a constraint
@@ -55,6 +51,11 @@ constraints AdminConstraint.new do
     mount RailsI18nterface::Engine => "/translate", :as => "translate_engine"
   end
 end
+# this second route will be then used if the user is not an admin
+get 'translate' => redirect do |p, req|
+  req.flash['error'] = I18n.t('errors.permission_denied')
+  "/signin"
+end
 ```
 
 Then create a `config/initializers/admin_constraint.rb` containing:
@@ -81,16 +82,22 @@ Where `[:en]` and `[:ja, :es, :fr]` could be replaced by locale list of your cho
 ## Todo
 
 * fix the code smell reported by code climate
-  * extract code from the controller to a lib
-  * refactor the libs in a cleaner way
-  * apply rubocop and follow his law
+  * extract code from the controller to a lib (in progress)
+  * refactor the libs in a cleaner way (in progress)
+  * apply rubocop and follow his law (done)
 * make the application thread-safe
-* remove those damn global variables
-* extend testing to refactored libs
+* remove those damn global variables (in progress)
+* extend testing to refactored libs (in progress)
 * change navigation to an ajax-driven reload
 * add a way to gather .one and .other and .few under same translation line
 * add support for other i18n backends (gettext)
 
+## Note for upgrade 0.1.x to 0.2.x
+
+The database is not used anymore, back to the good old way.
+So you can remove the table rails_i18nterface_translations (v0.1.7)
+or translations (< 0.1.7).
+
 ## License
 
 ```

data/app/controllers/rails_i18nterface/application_controller.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RailsI18nterface
   class ApplicationController < ActionController::Base
   end

data/app/controllers/rails_i18nterface/translate_controller.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RailsI18nterface
   class TranslateController < RailsI18nterface::ApplicationController
 
@@ -8,108 +10,68 @@ module RailsI18nterface
 
     def index
       @dbvalues = {}
-      @keys = initialize_keys
-      load_db_translations
-      @deep_keys = RailsI18nterface::Keys.to_deep_hash(@keys)
+      @keys = RailsI18nterface::Keys.new(Rails.root, @from_locale, @to_locale)
+      @files = @keys.files
+      @yaml_keys = @keys.yaml_keys
+      @all_keys = @keys.all_keys
+      @deep_keys = to_deep_hash(@all_keys)
       filter_by_key_pattern
       filter_by_text_pattern
       filter_by_translated_or_changed
       sort_keys
       paginate_keys
-      @total_entries = @keys.size
+      @total_entries = @all_keys.size
+      @page_title = 'Translate'
+      @show_filters = ['all', 'untranslated', 'translated']
     end
 
     def destroy
-      puts params
-      term = RailsI18nterface::Translation.find_by_key(params[:del])
-      if term and term.destroy
-        flash[:success] = "Translations removed from database"
-      else
-        flash[:notice] = "Translations not found in database"
-      end
       params[:key] = { params[:del] => '' }
       update
     end
 
-    def load_db_translations
-      @versions = {}
-      @dbvalues = {@to_locale => {}}
-      (RailsI18nterface::Translation.where(:locale => @to_locale) || []).each do |translation|
-        @versions[translation.key] = translation.updated_at.to_i
-        yaml_value = I18n.backend.send(:lookup, @to_locale, translation.key)
-        if yaml_value && translation.value != yaml_value
-          translation.value = yaml_value
-          RailsI18nterface::Translation.where(key: translation.key).first.update_attribute(:value, yaml_value)
-        end
-        @dbvalues[@to_locale][translation.key] = translation.value
-        @keys << translation.key
-      end
-      @keys.uniq!
-    end
-
     def export
       locale = params[:locale].to_sym
       keys = {locale => I18n.backend.send(:translations)[locale] || {}}
-      RailsI18nterface::Translation.where(:locale => @to_locale).each do |translation|
-        next if !translation.value or translation.value == ''
-        set_nested(keys[locale], translation.key.split('.'), translation.value)
-      end
       remove_blanks keys
-      puts keys
-      yaml = RailsI18nterface::Yamlfile.new(nil).keys_to_yaml(keys)
+      yaml = keys_to_yaml(keys)
       response.headers['Content-Disposition'] = "attachment; filename=#{locale}.yml"
       render :text => yaml
     end
 
     def update
-      RailsI18nterface::Translation.update(@to_locale, params[:key])
       if I18n.backend.respond_to? :store_translations
-        I18n.backend.store_translations(@to_locale, RailsI18nterface::Keys.to_deep_hash(params[:key]))
+        I18n.backend.store_translations(@to_locale, to_deep_hash(params[:key]))
       end
-      RailsI18nterface::Storage.new(@to_locale).write_to_file
-      RailsI18nterface::Log.new(@from_locale, @to_locale, params[:key].keys).write_to_file
-      force_init_translations # Force reload from YAML file
-      flash[:notice] = "Translations stored"
+      yaml = RailsI18nterface::Yamlfile.new(Rails.root, @to_locale)
+      yaml.write_to_file
+      force_init_translations
+      flash[:notice] = 'Translations stored'
       redirect_to root_path(params.slice(:filter, :sort_by, :key_type, :key_pattern, :text_type, :text_pattern))
     end
 
     def reload
-      RailsI18nterface::Keys.files = nil
+      @keys.reload
       redirect_to root_path(params.slice(:filter, :sort_by, :key_type, :key_pattern, :text_type, :text_pattern))
     end
 
     private
 
-    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|
-        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.
-        (@from_locale != @to_locale && !from_text.present?) ||
-          (from_text.present? && !from_text.is_a?(String))
-      end
-    end
 
     def lookup(locale, key)
-      (@dbvalues[locale] && @dbvalues[locale][key]) || I18n.backend.send(:lookup, locale, key)
+      I18n.backend.send(:lookup, locale, key)
     end
     helper_method :lookup
 
     def filter_by_translated_or_changed
       params[:filter] ||= 'all'
       return if params[:filter] == 'all'
-      @keys.reject! do |key|
+      @all_keys.reject! do |key|
         case params[:filter]
         when 'untranslated'
           lookup(@to_locale, key).present?
         when 'translated'
           lookup(@to_locale, key).blank?
-        when 'changed'
-          old_from_text(key).blank? || lookup(@from_locale, key) == old_from_text(key)
         else
           raise "Unknown filter '#{params[:filter]}'"
         end
@@ -118,15 +80,15 @@ module RailsI18nterface
 
     def filter_by_key_pattern
       return if params[:key_pattern].blank?
-      @keys.reject! do |key|
+      @all_keys.reject! do |key|
         case params[:key_type]
-        when "starts_with"
+        when 'starts_with'
           if params[:key_pattern] == '.'
             key.match(/\./)
           else
             !key.starts_with?(params[:key_pattern])
           end
-        when "contains"
+        when 'contains'
           key.index(params[:key_pattern]).nil?
         else
           raise "Unknown key_type '#{params[:key_type]}'"
@@ -136,7 +98,7 @@ module RailsI18nterface
 
     def filter_by_text_pattern
       return if params[:text_pattern].blank?
-      @keys.reject! do |key|
+      @all_keys.reject! do |key|
         lookup_key = lookup(@from_locale, key)
         case params[:text_type]
         when 'contains'
@@ -150,12 +112,12 @@ module RailsI18nterface
     end
 
     def sort_keys
-      params[:sort_by] ||= "key"
+      params[:sort_by] ||= 'key'
       case params[:sort_by]
-      when "key"
-        @keys.sort!
-      when "text"
-        @keys.sort! do |key1, key2|
+      when 'key'
+        @all_keys.sort!
+      when 'text'
+        @all_keys.sort! do |key1, key2|
           if lookup(@from_locale, key1).present? && lookup(@from_locale, key2).present?
             lookup(@from_locale, key1).to_s.downcase <=> lookup(@from_locale, key2).to_s.downcase
           elsif lookup(@from_locale, key1).present?
@@ -171,7 +133,7 @@ module RailsI18nterface
 
     def paginate_keys
       params[:page] ||= 1
-      @paginated_keys = @keys[offset, per_page]
+      @paginated_keys = @all_keys[offset, per_page]
     end
 
     def offset
@@ -204,18 +166,5 @@ module RailsI18nterface
       @to_locale = session[:to_locale].to_sym
     end
 
-    def old_from_text(key)
-      return @old_from_text[key] if @old_from_text && @old_from_text[key]
-      @old_from_text = {}
-      text = key.split(".").reduce(log_hash) do |hash, k|
-        hash ? hash[k] : nil
-      end
-      @old_from_text[key] = text
-    end
-    helper_method :old_from_text
-
-    def log_hash
-      @log_hash ||= RailsI18nterface::Log.new(@from_locale, @to_locale, {}).read
-    end
   end
 end

data/app/helpers/rails_i18nterface/application_helper.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RailsI18nterface
   module ApplicationHelper
   end

data/app/helpers/rails_i18nterface/translate_helper.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RailsI18nterface
   module TranslateHelper
 

data/app/views/rails_i18nterface/translate/index.html.erb

@@ -1,29 +1,21 @@
-<%
-  @page_title = "Translate"
-  show_filters = ["all", "untranslated", "translated"]
-  show_filters << "changed" if @from_locale != @to_locale
-%>
 <%= form_tag(params, :method => :get, :name => 'filter_form') do %>
 <%= hidden_field_tag(:filter, params[:filter]) %>
 <%= hidden_field_tag(:sort_by, params[:sort_by]) %>
 <div id="top">
-  <% if @page_title %>
-    <h1>
-      <div class="right">
-       <%= select_tag(:from_locale, options_for_select(I18n.available_locales, @from_locale.to_sym)) %> <span>to</span>
-       <%= select_tag(:to_locale, options_for_select(I18n.available_locales, @to_locale.to_sym)) %>
-       <%= submit_tag "Display" %>
-      </div>
-      <%= link_to '.. /', '../' %>
-      <%= link_to @page_title, root_path %></a>
-      <div class="center">
-       <label>Show:</label> <%=  simple_filter(show_filters).html_safe %>
-        Found <strong><%= @total_entries %></strong> messages
-        <%= link_to "Reload messages", translate_reload_path(params) %>
-      </div>
-
-    </h1>
-  <% end %>
+  <h1>
+    <div class="right">
+     <%= select_tag(:from_locale, options_for_select(I18n.available_locales, @from_locale.to_sym)) %> <span>to</span>
+     <%= select_tag(:to_locale, options_for_select(I18n.available_locales, @to_locale.to_sym)) %>
+     <%= submit_tag "Display" %>
+    </div>
+    <%= link_to '.. /', '../' %>
+    <%= link_to @page_title, root_path %></a>
+    <div class="center">
+     <label>Show:</label> <%=  simple_filter(@show_filters).html_safe %>
+      Found <strong><%= @total_entries %></strong> messages
+      <%= link_to "Reload messages", translate_reload_path(params) %>
+    </div>
+  </h1>
   <% flash.each do |key, msg| %>
     <div class="flash" id="<%= key %>"><%= msg %></div>
   <% end %>
@@ -78,7 +70,6 @@
       %>
   	  <div class="translation">
       	<p class="edit-form">
-  			<%= hidden_field_tag("version[#{key}]", @versions[key] || '0') %>
   		  <% if n_lines > 1 %>
           <div class="right">
               <% if @files[key] %>

data/config/routes.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 RailsI18nterface::Engine.routes.draw do
   root to: 'translate#index'
 

data/lib/rails-i18nterface.rb

@@ -1,9 +1,11 @@
+# encoding: utf-8
+
 require 'rails-i18nterface/engine'
 require 'rails-i18nterface/utils'
+require 'rails-i18nterface/cache'
 require 'rails-i18nterface/yamlfile'
 require 'rails-i18nterface/sourcefiles'
 require 'rails-i18nterface/keys'
-require 'rails-i18nterface/log'
 require 'rails-i18nterface/storage'
 
 module RailsI18nterface

data/lib/rails-i18nterface/cache.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module RailsI18nterface
+  module Cache
+
+    def cache_save(obj, uri, options={})
+      FileUtils.rm uri if File.exists? uri
+      File.open(uri, 'wb') do |f|
+        Marshal.dump(obj, f)
+      end
+    end
+
+    def cache_load(uri, file, &process)
+      mtime = File.mtime(file)
+      if cached?(uri) && uptodate?(uri, file)
+        File.open(uri) do |f|
+          Marshal.load f
+        end
+      else
+        if block_given?
+          obj = yield
+          cache_save(obj, uri)
+          File.utime(mtime, mtime, uri)
+          obj
+        else
+          nil
+        end
+      end
+    end
+
+    def cached?(uri)
+      File.file? uri
+    end
+
+    def uptodate?(uri, file)
+      File.mtime(uri) == File.mtime(file)
+    end
+
+  end
+end

data/lib/rails-i18nterface/engine.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'rails'
 
 module RailsI18nterface

data/lib/rails-i18nterface/keys.rb

@@ -1,57 +1,50 @@
-#require 'pathname'
+# encoding: utf-8
 
 module RailsI18nterface
   class 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
+    include Utils
 
-    def files
-      @files ||= RailsI18nterface::Sourcefiles.extract_files
-    end
-    alias_method :to_hash, :files
+    attr_accessor :files, :keys
+    attr_reader :yaml_keys, :all_keys
 
-    def names
-      @names ||= i18n_keys
+    def initialize(root_dir, from, to)
+      @root_dir = root_dir
+      @files = RailsI18nterface::Sourcefiles.extract_files(root_dir)
+      @yaml_keys = i18n_keys(I18n.default_locale)
+      @from_locale = from
+      @to_locale = to
+      @all_keys = (@files.keys.map(&:to_s) + @yaml_keys).uniq
     end
-    alias_method :to_tree, :names
 
-    def keys
-      files.keys
+    def reload
+      @files = RailsI18nterface::Sourcefiles.extract_files(root_dir)
+      @yaml_keys = i18n_keys(I18n.default_locale)
+      @all_keys = (@files.keys.map(&:to_s) + @yaml_keys).uniq
     end
-    alias_method :to_a, :keys
 
     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
+      to_shallow_hash(I18n.backend.send(:translations)[locale.to_sym]).keys.sort
     end
 
     def untranslated_keys
-      self.class.translated_locales.reduce({}) do |missing, locale|
-        missing[locale] = i18n_keys(I18n.default_locale).map do |key|
-          I18n.backend.send(:lookup, locale, key).nil? ? key : nil
+      self.class.translated_locales.reduce({}) do |a, e|
+        a[e] = i18n_keys(I18n.default_locale).map do |key|
+          I18n.backend.send(:lookup, e, key).nil? ? key : nil
         end.compact
-        missing
+        a
       end
     end
 
     def missing_keys
       locale = I18n.default_locale
+      filepath = Dir.glob(File.join(@root_dir, 'config', 'locales', '**', "#{locale}.yml"))
       yaml_keys = {}
-      yaml_keys = Storage.file_paths(locale).reduce({}) do |keys, path|
-        keys = keys.deep_merge(Yamlfile.new(path).read[locale.to_s])
+      yaml_keys = filepath.reduce({}) do |a, e|
+        a = a.deep_merge(Yamlfile.new(@root_dir, locale).read[locale.to_s])
       end
-      files.reject { |key, file| self.class.contains_key?(yaml_keys, key) }
+      @files.keys.reject { |key, file| contains_key?(yaml_keys, key) }
     end
 
     def self.translated_locales
@@ -60,86 +53,5 @@ module RailsI18nterface
       end
     end
 
-    # 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.reduce(HashWithIndifferentAccess.new(hash)) do |memo, k|
-        memo.is_a?(Hash) ? memo.try(:[], k) : nil
-      end.nil?
-    end
-
-    # Convert something like:
-    #
-    # {
-    #  :pressrelease => {
-    #    :label => {
-    #      :one => "Pressmeddelande"
-    #    }
-    #   }
-    # }
-    #
-    # to:
-    #
-    #  {'pressrelease.label.one' => "Pressmeddelande"}
-    #
-    def self.to_shallow_hash(hash)
-      hash.reduce({}) 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
-        end
-        shallow_hash
-      end
-    end
-
-    # Convert something like:
-    #
-    #  {'pressrelease.label.one' => "Pressmeddelande"}
-    #
-    # to:
-    #
-    # {
-    #  :pressrelease => {
-    #    :label => {
-    #      :one => "Pressmeddelande"
-    #    }
-    #   }
-    # }
-    def self.to_deep_hash(hash)
-      hash.reduce({}) do |deep_hash, (key, value)|
-        keys = key.to_s.split('.').reverse
-        leaf_key = keys.shift
-        key_hash = keys.reduce({leaf_key.to_sym => value}) { |h, k| { k.to_sym => h } }
-        deep_merge!(deep_hash, key_hash)
-        deep_hash
-      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
-
   end
 end