interpret 0.1.1

data/.gitignore

@@ -0,0 +1,11 @@
+pkg/*
+*.gem
+.bundle
+
+Gemfile.lock
+.DS_Store
+test_app/.bundle
+test_app/db/*.sqlite3
+test_app/log/*.log
+test_app/tmp/**/*
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in interpret.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/controllers/interpret/base_controller.rb

@@ -0,0 +1,10 @@
+class Interpret::BaseController < eval(Interpret.controller.classify)
+  before_filter :set_locale
+  layout 'interpret'
+
+private
+  def set_locale
+    I18n.locale = params[:locale] if params[:locale]
+  end
+end
+

data/app/controllers/interpret/search_controller.rb

@@ -0,0 +1,7 @@
+class Interpret::SearchController < Interpret::BaseController
+
+  def perform
+    t = Interpret::Translation.arel_table
+    @translations = Interpret::Translation.locale(I18n.locale).where(t[:key].matches("%#{params[:key]}%").and(t[:value].matches("%#{params[:value]}%"))  )
+  end
+end

data/app/controllers/interpret/tools_controller.rb

@@ -0,0 +1,39 @@
+class Interpret::ToolsController < Interpret::BaseController
+
+  def dump
+    Interpret::Translation.dump
+
+    session.delete(:tree)
+    Interpret.backend.reload! if Interpret.backend
+    redirect_to interpret_tools_url, :notice => "Dump done."
+  end
+
+  def export
+    require 'ya2yaml'
+
+    translations = Interpret::Translation.locale(I18n.locale).all
+    hash = Interpret::Translation.export(translations)
+    text = hash.ya2yaml
+
+    send_data text[5..text.length], :filename => "#{I18n.locale}.yml"
+  end
+
+  def import
+    unless params.has_key? :file
+      redirect_to interpret_tools_url, :alert => "You have to select a file to import."
+      return
+    end
+
+    begin
+      Interpret::Translation.import(params[:file])
+    rescue Exception => e
+      redirect_to interpret_tools_url, :alert => e
+    end
+
+    session.delete(:tree)
+    Interpret.backend.reload! if Interpret.backend
+
+    redirect_to interpret_tools_url, :notice => "Import successfully done."
+  end
+end
+

data/app/controllers/interpret/translations_controller.rb

@@ -0,0 +1,47 @@
+class Interpret::TranslationsController < Interpret::BaseController
+  cache_sweeper eval(Interpret.sweeper.to_s.classify) if Interpret.sweeper
+  cache_sweeper Interpret::TranslationSweeper
+  before_filter :get_tree, :only => :index
+
+  def index
+    key = params[:key]
+    t = Interpret::Translation.arel_table
+    if key
+      @translations = Interpret::Translation.locale(I18n.locale).where(t[:key].matches("#{key}.%"))
+      @translations = @translations.select{|x| x.key =~ /#{key}\.\w+$/}
+    else
+      @translations = Interpret::Translation.locale(I18n.locale).where(t[:key].does_not_match("%.%")).paginate :page => params[:page]
+    end
+  end
+
+  def edit
+    @translation = Interpret::Translation.find(params[:id])
+  end
+
+  def update
+    @translation = Interpret::Translation.find(params[:id])
+    old_value = @translation.value
+
+    respond_to do |format|
+      if @translation.update_attributes(params[:interpret_translation])
+        msg = respond_to?(:current_user) ? "By [#{current_user}]. " : ""
+        msg << "Locale: [#{@translation.locale}], key: [#{@translation.key}]. The translation has been changed from [#{old_value}] to [#{@translation.value}]"
+        Interpret.logger.info msg
+
+        format.html { redirect_to(translations_url)}
+        format.xml  { head :ok }
+        format.json { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @translation.errors, :status => :unprocessable_entity }
+        format.json { render :status => :unprocessable_entity }
+      end
+    end
+  end
+
+private
+  def get_tree
+    @tree = session[:tree] ||= Interpret::Translation.get_tree
+  end
+
+end

data/app/models/interpret/translation.rb

@@ -0,0 +1,257 @@
+require 'i18n/backend/active_record/translation'
+
+
+module Interpret
+
+  class TableDoesNotExists < ActiveRecord::ActiveRecordError; end
+
+  unless I18n::Backend::ActiveRecord::Translation.table_exists?
+    raise TableDoesNotExists, "You must setup a translations table first"
+  end
+
+  class Translation < I18n::Backend::ActiveRecord::Translation
+    default_scope order('locale ASC')
+
+    class << self
+      # Generates a hash representing the tree structure of the translations
+      # for the given locale. It includes only "folders" in the sense of
+      # locale keys that includes some real translations, or other keys.
+      def get_tree(lang = I18n.locale)
+        t = arel_table
+        all_trans = locale(lang).select(t[:key]).where(t[:key].matches("%.%")).all
+
+        tree = LazyHash.build_hash
+        all_trans = all_trans.map{|x| x.key.split(".")[0..-2].join(".")}.uniq
+        all_trans.each do |x|
+          LazyHash.lazy_add(tree, x, {})
+        end
+
+        # Generate a new clean hash without the proc's from LazyHash.
+        # Includes a root level for convenience, to be exactly like the
+        # structure of a .yml file which has the "en" root key for example.
+        {"index" => eval(tree.inspect)}
+      end
+
+      # Generate a hash from the given translations. That hash can be
+      # ya2yaml'ized to get a standard .yml locale file.
+      def export(translations)
+        res = LazyHash.build_hash
+
+        translations.each do |e|
+          LazyHash.lazy_add(res, "#{e.locale}.#{e.key}", e.value)
+        end
+        res
+      end
+
+      # Import the contents of the given .yml locale file into the database
+      # backend. All the existing translations for the given language will be
+      # erased, the backend will contain only the translations from the file
+      # (in that language).
+      #
+      # The language will be obtained from the first unique key of the yml
+      # file.
+      def import(file)
+        if file.content_type && file.content_type.match(/^text\/.*/).nil?
+          raise ArgumentError, "Invalid file content type"
+        end
+        hash = YAML.load file
+        raise ArgumentError, "the YAML file must contain an unique first key representing the locale" unless hash.keys.count == 1
+
+        lang = hash.keys.first
+        to_remove = locale(lang).all
+        to_remove.each do |x|
+          x.destroy
+        end
+        records = parse_hash(hash.first[1], lang)
+        # TODO: Replace with activerecord-import bulk inserts
+        transaction do
+          records.each {|x| x.save!}
+        end
+      end
+
+      # Dump all contents from *.yml locale files into the database.
+      # CAUTION: All existing data will be erased!
+      #
+      # It will create a "#{locale}.yml.backup" file into config/locales
+      # for each language present in the database, in case you want to
+      # recover some of your just-erased translations.
+      # If you don't want backups, set:
+      #
+      # Interpret.options[:dump_without_backup] = true
+      def dump
+        files = Dir[Rails.root.join("config", "locales", "*.yml").to_s]
+        delete_all
+
+        records = []
+        files.each do |f|
+          ar = YAML.load_file f
+          locale = ar.keys.first
+          records += parse_hash(ar.first[1], locale)
+        end
+
+        # TODO: Replace with activerecord-import bulk inserts
+        transaction do
+          records.each {|x| x.save!}
+        end
+      end
+
+      # Run a smart update from the translations in .yml files into the
+      # databse backend. It issues a merging from both, comparing each key
+      # present in the db with the one from the yml file.
+      #
+      # The use case beyond this arquitecture presuposes some things:
+      #
+      # 1) You're working in development mode with the default I18n backend,
+      # that is with the translations in the config/locales/*.yml files.
+      #
+      # 2) Your application is deployed in production and running well. Also,
+      # it has support to modify it's contents (from this very gem of course)
+      # on live, so its possible that your customer has changed a sentence or
+      # a title of the site. And you want to preserve that.
+      #
+      # 3) In general, from the very moment you choose to give the users (or
+      # admins) of your site the ability to change the contents, that contents
+      # are no longer part of the "project" (are checked in in git, to be
+      # specific), they are now part of the dynamic contents of the site just
+      # as if they were models in your db.
+      #
+      # In development, you define a "content layout" in the sense of a
+      # specific locale keys hierarchy. How many paragraphs are in your views,
+      # how many titles, etc... But the real paragraphs are in the production
+      # database.
+      #
+      # So, with this "update" action, you are updating that "contents layout"
+      # with the new one you just designed in development.
+      #
+      # Also keep in mind that rails let you have a diferent locale key
+      # hierarchy for each language, and this behaviour is prohibited in
+      # interpret.
+      # Here, the I18n.default_locale configured in your app is considered the
+      # main one, that is, the only language that can be trusted to have all
+      # the required and correct locale keys.
+      # This will be used to check for inconsitent translations into other
+      # languages, knowing what you haven't translated yet.
+      #
+      # What does all that means?
+      #
+      # - First of all, get the locale keys for the main language from yml files.
+      # - For all of these locale keys, do:
+      #   - If a key is present in the db, but not in the new ones, remove
+      #   it. You have removed it from the new content layout, so it's no longer
+      #   needed.
+      #   - If the key is not present in the db, it's new. So, create a new
+      #   entry for that key in each language. Look if a translation for that
+      #   key exists in yml files for each language, if it exists, use it. If
+      #   not, left it empty.
+      #   - If the key already exists in the db, do nothing. Maybe somone has
+      #   changed that content in production, and you don't want to lose
+      #   that. Or maybe you do want to change that content, because you
+      #   just added the correct sentence in the yml files. It's up to you to
+      #   do the right thing.
+      def update
+        files = Dir[Rails.root.join("config", "locales", "*.yml").to_s]
+
+        @languages = {}
+        @main = {}
+        files.each do |f|
+          ar = YAML.load_file f
+          lang = ar.keys.first
+          @languages[lang.to_s] = ar.first[1]
+          if I18n.default_locale.to_s == lang.to_s
+            @main = ar.first[1]
+            @main_lang = lang
+          end
+        end
+
+        sync(@main)
+      end
+
+    private
+      def sync(hash, prefix = "", existing = nil)
+        if existing.nil?
+          translations = locale(@main_lang).all
+          existing = export(translations)
+          existing = existing.first[1] unless existing.empty?
+        end
+
+        hash.keys.each do |x|
+          existing.delete(x)
+
+          if hash[x].kind_of?(Hash)
+            sync(hash[x], "#{prefix}#{x}.", existing[x])
+          else
+            old = locale(@main_lang).find_by_key("#{prefix}#{x}")
+
+            unless old
+              # Creates the new entry
+              create_new_translation("#{prefix}#{x}")
+            else
+              # Check if the entry exists in the other languages
+              check_in_other_langs("#{prefix}#{x}")
+            end
+          end
+        end
+
+        if prefix.blank?
+          remove_unused_keys(existing)
+        end
+      end
+
+      # Check if the the given key exists in all languages except @main. If
+      # not, create an entry.
+      def check_in_other_langs(key)
+        (@languages.keys - [@main_lang]).each do |lang|
+          trans = locale(lang).find_by_key(key)
+          if trans.nil?
+            create! :locale => lang,
+                    :key => key,
+                    :value => ""
+            Interpret.logger.info "Created inexistent key [#{key}] for lang [#{lang}]"
+          end
+        end
+      end
+
+      def create_new_translation(key)
+        @languages.keys.each do |lang|
+          origin_hash = @languages[lang].clone
+          key.split(".")[0..-2].each do |key|
+            origin_hash = origin_hash[key]
+          end
+          value = origin_hash[key.split(".").last]
+          create! :locale => lang,
+                  :key => key,
+                  :value => value
+        end
+        Interpret.logger.info "New key created [#{key}] for languages #{@languages.keys.inspect}"
+      end
+
+      def remove_unused_keys(hash, prefix = "")
+        hash.keys.each do |x|
+          if hash[x].kind_of?(Hash)
+            remove_unused_keys(hash[x], "#{prefix}#{x}.")
+          else
+            delete_all(:locale => @languages.keys, :key => "#{prefix}#{x}")
+            Interpret.logger.info "Removing unused key #{prefix}#{x}"
+          end
+        end
+      end
+
+      def parse_hash(dict, locale, prefix = "")
+        res = []
+        dict.keys.each do |x|
+          if dict[x].kind_of?(Hash)
+            res += parse_hash(dict[x], locale, "#{prefix}#{x}.")
+          else
+            res << new(:locale => locale,
+                       :key => "#{prefix}#{x}",
+                       :value => dict[x])
+          end
+        end
+        res
+      end
+
+
+    end
+  end
+end
+

data/app/sweepers/interpret/base_sweeper.rb

@@ -0,0 +1,14 @@
+class Interpret::BaseSweeper < ActionController::Caching::Sweeper
+  observe Interpret::Translation
+
+  def after_update(translation)
+    expire_cache(translation)
+  end
+
+protected
+
+  # Implement user's custom expire logic
+  def expire_cache(translation)
+  end
+end
+

data/app/sweepers/interpret/translation_sweeper.rb

@@ -0,0 +1,14 @@
+class Interpret::TranslationSweeper < ActionController::Caching::Sweeper
+  observe Interpret::Translation
+
+  def after_update(translation)
+    Interpret.backend.reload! if Interpret.backend
+  end
+
+private
+  def expire_cache
+    #expire_action :controller => "interpret/translations", :action => :tree
+    session.delete(:tree)
+    Interpret.backend.reload! if Interpret.backend
+  end
+end

data/app/views/interpret/search/index.html.erb

@@ -0,0 +1,29 @@
+<div id="header">
+  <h1>Search translations</h1>
+</div>
+
+<div id="search">
+  <p>Enter a search term for the key and/or the value of the translation</p>
+
+  <%= form_tag interpret_search_for_path do %>
+    <%= label_tag "key", "Key value" %>
+    <br />
+    <%= text_field_tag "key" %>
+    <br />
+
+    <%= label_tag "value", "Translation text" %>
+    <br />
+    <%= text_field_tag "value" %>
+    <br />
+
+    <%= submit_tag "SEARCH" %>
+
+  <% end %>
+
+  <%= content_for :sidebar do %>
+    <h2>Search</h2>
+    <p>
+  You can use this search feature to look into all the translations. Can be filtered by language, key and phrase.
+    </p>
+  <% end %>
+</div>

data/app/views/interpret/search/perform.html.erb

@@ -0,0 +1,38 @@
+<%= content_for :title do %>
+  Search translations
+  <%= "by " unless params[:key].blank? && params[:value].blank? %>
+  <%= params[:key] unless params[:key].blank? %>
+  <%= "and " unless params[:key].blank? || params[:value].blank? %>
+  <%= params[:value] unless params[:value].blank? %>
+<% end %>
+
+<div id="header">
+  <h1>Search translations</h1>
+</div>
+
+
+<%= render 'interpret/translations/listing' %>
+
+
+<%= content_for :sidebar do %>
+  <h2>Search</h2>
+  <p>
+    <%= @translations.size %> results found.
+  </p>
+  <div id="side_search">
+    <%= form_tag interpret_search_for_path do %>
+      <%= label_tag "key", "Key value" %>
+      <br />
+      <%= text_field_tag "key", params[:key] %>
+      <br />
+
+      <%= label_tag "value", "Translation text" %>
+      <br />
+      <%= text_field_tag "value", params[:value] %>
+      <br />
+
+      <%= submit_tag "SEARCH" %>
+
+    <% end %>
+  </div>
+<% end %>

data/app/views/interpret/tools/index.html.erb

@@ -0,0 +1,38 @@
+<div class="header">
+  <h1>Your master language</h1>
+</div>
+<p>
+Currently your primary language is <b><%= I18n.default_locale %></b>. This
+language will be used as a reference for all your translation work, you
+can change it below:
+</p>
+<p><em>TODO</em></p>
+
+<div class="header">
+  <h1>Dump .yml contents into database</h1>
+</div>
+
+<p>With this option you can export all of your *.yml contents into the database backend<br/>
+<b>Be aware!!</b> All of your current database translations will be erased
+</p>
+
+<% if Rails.env == "production" %>
+  <p><b>MY GOD!!! You're in PRODUCTION!! You're sure you wanna do this??</b></p>
+<% end %>
+
+<p>
+<%= button_to "Run the migration", dump_interpret_tools_path %>
+</p>
+
+<div class="header">
+  <h1>Tools for import/export locale data</h1>
+</div>
+
+<p><%= link_to "Download", export_interpret_tools_path %> the current translations for '<%= I18n.locale %>' language as .yml file</p>
+<p>Upload your .yml file for '<%= I18n.locale %>' language</p>
+<p>
+<%= form_tag import_interpret_tools_path, :multipart => true do %>
+  <%= label_tag "File:" %>
+  <%= file_field_tag :file %>
+  <%= submit_tag "Upload" %>
+<% end %>

data/app/views/interpret/translations/_form.html.erb

@@ -0,0 +1,5 @@
+<%= form_for @translation, :url => translation_path(@translation) do |f| %>
+  <%= f.label :value %>
+  <%= f.text_field :value, :value => @translation.value %>
+  <%= f.submit %>
+<% end %>

data/app/views/interpret/translations/_listing.html.erb

@@ -0,0 +1,22 @@
+<table>
+  <thead>
+    <tr class="header">
+      <th>Key</th>
+      <th>Content</th>
+    </tr>
+  </thead>
+  <tbody>
+    <% @translations.each do |x| %>
+      <tr id="translation_<%= x.id %>">
+        <td><%= x.key %></td>
+        <td>
+          <%= best_in_place x, :value,
+              :type => :textarea,
+              :path => interpret_translation_path(x),
+              :activator => "#translation_#{x.id}",
+              :sanitize => false %>
+        </td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/app/views/interpret/translations/edit.html.erb

@@ -0,0 +1,5 @@
+<h1>[<%= I18n.locale %>] Editing '<%= @translation.key %>'</h1>
+
+<%= render 'form' %>
+
+<%= link_to "Back", translations_path %>

data/app/views/interpret/translations/index.html.erb

@@ -0,0 +1,28 @@
+<%= content_for :title do %>
+  Translation list
+<% end %>
+<div id="header">
+  <h1>Translations for <%= I18n.locale %></h1>
+</div>
+<p>
+Below are the translations without any particulary key in your application.
+That use to be some global names or terms for common use along all the site,
+which doesn't belong to any page or section in particulary. To dive into the
+rest of your app's contents, navigate using the tree in the left, that shows your
+locales structure.
+</p>
+
+<%= render 'interpret/translations/listing' %>
+
+<%= content_for :sidebar do %>
+  <div id="tree_sidebar">
+    <h3>
+      <% if params[:key] %>
+        /<%= params[:key].split(".").join("/") %>
+      <% else %>
+        /
+      <% end %>
+    </h3>
+    <%= show_interpret_tree(@tree, params[:key]) %>
+  </div>
+<% end %>

data/app/views/layouts/interpret.html.erb

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>INTERPRET - <%= yield :title %></title>
+  <%= stylesheet_link_tag "interpret_style" %>
+  <%= javascript_include_tag "https://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js" %>
+  <%= javascript_include_tag "jquery.purr" %>
+  <%= javascript_include_tag "best_in_place" %>
+  <%= csrf_meta_tag %>
+</head>
+<body>
+<div id="container">
+  <div class="menu grid_16">
+    <%= interpret_section_link_to "Overview", interpret_root_path %> |
+    <%= interpret_section_link_to "Tools", interpret_tools_path %> |
+    <%= interpret_section_link_to "Search", interpret_search_path %>
+    <hr />
+  </div>
+  <div class="menu grid_16">
+    Languages:
+    <% I18n.available_locales.each do |locale| %>
+      <%= link_to locale, :locale => locale %>
+    <% end %>
+    <hr />
+  </div>
+  <div id="sidebar" class="grid_3">
+    <%= yield :sidebar %>
+  </div>
+  <div id="main" class="grid_13">
+    <%= yield %>
+  </div>
+</div>
+
+<%= javascript_tag do %>
+  $(document).ready(function() {
+  /* Activating Best In Place */
+    jQuery(".best_in_place").best_in_place()
+  });
+<% end %>
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,20 @@
+Rails.application.routes.draw do
+  scope Interpret.scope do
+    namespace :interpret do
+      resources :translations, :only => [:edit, :update]
+
+      resources :tools, :only => :index do
+        collection do
+          get :export
+          post :import
+          post :dump
+        end
+      end
+
+      match "search", :to => "search#index"
+      match "search_for", :to => "search#perform"
+
+      root :to => "translations#index"
+    end
+  end
+end