rails-i18nterface 0.1.0

data/app/controllers/rails_i18nterface/application_controller.rb

@@ -0,0 +1,4 @@
+module RailsI18nterface
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/rails_i18nterface/translate_controller.rb

@@ -0,0 +1,255 @@
+module RailsI18nterface
+  class TranslateController < RailsI18nterface::ApplicationController
+
+    before_filter :init_translations
+    before_filter :set_locale
+
+    def index
+      @dbvalues = {}
+      initialize_keys
+      load_db_translations
+      @deep_keys = RailsI18nterface::Keys.to_deep_hash(@keys)
+      filter_by_key_pattern
+      filter_by_text_pattern
+      filter_by_translated_or_changed
+      sort_keys
+      paginate_keys
+      @total_entries = @keys.size
+    end
+
+    def load_db_translations
+      @versions = {}
+      @dbvalues = {@to_locale => {}}
+      (Translation.where(:locale => @to_locale) || []).each { |translation|
+        @versions[translation.key] = translation.updated_at.to_i
+        @dbvalues[@to_locale][translation.key] = translation.value
+        @keys << translation.key
+      }
+      @keys.uniq!
+    end
+
+    def export
+      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
+        set_nested(keys[locale], translation.key.split("."), translation.value)
+      }
+      remove_blanks keys
+      yaml = keys_to_yaml(deep_stringify_keys(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
+        unless t
+          t = Translation.new
+          t.key = k
+          t.locale = @to_locale
+        end
+        next if t.value == v
+        if params[:version][k].to_i == t.updated_at.to_i
+          t.value = v
+        end
+        t.save
+      }
+      if I18n.backend.respond_to? :store_translations
+        I18n.backend.store_translations(@to_locale, RailsI18nterface::Keys.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"
+      redirect_to root_path(params.slice(:filter, :sort_by, :key_type, :key_pattern, :text_type, :text_pattern))
+    end
+
+    def reload
+      RailsI18nterface::Keys.files = nil
+      redirect_to :action => 'index'
+    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)
+    end
+    helper_method :lookup
+
+    def filter_by_translated_or_changed
+      params[:filter] ||= 'all'
+      return if params[:filter] == '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
+      end
+    end
+
+    def filter_by_key_pattern
+      return if params[:key_pattern].blank?
+      @keys.reject! do |key|
+        case params[:key_type]
+        when "starts_with"
+          if params[:key_pattern] == '.'
+            key.match(/\./)
+          else
+            !key.starts_with?(params[:key_pattern])
+          end
+        when "contains"
+          key.index(params[:key_pattern]).nil?
+        else
+          raise "Unknown key_type '#{params[:key_type]}'"
+        end
+      end
+    end
+
+    def filter_by_text_pattern
+      return if params[:text_pattern].blank?
+      @keys.reject! do |key|
+        case params[:text_type]
+        when 'contains'
+          !lookup(@from_locale, key).present? || !lookup(@from_locale, key).to_s.downcase.index(params[:text_pattern].downcase)
+        when 'equals'
+          !lookup(@from_locale, key).present? || lookup(@from_locale, key).to_s.downcase != params[:text_pattern].downcase
+        else
+          raise "Unknown text_type '#{params[:text_type]}'"
+        end
+      end
+    end
+
+    def sort_keys
+      params[:sort_by] ||= "key"
+      case params[:sort_by]
+      when "key"
+        @keys.sort!
+      when "text"
+        @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?
+            -1
+          else
+            1
+          end
+        end
+      else
+        raise "Unknown sort_by '#{params[:sort_by]}'"
+      end
+    end
+
+    def paginate_keys
+      params[:page] ||= 1
+      @paginated_keys = @keys[offset, per_page]
+    end
+
+    def offset
+      (params[:page].to_i - 1) * per_page
+    end
+
+    def per_page
+      50
+    end
+    helper_method :per_page
+
+    def init_translations
+      I18n.backend.send(:init_translations) unless I18n.backend.initialized?
+    end
+
+    def force_init_translations
+      I18n.backend.send(:init_translations) rescue false
+    end
+
+    def default_locale
+      I18n.default_locale
+    end
+
+    def set_locale
+      session[:from_locale] ||= default_locale
+      session[:to_locale] ||= :en
+      session[:from_locale] = params[:from_locale] if params[:from_locale].present?
+      session[:to_locale] = params[:to_locale] if params[:to_locale].present?
+      @from_locale = session[:from_locale].to_sym
+      @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(".").inject(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

@@ -0,0 +1,4 @@
+module RailsI18nterface
+  module ApplicationHelper
+  end
+end

data/app/helpers/rails_i18nterface/translate_helper.rb

@@ -0,0 +1,74 @@
+module RailsI18nterface
+  module TranslateHelper
+
+    def simple_filter(labels, param_name = 'filter', selected_value = nil)
+      selected_value ||= params[param_name]
+      filter = []
+      labels.each do |item|
+        if item.is_a?(Array)
+          type, label = item
+        else
+          type = label = item
+        end
+        if type.to_s == selected_value.to_s
+          filter << "<i>#{label}</i>"
+        else
+          link_params = params.merge({param_name.to_s => type})
+          link_params.merge!({"page" => nil}) if param_name.to_s != "page"
+          filter << link_to(label, link_params)
+        end
+      end
+      filter.join(" | ")
+    end
+
+    def n_lines(text, line_size)
+      n_lines = 1
+      if text.present?
+        n_lines = text.split("\n").size
+        if n_lines == 1 && text.length > line_size
+          n_lines = text.length / line_size + 1
+        end
+      end
+      n_lines
+    end
+
+    def build_namespace(h)
+      out = '<ul>'
+      dirs = {}
+      root = []
+      h.each do |k,v|
+        if v.is_a? Hash
+          dirs[k] = v
+        else
+          root << k
+        end
+      end
+      out << "<li class=\"dir\"><span class=\"display\" data-id=\".\"></span>ROOT"
+      out << " <span class=\"num\">(#{root.length})</span>"
+      out << '<ul>'
+      root.each do |key|
+        out << "<li class=\"item\" data-id=\"#{key.to_s}\">#{key}</li>"
+      end
+      out << '</ul>'
+      out << '</ul>'
+      out << list_namespace('',dirs)
+    end
+
+    def list_namespace(k,h)
+      out = '<ul>'
+      k != '' && k += '.'
+      h.each do |key,val|
+        if val.is_a? Hash
+          out << "<li class=\"dir\"><span class=\"display\" data-id=\"#{k+key.to_s}\"></span>#{key}"
+          out << " <span class=\"num\">(#{val.length})</span>"
+          out << list_namespace(k+key.to_s,val)
+        else
+          out << "<li class=\"item\" data-id=\"#{k+key.to_s}\">#{key}"
+        end
+        out << '</li>'
+      end
+      out << '</ul>'
+    end
+
+  end
+end

data/app/models/translation.rb

@@ -0,0 +1,4 @@
+class Translation < ActiveRecord::Base
+end
+
+

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

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+    <title><%= @page_title %></title>
+    <%= stylesheet_link_tag 'rails_i18nterface/application' %>
+    <%= javascript_include_tag 'rails_i18nterface/application' %>
+  </head>
+  <body>
+		<div id="container">
+		  <%= yield %>
+    </div>
+</html>

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

@@ -0,0 +1 @@
+<h2>Namespaces</h2>

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

@@ -0,0 +1,18 @@
+<%
+  n_pages = total_entries/per_page + (total_entries % per_page > 0 ? 1 : 0)
+  current_page = (params[:page] || 1).to_i
+%>
+
+<% if n_pages > 1 %>
+<div class="clearfix">
+	<ul class="paging">
+	  <% (1..n_pages).each do |page_number| %>
+	    <% if current_page == page_number %>
+	      <li class="selected"><%= link_to(page_number, params.merge(:page => page_number), :title => "Page #{page_number}" ) %></li>
+	    <% else %>
+	      <li><%= link_to(page_number, params.merge(:page => page_number), :title => "Page #{page_number}") %></li>
+	    <% end %>
+	  <% end %>
+	</ul>
+</div>
+<% end %>

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

@@ -0,0 +1,132 @@
+<%
+  @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 %>
+      </div>
+
+    </h1>
+  <% end %>
+  <% flash.each do |key, msg| %>
+    <div id="<%= key %>"><%= msg %></div>
+  <% end %>
+</div>
+<div id="searchbox">
+
+   <%= select_tag(:key_type, options_for_select([["Key contains", 'contains'], ["Key starts with", 'starts_with']], params[:key_type])) %>
+   <%= text_field_tag(:key_pattern, params[:key_pattern], :size => 50, :id => "key_pattern_value", :class => "text-default") %>
+
+   <%= select_tag(:text_type, options_for_select([['Text contains','contains'], ['Text equals','equals']], params[:text_type])) %>
+   <%= text_field_tag(:text_pattern, params[:text_pattern], :size => 50, :id => "text_pattern_value", :class => "text-default") %>
+
+    <%= link_to "clear", params.merge({:text_pattern => nil, :key_pattern => nil}), class: 'btn' %>
+    <%= submit_tag "Search" %>
+    <%= link_to "Export language file", translate_export_path(:locale => @to_locale), class: 'btn sep' %>
+</div>
+<% end %>
+
+<div id="namespaces">
+  <%= build_namespace(@deep_keys).html_safe %>
+</div>
+
+<div id="inside">
+  <div class="paging">
+    <%= render :partial => 'pagination', :locals => {:total_entries => @total_entries, :per_page => per_page} %>
+  </div>
+
+  <% if @total_entries > 0 %>
+  <%= form_tag(translate_path, method: :put) do %>
+    <div>
+        <%= hidden_field_tag(:filter, params[:filter], :id => "hid_filter") %>
+        <%= hidden_field_tag(:sort_by, params[:sort_by], :id => "hid_sort_by") %>
+        <%= hidden_field_tag(:key_type, params[:key_type], :id => "hid_key_type") %>
+        <%= hidden_field_tag(:key_pattern, params[:key_pattern], :id => "hid_key_pattern") %>
+        <%= hidden_field_tag(:text_type, params[:text_type], :id => "hid_text_type") %>
+        <%= hidden_field_tag(:text_pattern, params[:text_pattern], :id => "hid_text_pattern") %>
+    </div>
+    <div class="translations">
+      <p class="translate">
+        Translations from <%= @from_locale %> to <%= @to_locale %>
+        <label>Sort by:</label> <%= simple_filter(["key", "text"], 'sort_by').html_safe %>
+  	    <%= submit_tag "Save Translations", style: 'float:right;' %>
+  	  </p>
+  	  <% @paginated_keys.each do |key|
+  	      from_text = lookup(@from_locale, key)
+  	      to_text = lookup(@to_locale, key)
+  	      line_size = 100
+  	      n_lines = n_lines(from_text, line_size)
+  	      field_name = "key[#{key}]"
+          tid = key.split('.').join("_")
+
+      %>
+  	  <div class="translation">
+      	<p class="edit-form">
+  			<%= hidden_field_tag("version[#{key}]", @versions[key] || '0') %>
+  		<% if n_lines > 1 %>
+          <span class="right">
+  			    <span class="key"><%=h key %></span>
+  			      <% if @files[key] %>
+  				      <span class="file"><%= @files[key].join("</span><span>") %></span>
+  			      <% end %>
+  			    </span>
+  			  </span>
+          <div class="long-translation">
+  		      <div class="translation-text">
+        			<pre id="<%= tid %>_original"><%= from_text %></pre>
+              <div class="clear"></div>
+  		      </div>
+            <div class="translation-textarea">
+  			      <%= text_area_tag(field_name, to_text, :rows => n_lines+1, :id => tid) %>
+              <div class="clear"></div>
+  		      </div>
+            <div class="clear"></div>
+  		    </div>
+      <% else %>
+  		  <span class="translation-text">
+  			  <code class="keytext" id="<%= tid %>_original"><%= from_text %></code>
+  		  </span>
+        <span class="right">
+  			  <span class="key" ><%=h key %></span>
+  			    <% if @files[key] %>
+  				    <span class="file"><%= @files[key].join("</span><span>") %></span>
+  			    <% end %>
+  			  </span>
+  			</span>
+
+  			<%= text_field_tag(field_name, to_text, :size => line_size, :id => tid) %>
+  		<% end %>
+  		</p>
+  		<p>
+  	</p>
+  	</div>
+  <% end %>
+    <p class="translate">
+      Translations from <%= @from_locale %> to <%= @to_locale %>
+      <%= submit_tag "Save Translations", style: 'float:right' %>
+  	</p>
+  </div>
+  <% end %>
+  <% end %>
+
+  <div class="paging clear">
+    <%= render :partial => 'pagination', :locals => {:total_entries => @total_entries, :per_page => per_page} %>
+  </div>
+
+</div>