translate-rails3 0.1.0

data/lib/translate/log.rb

@@ -0,0 +1,35 @@
+class Translate::Log
+  attr_accessor :from_locale, :to_locale, :keys
+  
+  def initialize(from_locale, to_locale, keys)
+    self.from_locale = from_locale
+    self.to_locale = to_locale
+    self.keys = keys
+  end
+  
+  def write_to_file
+    current_texts = File.exists?(file_path) ? file.read : {}
+    current_texts.merge!(from_texts)
+    file.write(current_texts)
+  end
+
+  def read
+    file.read
+  end
+
+  private
+  def file
+    @file ||= Translate::File.new(file_path)    
+  end
+  
+  def from_texts
+    Translate::File.deep_stringify_keys(Translate::Keys.to_deep_hash(keys.inject({}) do |hash, key|
+      hash[key] = I18n.backend.send(:lookup, from_locale, key)
+      hash
+    end))
+  end
+  
+  def file_path
+    File.join(Rails.root, "config", "locales", "log", "from_#{from_locale}_to_#{to_locale}.yml")
+  end
+end

data/lib/translate/routes.rb

@@ -0,0 +1,11 @@
+module Translate
+  class Routes
+    def self.translation_ui(map)
+      map.with_options(:controller => 'translate') do |t|
+        t.translate_list 'translate'
+        t.translate 'translate/translate', :action => 'translate'
+        t.translate_reload 'translate/reload', :action => 'reload'
+      end
+    end
+  end
+end

data/lib/translate/storage.rb

@@ -0,0 +1,28 @@
+class Translate::Storage
+  attr_accessor :locale
+  
+  def initialize(locale)
+    self.locale = locale.to_sym
+  end
+  
+  def write_to_file
+    Translate::File.new(file_path).write(keys)
+  end
+  
+  def self.file_paths(locale)
+    Dir.glob(File.join(root_dir, "config", "locales", "**","#{locale}.yml"))
+  end
+  
+  def self.root_dir
+    Rails.root
+  end
+  
+  private
+  def keys
+    {locale => I18n.backend.send(:translations)[locale]}
+  end
+  
+  def file_path
+    File.join(Translate::Storage.root_dir, "config", "locales", "#{locale}.yml")
+  end
+end

data/spec/controllers/translate_controller_spec.rb

@@ -0,0 +1,130 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe TranslateController do
+  describe "index" do
+    before(:each) do
+      controller.stub!(:per_page).and_return(1)
+      I18n.backend.stub!(:translations).and_return(i18n_translations)
+      I18n.backend.instance_eval { @initialized = true }
+      keys = mock(:keys)
+      keys.stub!(:i18n_keys).and_return(['vendor.foobar'])
+      Translate::Keys.should_receive(:new).and_return(keys)
+      Translate::Keys.should_receive(:files).and_return(files)
+      I18n.stub!(:available_locales).and_return([:en, :sv])
+      I18n.stub!(:default_locale).and_return(:sv)
+    end
+    
+    it "shows sorted paginated keys from the translate from locale and extracted keys by default" do
+      get_page :index
+      assigns(:from_locale).should == :sv
+      assigns(:to_locale).should == :en
+      assigns(:files).should == files
+      assigns(:keys).sort.should == ['articles.new.page_title', 'home.page_title', 'vendor.foobar']
+      assigns(:paginated_keys).should == ['articles.new.page_title']
+    end
+
+    it "can be paginated with the page param" do
+      get_page :index, :page => 2
+      assigns(:files).should == files
+      assigns(:paginated_keys).should == ['home.page_title']      
+    end
+    
+    it "accepts a key_pattern param with key_type=starts_with" do
+      get_page :index, :key_pattern => 'articles', :key_type => 'starts_with'
+      assigns(:files).should == files
+      assigns(:paginated_keys).should == ['articles.new.page_title']
+      assigns(:total_entries).should == 1
+    end
+
+    it "accepts a key_pattern param with key_type=contains" do
+      get_page :index, :key_pattern => 'page_', :key_type => 'contains'
+      assigns(:files).should == files
+      assigns(:total_entries).should == 2
+      assigns(:paginated_keys).should == ['articles.new.page_title']
+    end
+
+    it "accepts a filter=untranslated param" do
+      get_page :index, :filter => 'untranslated'
+      assigns(:total_entries).should == 2
+      assigns(:paginated_keys).should == ['articles.new.page_title']
+    end
+    
+    it "accepts a filter=translated param" do
+      get_page :index, :filter => 'translated'
+      assigns(:total_entries).should == 1
+      assigns(:paginated_keys).should == ['vendor.foobar']
+    end
+    
+    it "accepts a filter=changed param" do
+      log = mock(:log)
+      old_translations = {:home => {:page_title => "Skapar ny artikel"}}
+      log.should_receive(:read).and_return(Translate::File.deep_stringify_keys(old_translations))
+      Translate::Log.should_receive(:new).with(:sv, :en, {}).and_return(log)      
+      get_page :index, :filter => 'changed'
+      assigns(:total_entries).should == 1
+      assigns(:keys).should == ["home.page_title"]
+    end
+
+    def i18n_translations
+      HashWithIndifferentAccess.new({
+        :en => {
+          :vendor => {
+            :foobar => "Foo Baar"
+          }
+        },
+        :sv => {
+          :articles => {
+            :new => {
+              :page_title => "Skapa ny artikel"
+            }
+          },
+          :home => {
+            :page_title => "Välkommen till I18n"
+          },
+          :vendor => {
+            :foobar => "Fobar"
+          }
+        }
+      })
+    end
+    
+    def files
+      HashWithIndifferentAccess.new({
+        :'home.page_title' => ["app/views/home/index.rhtml"],
+        :'general.back' => ["app/views/articles/new.rhtml", "app/views/categories/new.rhtml"],
+        :'articles.new.page_title' => ["app/views/articles/new.rhtml"]
+      })
+    end
+  end
+  
+  describe "translate" do
+    it "should store translations to I18n backend and then write them to a YAML file" do
+      session[:from_locale] = :sv
+      session[:to_locale] = :en
+      translations = {
+        :articles => {
+          :new => {
+            :title => "New Article"
+          }
+        },
+        :category => "Category"
+      }
+      key_param = {'articles.new.title' => "New Article", "category" => "Category"}
+      I18n.backend.should_receive(:store_translations).with(:en, translations)
+      storage = mock(:storage)
+      storage.should_receive(:write_to_file)
+      Translate::Storage.should_receive(:new).with(:en).and_return(storage)
+      log = mock(:log)
+      log.should_receive(:write_to_file)
+      Translate::Log.should_receive(:new).with(:sv, :en, key_param.keys).and_return(log)
+      post :translate, "key" => key_param
+      response.should be_redirect
+    end
+  end
+  
+  def get_page(*args)
+    get(*args)
+    response.should be_success
+  end
+end

data/spec/file_spec.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Translate::File do
+  describe "write" do
+    before(:each) do
+      @file = Translate::File.new(file_path)
+    end
+
+    after(:each) do
+      FileUtils.rm(file_path)
+    end
+    
+    it "writes all I18n messages for a locale to YAML file" do
+      @file.write(translations)
+      @file.read.should == Translate::File.deep_stringify_keys(translations)
+    end
+
+    def translations
+      {
+        :en => {
+          :article => {
+            :title => "One Article"
+          },
+          :category => "Category"
+        }
+      }
+    end
+  end
+  
+  describe "deep_stringify_keys" do
+    it "should convert all keys in a hash to strings" do
+      Translate::File.deep_stringify_keys({
+        :en => {
+          :article => {
+            :title => "One Article"
+          },
+          :category => "Category"
+        }
+      }).should == {
+        "en" => {
+          "article" => {
+            "title" => "One Article"
+          },
+          "category" => "Category"
+        }
+      }
+    end
+  end
+
+  def file_path
+    File.join(File.dirname(__FILE__), "files", "en.yml")
+  end  
+end

data/spec/files/translate/app/models/article.rb

@@ -0,0 +1,12 @@
+class Article < ActiveRecord::Base
+  def validate
+    # t('li')
+    errors.add_to_base([t(:'article.key1') + "#{t('article.key2')}"])
+    I18n.t 'article.key3'
+    I18n.t 'article.key3'
+    I18n.t :'article.key4'
+    I18n.translate :'article.key5'
+    'bla bla t' + "blubba bla" + ' foobar'
+    'bla bla t ' + "blubba bla" + ' foobar'
+  end
+end

data/spec/files/translate/app/views/category.erb

@@ -0,0 +1 @@
+<%= t(:'category_erb.key1') %>

data/spec/files/translate/app/views/category.html

@@ -0,0 +1 @@
+t(:'category_html.key1')

data/spec/files/translate/app/views/category.html.erb

@@ -0,0 +1 @@
+<%= t(:'category_html_erb.key1') %>

data/spec/files/translate/app/views/category.rhtml

@@ -0,0 +1,5 @@
+<script>
+  document.createElement('li');
+</script>
+
+<%= t(:'category_rhtml.key1') %>

data/spec/files/translate/public/javascripts/application.js

@@ -0,0 +1 @@
+I18n.t('js.alert')

data/spec/keys_spec.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'fileutils'
+
+describe Translate::Keys do
+  before(:each) do
+    I18n.stub!(:default_locale).and_return(:en)      
+    @keys = Translate::Keys.new
+    Translate::Storage.stub!(:root_dir).and_return(i18n_files_dir)
+  end
+  
+  describe "to_a" do
+    it "extracts keys from I18n lookups in .rb, .html.erb, and .rhtml files" do
+      @keys.to_a.map(&:to_s).sort.should == ['article.key1', 'article.key2', 'article.key3', 'article.key4', 'article.key5',
+        'category_erb.key1', 'category_html_erb.key1', 'category_rhtml.key1', 'js.alert']
+    end
+  end
+  
+  describe "to_hash" do
+    it "return a hash with I18n keys and file lists" do
+      @keys.to_hash[:'article.key3'].should == ["vendor/plugins/translate/spec/files/translate/app/models/article.rb"]      
+    end
+  end
+
+  describe "i18n_keys" do
+    before(:each) do
+      I18n.backend.send(:init_translations) unless I18n.backend.initialized?
+    end
+    
+    it "should return all keys in the I18n backend translations hash" do
+      I18n.backend.should_receive(:translations).and_return(translations)
+      @keys.i18n_keys(:en).should == ['articles.new.page_title', 'categories.flash.created', 'empty', 'home.about']
+    end
+    
+  describe "untranslated_keys" do
+    before(:each) do
+      I18n.backend.stub!(:translations).and_return(translations)
+    end
+    
+    it "should return a hash with keys with missing translations in each locale" do
+      @keys.untranslated_keys.should == {
+        :sv => ['articles.new.page_title', 'categories.flash.created', 'empty']
+      }
+    end
+  end
+  
+  describe "missing_keys" do
+    before(:each) do
+      @file_path = File.join(i18n_files_dir, "config", "locales", "en.yml")
+      Translate::File.new(@file_path).write({
+        :en => {
+          :home => {
+            :page_title => false,
+            :intro => {
+              :one => "intro one",
+              :other => "intro other"
+            }
+          }
+        }
+      })
+    end
+    
+    after(:each) do
+      FileUtils.rm(@file_path)
+    end
+    
+    it "should return a hash with keys that are not in the locale file" do
+      @keys.stub!(:files).and_return({
+        :'home.page_title' => "app/views/home/index.rhtml",
+        :'home.intro' => 'app/views/home/index.rhtml',
+        :'home.signup' => "app/views/home/_signup.rhtml",
+        :'about.index.page_title' => "app/views/about/index.rhtml"
+      })
+      @keys.missing_keys.should == {
+        :'home.signup' => "app/views/home/_signup.rhtml",
+        :'about.index.page_title' => "app/views/about/index.rhtml"        
+      }
+    end
+  end
+
+  describe "contains_key?" do
+    it "works" do
+      hash = {
+        :foo => {
+          :bar => {
+            :baz => false
+          }
+        }
+      }
+      Translate::Keys.contains_key?(hash, "").should be_false
+      Translate::Keys.contains_key?(hash, "foo").should be_true
+      Translate::Keys.contains_key?(hash, "foo.bar").should be_true
+      Translate::Keys.contains_key?(hash, "foo.bar.baz").should be_true
+      Translate::Keys.contains_key?(hash, :"foo.bar.baz").should be_true
+      Translate::Keys.contains_key?(hash, "foo.bar.baz.bla").should be_false
+    end
+  end
+  
+  describe "translated_locales" do
+    before(:each) do
+      I18n.stub!(:default_locale).and_return(:en)
+      I18n.stub!(:available_locales).and_return([:sv, :no, :en, :root])
+    end
+    
+    it "returns all avaiable except :root and the default" do
+      Translate::Keys.translated_locales.should == [:sv, :no]
+    end
+  end
+  
+  describe "to_deep_hash" do
+    it "convert shallow hash with dot separated keys to deep hash" do
+      Translate::Keys.to_deep_hash(shallow_hash).should == deep_hash
+    end
+  end
+  
+  describe "to_shallow_hash" do
+    it "converts a deep hash to a shallow one" do
+      Translate::Keys.to_shallow_hash(deep_hash).should == shallow_hash
+    end
+  end
+
+  ##########################################################################
+  #
+  # Helper Methods
+  #
+  ##########################################################################
+
+    def translations
+      {
+        :en => {
+          :home => {
+            :about => "This site is about making money"
+          },
+          :articles => {
+           :new => {
+             :page_title => "New Article"
+            }
+          },
+          :categories => {
+            :flash => {
+             :created => "Category created"  
+            }
+          },
+          :empty => nil
+        },
+        :sv => {
+          :home => {
+            :about => false
+          }
+        }
+      }
+    end
+  end
+  
+  def shallow_hash
+    {
+      'pressrelease.label.one' => "Pressmeddelande",
+      'pressrelease.label.other' => "Pressmeddelanden",
+      'article' => "Artikel",
+      'category' => ''
+    }    
+  end
+  
+  def deep_hash
+    {
+      :pressrelease => {
+        :label => {
+          :one => "Pressmeddelande",
+          :other => "Pressmeddelanden"
+        }
+      },
+      :article => "Artikel",
+      :category => ''
+    }    
+  end
+  
+  def i18n_files_dir
+    File.join(ENV['PWD'], "spec", "files", "translate")
+  end
+end