translation_engine 0.0.1

data/app/models/translation_engine/backend.rb

@@ -0,0 +1,79 @@
+class TranslationEngine::Backend < I18n::Backend::Simple
+
+  IGNORE_KEYS = %i(faker order)
+
+  def reload!
+    super
+    init_translations
+    release == 'master' ? download_master : download_release
+  end
+
+  def release=(release)
+    @release = release
+    reload!
+    release
+  end
+
+  def release
+    @release ||= 'master'
+  end
+
+  def releases
+    [TranslationEngine::Release.master] | connection.get_releases
+  end
+
+  def current_locale_releases
+    releases.select(&:current_locale?)
+  end
+
+  protected
+
+  def connection
+    @connection ||= TranslationEngine::Connection.new
+  end
+
+  def download_master
+    if (yml_data = connection.get_translations.body)
+      Rails.logger.info { 'Updating from translation server - master' }
+      YAML.load(yml_data).each do |locale, translations|
+        store_translations locale, translations
+      end
+    end
+  end
+
+  def download_release
+    if (yml_data = connection.get_release(release).body)
+      Rails.logger.info { "Updating from translation server - #{release}" }
+      YAML.load(yml_data).each do |locale, translations|
+        store_translations locale, translations
+      end
+    end
+  end
+
+  def lookup(locale, key, scope = [], options = {})
+    keys = I18n.normalize_keys(locale, key, scope, options[:separator])
+    resolved = super
+    if resolved
+      enhance_translation(resolved, keys)
+    else
+      resolved
+    end
+  end
+
+  def enhance_translation(value, main_keys, catch_translation = true)
+    return value if (main_keys & IGNORE_KEYS).any?
+
+    case value
+    when Array
+      TranslationEngine::Translation.catch(value, main_keys)
+      value.map { |v| enhance_translation(v, main_keys, false) }
+    when Hash
+      Hash[value.map { |k, v| [k, enhance_translation(v, main_keys + [k])] }]
+    when String
+      TranslationEngine::Translation.new(value, main_keys).to_s
+    else
+      TranslationEngine::Translation.catch(value, main_keys) if catch_translation
+      value
+    end
+  end
+end

data/app/models/translation_engine/connection.rb

@@ -0,0 +1,75 @@
+require 'faraday'
+
+class TranslationEngine::Connection
+
+  NotFound = Class.new(Exception)
+
+  def send_images(data)
+    connection.post do |req|
+      req.url '/api/v1/images'
+      req.headers['Content-Type']  = 'application/json'
+      req.headers['Authorization'] = api_token
+      req.body = data.to_json
+    end
+  end
+
+  def send_translations(data)
+    connection.post do |req|
+      req.url '/api/v1/translations'
+      req.headers['Content-Type']  = 'application/json'
+      req.headers['Authorization'] = api_token
+      req.body = data.to_json
+    end
+  end
+
+  def get_releases
+    response = connection.get do |req|
+      req.url '/api/v1/releases.json'
+      req.headers['Authorization'] = api_token
+    end
+
+    JSON.parse(response.body).with_indifferent_access[:releases].map do |args|
+      TranslationEngine::Release.new args
+    end
+  end
+
+  def get_release(version)
+    response = connection.get do |req|
+      req.url "/api/v1/releases/#{version}.yaml"
+      req.headers['Authorization'] = api_token
+    end
+
+    raise NotFound, "Release #{version} Not found" if response.status != 200
+
+    response
+  end
+
+  def get_translations
+    connection.get do |req|
+      req.url '/api/v1/translations.yaml'
+      req.headers['Authorization'] = api_token
+    end
+  end
+
+  def get_translations_head
+    connection.head do |req|
+      req.url '/api/v1/translations.yaml'
+      req.headers['Authorization'] = api_token
+    end
+  end
+
+  private
+
+  def connection
+    @connection ||= Faraday.new(:url => TranslationEngine.api_host) do |faraday|
+      faraday.use TranslationEngine::ConnectionExceptionMiddleware
+      faraday.adapter Faraday.default_adapter
+      faraday.options.timeout      = TranslationEngine.timeout
+      faraday.options.open_timeout = TranslationEngine.timeout * 4
+    end
+  end
+
+  def api_token
+    "Token token=#{TranslationEngine.api_key}"
+  end
+end

data/app/models/translation_engine/connection_error.rb

@@ -0,0 +1,2 @@
+class TranslationEngine::ConnectionError < TranslationEngine::Error
+end

data/app/models/translation_engine/downloader.rb

@@ -0,0 +1,72 @@
+require 'fileutils'
+
+class TranslationEngine::Downloader
+
+  def self.etag?(etag)
+    response = @current_etag == etag
+    Rails.logger.info { "Translations are up to date" } if response
+    @current_etag = etag
+    response
+  end
+
+  def update
+    return nil if self.class.etag?(connection.get_translations_head[:etag])
+    I18n.backend.reload!
+  end
+
+  def store
+    if (yml_data = receive_translations)
+      Rails.logger.info { "Storing translations to #{locale_file}" }
+      write(locale_file, yml_data)
+      add_translation_file_to_i18n
+      I18n.backend.reload!
+    end
+  end
+
+  def store_release(release)
+    locale = release.split('_')[0...-1].join('_')
+    filename = releases_dir.join("#{locale.downcase}.yml")
+    if (yml_data = connection.get_release(release).body)
+      Rails.logger.info { "Storing release #{release} to #{filename}" }
+      write(filename, yml_data)
+    end
+  end
+
+  private
+
+  def add_translation_file_to_i18n
+    unless I18n.load_path.include?(locale_file)
+      I18n.load_path += [locale_file]
+    end
+  end
+
+  def connection
+    @connection ||= TranslationEngine::Connection.new
+  end
+
+  def locale_dir
+    Rails.root.join('config', 'locales')
+  end
+
+  def locale_file
+    locale_dir.join('z_translation_engine.yml')
+  end
+
+  def receive_translations
+    return if self.class.etag?(connection.get_translations_head[:etag])
+
+    connection.get_translations.body
+  end
+
+  def releases_dir
+    dir = Rails.root.join('config', 'locales', 'z_releases')
+    FileUtils.mkdir_p(dir) unless File.exists?(dir)
+    dir
+  end
+
+  def write(filename, data)
+    File.open(filename, 'wb') do |f|
+      f.write data
+    end
+  end
+end

data/app/models/translation_engine/error.rb

@@ -0,0 +1,2 @@
+class TranslationEngine::Error < StandardError
+end

data/app/models/translation_engine/release.rb

@@ -0,0 +1,26 @@
+class TranslationEngine::Release
+
+  attr_accessor :version, :locale, :created_at
+
+  def self.master
+    new(
+      version:    'master',
+      locale:     'all',
+      created_at: Time.now.to_s
+    )
+  end
+
+  def initialize(args)
+    @version    = args[:version]
+    @locale     = args[:locale]
+    @created_at = Time.parse(args[:created_at])
+  end
+
+  def current_locale?
+    I18n.locale.to_s == @locale || @locale == 'all'
+  end
+
+  def current?
+    I18n.backend.release == @version
+  end
+end

data/app/models/translation_engine/translation.rb

@@ -0,0 +1,67 @@
+class TranslationEngine::Translation
+
+  def self.catched
+    @catched ||= []
+  end
+
+  def self.clear_catched
+    @catched = []
+  end
+
+  def self.catch(text, keys)
+    if text.is_a?(Hash)
+      text.each do |key, value|
+        TranslationEngine::Translation.catch(value, keys + [key])
+      end
+    else
+      catch_basic_value(text, keys)
+    end
+  end
+
+  def self.catch_basic_value(text, keys)
+    catched << {
+      data_type: data_type(text),
+      key:       keys.join('.'),
+      text:      normalize_for_translation_server(text)
+    }
+  end
+
+  def self.normalize_for_translation_server(value)
+    if value.is_a?(Array)
+      YAML.dump(value).gsub("---\n", '')
+    else
+      value
+    end
+  end
+
+  def self.data_type(text)
+    case text
+    when Array      then 'array'
+    when String     then 'string'
+    when Float      then 'float'
+    when Integer    then 'integer'
+    when TrueClass  then 'boolean'
+    when FalseClass then 'boolean'
+    when Symbol     then 'symbol'
+    else nil
+    end
+  end
+
+  def initialize(text, keys)
+    @text = text
+    @keys = keys
+    self.class.catch(@text, @keys)
+  end
+
+  def full_key
+    @keys.join('.') rescue ''
+  end
+
+  def to_s
+    if TranslationEngine.use_screenshots && @text.is_a?(String)
+      "--TRANSLATION--#{full_key}--#{@text}"
+    else
+      @text
+    end
+  end
+end

data/config/initializers/translation_engine.rb

@@ -0,0 +1,8 @@
+TranslationEngine.config do |config|
+  config.api_key  = '4e75310553e4523c0e015606343e01c5'
+  config.api_host = 'http://127.0.0.1:3000'
+  config.use_screenshots  = false
+  config.use_catcher      = false
+  config.timeout          = 5
+  config.raise_exceptions = Rails.env.development?
+end

data/lib/tasks/translation_engine_tasks.rake

@@ -0,0 +1,83 @@
+namespace :translation_engine do
+  namespace :pull do
+
+    desc 'Download all master translations from Translations server and ' +
+         'store them into config/locales/z_translation_engine.yml'
+    task master: :environment do
+      TranslationEngine::Downloader.new.store
+      puts 'Downloaded translations to: config/locales/z_translation_engine.yml'
+    end
+
+    desc 'Download released translations from Translations server and ' +
+         'store them into config/locales/z_releases/LOCALE.yml, ' +
+         'will overwrite previous locale release, leaving allways only one.'
+    task release: :environment do
+      Rails.logger = Logger.new(STDOUT)
+      TranslationEngine::Downloader.new.store_release(ENV['RELEASE'])
+    end
+  end
+
+  namespace :list do
+    desc 'List all available releases from Translations Server'
+    task releases: :environment do
+      puts "Listing releases from: #{TranslationEngine.api_host}"
+      releases = TranslationEngine::Connection.new.get_releases
+
+      releases_hash = Hash.new { |h, k| h[k] = [] }
+
+      releases.each_with_object(releases_hash) do |release, hash|
+        hash[release.locale] << release
+      end
+
+      releases_hash.each do |locale, releases|
+        puts "LOCALE: #{locale}"
+        releases.each do |release|
+          print "  #{release.version} - #{release.created_at}"
+          print ' -> `rake translation_engine:pull:release '
+          puts "RELEASE=#{release.version}`"
+        end
+      end
+    end
+  end
+
+  desc 'Send all translations from directory config/locales/LOCALE ' +
+       'to translations server'
+  task push: :environment do
+    locale = ENV['LOCALE'] || 'default'
+    puts "\nLOCALE: #{locale}"
+
+    TranslationEngine.timeout = 1000
+
+    def to_dotted_hash(hash, recursive_key = [])
+      hash.each_with_object({}) do |(k, v), ret|
+        key = recursive_key + [k]
+        if v.is_a? Hash
+          ret.merge! to_dotted_hash(v, key)
+        else
+          ret[key] = v
+        end
+      end
+    end
+    dir = Rails.root.join('config', 'locales')
+
+    Dir[dir.join "#{locale}/**/*.{yml}"].each do |file|
+      unless file.include?('faker')
+        hash = YAML.load_file(file) || {}
+        to_dotted_hash(hash).each do |keys, text|
+          Translation.catch text, keys
+        end
+      end
+    end
+
+    if Translation.catched.any?
+      data = {
+        locale:       locale,
+        translations: Translation.catched.uniq
+      }
+      puts "Send #{Translation.catched.size} translations"
+      Connection.new.send_translations(data)
+    else
+      puts "No translations was found and send"
+    end
+  end
+end

data/lib/translation_engine.rb

@@ -0,0 +1,10 @@
+require "translation_engine/engine"
+
+module TranslationEngine
+  mattr_accessor :api_key, :api_host, :timeout,
+                 :use_screenshots, :use_catcher, :raise_exceptions
+
+ def self.config
+    yield self
+  end
+end

data/lib/translation_engine/engine.rb

@@ -0,0 +1,32 @@
+require 'rails-assets-html2canvas'
+
+module TranslationEngine
+  class Engine < ::Rails::Engine
+    isolate_namespace TranslationEngine
+
+    initializer "translation_engine.middlewares" do |app|
+      app.config.app_middleware.use TranslationEngine::CatcherMiddleware
+      app.config.app_middleware.use TranslationEngine::KeysMiddleware
+      app.config.app_middleware.use TranslationEngine::ScreenshotsMiddleware
+    end
+
+    initializer "translation_engine.assets.precompile" do |app|
+      app.config.assets.precompile += %w(
+        translation_engine/screenshots.css
+        translation_engine/screenshots.js
+      )
+      %w(stylesheets javascripts).each do |sub|
+        app.config.assets.paths << root.join('app', 'assets', sub).to_s
+      end
+    end
+
+    if !Rails.const_defined?('Console')
+      config.after_initialize do |app|
+        if TranslationEngine.use_catcher || TranslationEngine.use_screenshots
+          I18n.backend = TranslationEngine::Backend.new
+        end
+      end
+    end
+  end
+end
+