localeapp 0.0.7

data/lib/locale_app/configuration.rb

@@ -0,0 +1,93 @@
+module LocaleApp
+  class Configuration
+  
+    # The API key for your project, found on the project edit form
+    attr_accessor :api_key
+
+    # The host to connect to (defaults to api.localeapp.com)
+    attr_accessor :host
+
+    # The port to connect to (defaults to 80)
+    attr_accessor :port
+
+    attr_accessor :http_auth_username
+    attr_accessor :http_auth_password
+
+    # The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # The path to the project in which the translation occurred, such as the
+    # RAILS_ROOT
+    attr_accessor :project_root
+
+    # The names of environments where notifications aren't sent (defaults to
+    # 'test', 'cucumber', 'production')
+    attr_accessor :disabled_sending_environments
+
+    # The names of environments where I18n.reload isn't called for each request
+    # (defaults to 'test', 'cucumber', 'production')
+    attr_accessor :disabled_reloading_environments
+
+    # The names of environments where updates aren't pulled (defaults to
+    # 'test', 'cucumber', 'production')
+    attr_accessor :disabled_polling_environments
+
+    # The logger used by LocaleApp
+    attr_accessor :logger
+
+    # The number of seconds to wait before asking the service for new
+    # translations (defaults to 0 - every request).
+    attr_accessor :poll_interval
+
+    # The complete path to the data file where we store synchronization
+    # information (defaults to ./locale_app.yml) local_app/rails overwrites
+    # this to RAILS_ROOT/log/locale_app.yml
+    attr_accessor :synchronization_data_file
+
+    # The complete path to the directory where translations are stored
+    attr_accessor :translation_data_directory
+
+    def initialize
+      @host                            = 'api.localeapp.com'
+      @port                            = 80
+      @disabled_sending_environments   = %w(test cucumber production)
+      @disabled_reloading_environments = %w(test cucumber production)
+      @disabled_polling_environments   = %w(test cucumber production)
+      @poll_interval                   = 0
+      @synchronization_data_file       = File.join('log', 'locale_app.yml')
+      @translation_data_directory      = File.join('config', 'locales')
+      if ENV['DEBUG']
+        require 'logger'
+        @logger = Logger.new(STDOUT)
+      end
+    end
+
+    def polling_disabled?
+      disabled_polling_environments.include?(environment_name)
+    end
+
+    def reloading_disabled?
+      disabled_reloading_environments.include?(environment_name)
+    end
+
+    def sending_disabled?
+      disabled_sending_environments.include?(environment_name)
+    end
+
+    def write_initial(path)
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir)
+      File.open(path, 'w+') do |file|
+        file.write <<-CONTENT
+require 'locale_app/rails'
+
+LocaleApp.configure do |config|
+  config.api_key = '#{@api_key}'
+  config.host = '#{@host}'
+  config.port = #{@port}
+end
+CONTENT
+      end
+    end
+  end
+end

data/lib/locale_app/exception_handler.rb

@@ -0,0 +1,21 @@
+module LocaleApp
+  class ExceptionHandler
+    def self.call(exception, locale, key, options)
+      LocaleApp.log(exception.message)
+      if I18n::MissingTranslationData === exception
+        LocaleApp.log("Detected missing translation for key(s) #{key.inspect}")
+
+        [*key].each do |key|
+          LocaleApp.missing_translations.add(locale, key, options)
+        end
+
+        [locale, key].join(', ')
+      else
+        LocaleApp.log('Raising exception')
+        raise
+      end
+    end
+  end
+end
+
+I18n.exception_handler = LocaleApp::ExceptionHandler

data/lib/locale_app/key_checker.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+require 'rest-client'
+require 'time'
+
+module LocaleApp
+  class KeyChecker
+    include ::LocaleApp::ApiCall
+
+    def check(key)
+      if LocaleApp.configuration.nil? # no config file yet
+        LocaleApp.configuration = LocaleApp::Configuration.new
+        LocaleApp.configuration.host = ENV['LA_TEST_HOST'] if ENV['LA_TEST_HOST']
+      end
+      LocaleApp.configuration.api_key = key
+      api_call :project,
+        :success => :handle_success,
+        :failure => :handle_failure,
+        :max_connection_attempts => 1
+
+      if @checked
+        [@ok, @data]
+      else
+        [false, "Error communicating with server"]
+      end
+    end
+
+    def handle_success(response)
+      @checked = true
+      @ok = true
+      @data = JSON.parse(response)
+    end
+
+    def handle_failure(response)
+      if response.code.to_i == 404
+        @checked = true
+        @ok = false
+        @data = {}
+      else
+        @checked = false
+      end
+    end
+  end
+end

data/lib/locale_app/missing_translations.rb

@@ -0,0 +1,36 @@
+module LocaleApp
+  MissingTranslationRecord = Struct.new(:key, :locale, :options)
+
+  class MissingTranslations
+    def initialize
+      @translations = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def add(locale, key, options = {})
+      record = MissingTranslationRecord.new(key, locale, options)
+      @translations[locale][key] = record
+    end
+
+    def [](locale)
+      @translations[locale]
+    end
+
+    # This method will get cleverer so we don't resend keys we've
+    # already sent, or send multiple times for the same locale etc.
+    # For now it's pretty dumb
+    def to_send
+      data = []
+      # need the sort to make specs work under 1.8
+      @translations.sort { |a, b| a.to_s <=> b.to_s }.each do |locale, records|
+        records.each do |key, record|
+          missing_data = {}
+          missing_data[:key] = key
+          missing_data[:locale] = locale
+          missing_data[:options] = record.options
+          data << missing_data
+        end
+      end
+      data
+    end
+  end
+end

data/lib/locale_app/poller.rb

@@ -0,0 +1,61 @@
+require 'yaml'
+require 'rest-client'
+require 'time'
+
+module LocaleApp
+  class Poller
+    include ::LocaleApp::ApiCall
+    
+    # when we last asked the service for updates
+    attr_accessor :polled_at
+
+    # the last time the service had updates for us
+    attr_accessor :updated_at
+
+    def initialize
+      @polled_at  = synchronization_data[:polled_at]  || 0
+      @updated_at = synchronization_data[:updated_at] || 0
+    end
+
+    def synchronization_data
+      if File.exists?(LocaleApp.configuration.synchronization_data_file)
+        YAML.load_file(LocaleApp.configuration.synchronization_data_file)
+      else
+        {}
+      end
+    end
+
+    def write_synchronization_data!(polled_at, updated_at)
+      File.open(LocaleApp.configuration.synchronization_data_file, 'w+') do |f|
+        f.write({:polled_at => polled_at, :updated_at => updated_at}.to_yaml)
+      end
+    end
+
+    def needs_polling?
+      synchronization_data[:polled_at] < (Time.now.to_i - LocaleApp.configuration.poll_interval)
+    end
+
+    def needs_reloading?
+      synchronization_data[:updated_at] != @updated_at
+    end
+
+    def poll!
+      api_call :translations,
+        :url_options => { :query => { :updated_at => updated_at }},
+        :success => :handle_success,
+        :failure => :handle_failure,
+        :max_connection_attempts => 1
+      @success
+    end
+
+    def handle_success(response)
+      @success = true
+      LocaleApp.updater.update(JSON.parse(response))
+      write_synchronization_data!(Time.now.to_i, Time.parse(response.headers[:date]).to_i)
+    end
+
+    def handle_failure(response)
+      @success = false
+    end
+  end
+end

data/lib/locale_app/rails/2_3_translation_helper_monkeypatch.rb

@@ -0,0 +1,36 @@
+# We're replacing the original method with one that doesn't set the :raise option.
+# This means the exception handler will be called and missing translations get sent to
+# localeapp. It's ugly but there's no other way to do it :(
+
+module LocaleApp::TranslationHelperMonkeyPatch
+  # Delegates to I18n#translate but also performs two additional functions. First, it'll catch MissingTranslationData exceptions
+  # and turn them into inline spans that contains the missing key, such that you can see in a view what is missing where.
+  #
+  # Second, it'll scope the key by the current partial if the key starts with a period. So if you call translate(".foo") from the
+  # people/index.html.erb template, you'll actually be calling I18n.translate("people.index.foo"). This makes it less repetitive
+  # to translate many keys within the same partials and gives you a simple framework for scoping them consistently. If you don't
+  # prepend the key with a period, nothing is converted.
+  def translate(keys, options = {})
+    if multiple_keys = keys.is_a?(Array)
+      ActiveSupport::Deprecation.warn "Giving an array to translate is deprecated, please give a symbol or a string instead", caller
+    end
+
+    keys = scope_keys_by_partial(keys)
+
+    translations = I18n.translate(keys, options)
+    translations = [translations] if !multiple_keys && translations.size > 1
+    translations = html_safe_translation_keys(keys, translations)
+
+    if multiple_keys || translations.size > 1
+      translations
+    else
+      translations.first
+    end
+  rescue I18n::MissingTranslationData => e
+    keys = I18n.send(:normalize_translation_keys, e.locale, e.key, e.options[:scope])
+    content_tag('span', keys.join(', '), :class => 'translation_missing')
+  end
+  alias :t :translate
+end
+
+ActionView::Base.send(:include, ::LocaleApp::TranslationHelperMonkeyPatch)

data/lib/locale_app/rails/controller.rb

@@ -0,0 +1,34 @@
+module LocaleApp
+  module Rails
+    module Controller
+      def self.included(base)
+        base.before_filter :handle_translation_updates
+        base.after_filter  :send_missing_translations
+      end
+
+      def handle_translation_updates
+        unless ::LocaleApp.configuration.polling_disabled?
+          ::LocaleApp.log Time.now.to_i.to_s << '-- Handling translation updates'
+          if ::LocaleApp.poller.needs_polling?
+            ::LocaleApp.log Time.now.to_i.to_s << ' - polling'
+            ::LocaleApp.poller.poll!
+          end
+        end
+
+        unless ::LocaleApp.configuration.reloading_disabled?
+          if ::LocaleApp.poller.needs_reloading?
+            ::LocaleApp.log Time.now.to_i.to_s << '- reloading I18n'
+            I18n.reload!
+            ::LocaleApp.poller.updated_at = ::LocaleApp.poller.synchronization_data[:updated_at]
+          end
+        end
+      end
+
+      def send_missing_translations
+        return if ::LocaleApp.configuration.sending_disabled?
+
+        ::LocaleApp.sender.post_missing_translations
+      end
+    end
+  end
+end

data/lib/locale_app/rails/flatten.rb

@@ -0,0 +1,113 @@
+module I18n
+  module Backend
+    # This module contains several helpers to assist flattening translations.
+    # You may want to flatten translations for:
+    #
+    #   1) speed up lookups, as in the Memoize backend;
+    #   2) In case you want to store translations in a data store, as in ActiveRecord backend;
+    #
+    # You can check both backends above for some examples.
+    # This module also keeps all links in a hash so they can be properly resolved when flattened.
+    module Flatten
+      SEPARATOR_ESCAPE_CHAR = "\001"
+      FLATTEN_SEPARATOR = "."
+
+      # normalize_keys the flatten way. This method is significantly faster
+      # and creates way less objects than the one at I18n.normalize_keys.
+      # It also handles escaping the translation keys.
+      def self.normalize_flat_keys(locale, key, scope, separator)
+        keys = [scope, key].flatten.compact
+        separator ||= I18n.default_separator
+
+        if separator != FLATTEN_SEPARATOR
+          keys.map! do |k|
+            k.to_s.tr("#{FLATTEN_SEPARATOR}#{separator}",
+              "#{SEPARATOR_ESCAPE_CHAR}#{FLATTEN_SEPARATOR}")
+          end
+        end
+
+        keys.join(".")
+      end
+
+      # Receives a string and escape the default separator.
+      def self.escape_default_separator(key) #:nodoc:
+        key.to_s.tr(FLATTEN_SEPARATOR, SEPARATOR_ESCAPE_CHAR)
+      end
+
+      # Shortcut to I18n::Backend::Flatten.normalize_flat_keys
+      # and then resolve_links.
+      def normalize_flat_keys(locale, key, scope, separator)
+        key = I18n::Backend::Flatten.normalize_flat_keys(locale, key, scope, separator)
+        resolve_link(locale, key)
+      end
+
+      # Store flattened links.
+      def links
+        @links ||= Hash.new { |h,k| h[k] = {} }
+      end
+
+      # Flatten keys for nested Hashes by chaining up keys:
+      #
+      #   >> { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}.wind
+      #   => { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
+      #
+      def flatten_keys(hash, escape, prev_key=nil, &block)
+        hash.each_pair do |key, value|
+          key = escape_default_separator(key) if escape
+          curr_key = [prev_key, key].compact.join(FLATTEN_SEPARATOR).to_sym
+          yield curr_key, value
+          flatten_keys(value, escape, curr_key, &block) if value.is_a?(Hash)
+        end
+      end
+
+      # Receives a hash of translations (where the key is a locale and
+      # the value is another hash) and return a hash with all
+      # translations flattened.
+      #
+      # Nested hashes are included in the flattened hash just if subtree
+      # is true and Symbols are automatically stored as links.
+      def flatten_translations(locale, data, escape, subtree)
+        hash = {}
+        flatten_keys(data, escape) do |key, value|
+          if value.is_a?(Hash)
+            hash[key] = value if subtree
+          else
+            store_link(locale, key, value) if value.is_a?(Symbol)
+            hash[key] = value
+          end
+        end
+        hash
+      end
+
+      protected
+
+        def store_link(locale, key, link)
+          links[locale.to_sym][key.to_s] = link.to_s
+        end
+
+        def resolve_link(locale, key)
+          key, locale = key.to_s, locale.to_sym
+          links = self.links[locale]
+
+          if links.key?(key)
+            links[key]
+          elsif link = find_link(locale, key)
+            store_link(locale, key, key.gsub(*link))
+          else
+            key
+          end
+        end
+
+        def find_link(locale, key) #:nodoc:
+          links[locale].each do |from, to|
+            return [from, to] if key[0, from.length] == from
+          end && nil
+        end
+
+        def escape_default_separator(key) #:nodoc:
+          I18n::Backend::Flatten.escape_default_separator(key)
+        end
+
+    end
+  end
+end

data/lib/locale_app/rails.rb

@@ -0,0 +1,53 @@
+module LocaleApp
+  module Rails
+    def self.initialize
+      if defined?(::Rails.logger)
+        rails_logger = ::Rails.logger
+      elsif defined?(RAILS_DEFAULT_LOGGER)
+        rails_logger = RAILS_DEFAULT_LOGGER
+      end
+
+      if defined?(::Rails.env)
+        rails_env = ::Rails.env
+      elsif defined?(RAILS_ENV)
+        rails_env = RAILS_ENV
+      end
+
+      if defined?(::Rails.root)
+        rails_root = ::Rails.root
+      elsif defined?(RAILS_ROOT)
+        rails_root = RAILS_ROOT
+      end
+
+      ActionController::Base.send(:include, LocaleApp::Rails::Controller)
+
+      if ::Rails::VERSION::MAJOR == 2 && ::Rails::VERSION::MINOR >= 3 # TODO: Check previous rails versions if required
+        require 'locale_app/rails/2_3_translation_helper_monkeypatch'
+      end
+
+      LocaleApp.configure do |config|
+        config.logger                     = rails_logger
+        config.environment_name           = rails_env
+        config.project_root               = rails_root
+        config.synchronization_data_file  = File.join([rails_root, 'log', 'locale_app.yml'])
+        config.translation_data_directory = File.join([rails_root, 'config', 'locales'])
+      end
+      initialize_synchronization_data_file
+    end
+
+    def self.initialize_synchronization_data_file
+      if !File.exists?(LocaleApp.configuration.synchronization_data_file)
+        File.open(LocaleApp.configuration.synchronization_data_file, 'w') do |f|
+          f.write({:polled_at => Time.now.to_i, :updated_at => Time.now.to_i}.to_yaml)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Rails)
+  require 'locale_app/rails/controller'
+  require 'locale_app/exception_handler'
+  LocaleApp::Rails.initialize
+  LocaleApp.log('Loaded locale_app/rails')
+end

data/lib/locale_app/routes.rb

@@ -0,0 +1,80 @@
+module LocaleApp
+  module Routes
+    VERSION = 'v1'
+
+    def project_endpoint(options = {})
+      [:get, project_url(options)]
+    end
+
+    def project_url(options = {})
+      options[:format] ||= 'json'
+      URI::HTTP.build(base_options.merge(:path => project_path(options[:format]))).to_s
+    end
+
+    def translations_url(options={})
+      options[:format] ||= 'json'
+      url = URI::HTTP.build(base_options.merge(:path => translations_path(options[:format])))
+      url.query = options[:query].map { |k,v| "#{k}=#{v}" }.join('&') if options[:query]
+      url.to_s
+    end
+
+    def translations_endpoint(options = {})
+      [:get, translations_url(options)]
+    end
+
+    def create_translation_endpoint(options = {})
+      [:post, translations_url(options)]
+    end
+
+    def missing_translations_endpoint(options = {})
+      [:post, missing_translations_url(options)]
+    end
+
+    def missing_translations_url(options={})
+      options[:format] ||= 'json'
+      url = URI::HTTP.build(base_options.merge(:path => missing_translations_path(options[:format])))
+      url.query = options[:query].map { |k,v| "#{k}=#{v}" }.join('&') if options[:query]
+      url.to_s
+    end
+
+    def import_endpoint(options = {})
+      [:post, import_url(options)]
+    end
+
+    def import_url(options={})
+      URI::HTTP.build(base_options.merge(:path => import_path)).to_s
+    end
+
+  private
+
+    def base_options
+      options = {:host => LocaleApp.configuration.host, :port => LocaleApp.configuration.port}
+      if LocaleApp.configuration.http_auth_username
+        options[:userinfo] = "#{LocaleApp.configuration.http_auth_username}:#{LocaleApp.configuration.http_auth_password}"
+      end
+      options
+    end
+
+    def project_path(format = nil)
+      path = "/#{VERSION}/projects/#{LocaleApp.configuration.api_key}"
+      path << ".#{format}" if format
+      path
+    end
+
+    def translations_path(format = nil)
+      path = project_path << '/translations'
+      path << ".#{format}" if format
+      path
+    end
+
+    def missing_translations_path(format = nil)
+      path = project_path << '/translations/missing'
+      path << ".#{format}" if format
+      path
+    end
+
+    def import_path(format = nil)
+      project_path << '/import/'
+    end
+  end
+end

data/lib/locale_app/sender.rb

@@ -0,0 +1,49 @@
+require 'rest-client'
+require 'json'
+
+module LocaleApp
+  class Sender
+    include ::LocaleApp::ApiCall
+    include ::LocaleApp::Routes
+
+    def post_translation(locale, key, options, value = nil)
+      options ||= {}
+      translation = { :key => key, :locale => locale, :substitutions => options.keys, :description => value}
+      @data = { :translation => translation }
+      api_call :create_translation,
+        :payload => @data.to_json,
+        :request_options => { :content_type => :json },
+        :success => :handle_single_translation_success,
+        :failure => :handle_single_translation_failure,
+        :max_connection_attempts => 1
+    end
+
+    def handle_single_translation_success(response)
+       LocaleApp.log([translations_url, response.code, @data.inspect].join(' - '))
+    end
+
+    def handle_single_translation_failure(response)
+       LocaleApp.log([translations_url, response.code, @data.inspect].join(' - '))
+    end
+
+    def post_missing_translations
+      to_send = LocaleApp.missing_translations.to_send
+      return if to_send.empty?
+      @data = { :translations => to_send }
+      api_call :missing_translations,
+        :payload => @data.to_json,
+        :request_options => { :content_type => :json },
+        :success => :handle_missing_translation_success,
+        :failure => :handle_missing_translation_failure,
+        :max_connection_attempts => 1
+    end
+
+    def handle_missing_translation_success(response)
+       LocaleApp.log([translations_url, response.code, @data.inspect].join(' - '))
+    end
+
+    def handle_missing_translation_failure(response)
+       LocaleApp.log([translations_url, response.code, @data.inspect].join(' - '))
+    end
+  end
+end

data/lib/locale_app/tasks/locale_app.rake

@@ -0,0 +1,20 @@
+namespace :locale_app do
+  desc 'Imports the en.yml file to the LocaleServer'
+  task :import => :environment do
+    require 'flatten'
+    include I18n::Backend::Flatten
+    yml = YAML.load_file(ENV['LOCALE_FILE'])
+
+    yml.each do |locale, translations|
+      flatten_translations(
+        locale,
+        translations,
+        I18n::Backend::Flatten::SEPARATOR_ESCAPE_CHAR,
+        nil
+      ).each do |key, value|
+        puts "#{key} => #{value}"
+        LocaleApp.sender.post_translation(locale, key, {}, value)
+      end
+    end
+  end
+end