phraseapp-in-context-editor-ruby 1.0.0rc1

data/lib/generators/phraseapp_in_context_editor/install_generator.rb

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+
+module PhraseappInContextEditor
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Creates a PhraseApp In-Context-Editor initializer for your application."
+      class_option :access_token, type: :string, desc: "Your PhraseApp access token", required: true
+      class_option :project_id, type: :string, desc: "Your PhraseApp project id", required: true
+
+      def copy_initializer
+        template "phraseapp_in_context_editor.rb", "config/initializers/phraseapp_in_context_editor.rb"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/phraseapp_in_context_editor/templates/README

@@ -0,0 +1,10 @@
+===============================================================================
+Welcome to PhraseApp!
+
+PhraseApp is the translation management solution for web and mobile applications. Collaborate with your team, find professional translators and stay on top of the process.
+
+Our In-Context Editor offers just that. It provides translators with useful contextual information which improves overall translation quality.
+
+Login: https://phraseapp.com/account/login
+Documentation: http://docs.phraseapp.com/guides/in-context-editor/
+===============================================================================

data/lib/generators/phraseapp_in_context_editor/templates/phraseapp_in_context_editor.rb

@@ -0,0 +1,27 @@
+PhraseApp::InContextEditor.configure do |config|
+  # Enable or disable the In-Context-Editor in general
+  config.enabled = true
+
+  # Fetch your project id after creating your first project
+  # in Translation Center.
+  # You can find the project id in your project settings
+  # page (https://phraseapp.com/projects)
+  config.project_id = "<%= options[:project_id] %>"
+
+  # You can create and manage access tokens in your profile settings
+  # in Translation Center or via the Authorizations API
+  # (http://docs.phraseapp.com/api/v2/authorizations/).
+  config.access_token = "<%= options[:access_token] %>"
+
+  # Configure an array of key names that should not be handled
+  # by the In-Context-Editor.
+  config.ignored_keys = ["number.*", "breadcrumb.*"]
+
+  # PhraseApp uses decorators to generate a unique identification key
+  # in context of your document. However, this might result in conflicts
+  # with other libraries (e.g. client-side template engines) that use a similar syntax.
+  # If you encounter this problem, you might want to change this decorator pattern.
+  # More information: http://docs.phraseapp.com/guides/in-context-editor/configure/
+  # config.prefix = "{{__"
+  # config.suffix = "__}}"
+end

data/lib/phraseapp-in-context-editor-ruby.rb

@@ -0,0 +1,92 @@
+# -*- encoding : utf-8 -*-
+require 'phraseapp-ruby'
+
+module PhraseApp
+  module InContextEditor
+    autoload :Config, 'phraseapp-in-context-editor-ruby/config'
+
+    class << self
+      def config
+        Thread.current[:phraseapp_config] ||= PhraseApp::InContextEditor::Config.new
+      end
+
+      def config=(value)
+        Thread.current[:phraseapp_config] = value
+      end
+
+      def backend
+        config.backend
+      end
+
+      def suffix
+        config.suffix
+      end
+
+      def prefix
+        config.prefix
+      end
+
+      def project_id
+        config.project_id
+      end
+
+      def access_token
+        config.access_token
+      end
+
+      def cache_key_segments_initial
+        config.cache_key_segments_initial
+      end
+
+      def cache_lifetime
+        config.cache_lifetime
+      end
+
+      def ignored_keys
+        config.ignored_keys
+      end
+
+      def enabled=(value)
+        config.enabled = value
+      end
+
+      def enabled?
+        config.enabled
+      end
+
+      def disabled?
+        !config.enabled
+      end
+
+      def js_use_ssl
+        config.js_use_ssl
+      end
+
+      def js_host
+        config.js_host
+      end
+
+      def api_client
+        config.api_client
+      end
+    end
+
+    def self.configure
+      yield(self.config)
+    end
+  end
+
+  autoload :ViewHelpers, 'phraseapp-in-context-editor-ruby/view_helpers'
+
+  require 'phraseapp-in-context-editor-ruby/version'
+  require 'phraseapp-in-context-editor-ruby/engine'
+  require 'phraseapp-in-context-editor-ruby/delegate'
+  require 'phraseapp-in-context-editor-ruby/backend_service'
+  require 'phraseapp-in-context-editor-ruby/view_helpers'
+end
+
+# Only load adapters directly if non-rails app, otherwise use engine
+unless defined? Rails
+  require 'phraseapp-in-context-editor-ruby/adapters/i18n'
+  require 'phraseapp-in-context-editor-ruby/adapters/fast_gettext'
+end

data/lib/phraseapp-in-context-editor-ruby/adapters/fast_gettext.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+
+require 'phraseapp-in-context-editor-ruby/delegate/fast_gettext'
+
+module FastGettext
+  module Translation
+    def __with_phraseapp(*args)
+      PhraseApp::InContextEditor::Delegate::FastGettext.new(:_, *args)
+    end
+    alias_method :__without_phraseapp, :_
+    alias_method :_, :__with_phraseapp
+
+    def n__with_phraseapp(*args)
+      PhraseApp::InContextEditor::Delegate::FastGettext.new(:n_, *args)
+    end
+    alias_method :n__without_phraseapp, :n_
+    alias_method :n_, :n__with_phraseapp
+
+    def s__with_phraseapp(*args)
+      PhraseApp::InContextEditor::Delegate::FastGettext.new(:s_, *args)
+    end
+    alias_method :s__without_phraseapp, :s_
+    alias_method :s_, :s__with_phraseapp
+  end
+end if defined? FastGettext::Translation

data/lib/phraseapp-in-context-editor-ruby/adapters/i18n.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+
+module I18n
+  class << self
+    def translate_with_phraseapp(*args)
+      PhraseApp::InContextEditor.backend.translate(*args)
+    end
+    alias_method :translate_without_phraseapp, :translate
+    alias_method :translate, :translate_with_phraseapp
+    alias_method :t, :translate
+  end
+end if defined?(I18n)

data/lib/phraseapp-in-context-editor-ruby/api_collection.rb

@@ -0,0 +1,41 @@
+module PhraseApp
+  module InContextEditor
+    class ApiCollection
+      def initialize(api_client, action, ids=[], query=nil)
+        raise "PhraseApp API client can't handle action #{action}" unless api_client.respond_to?(action)
+
+        @api_client = api_client
+        @action = action
+        @ids = ids
+        @query = query
+      end
+
+      def collection
+        results = []
+        page = 1
+        per_page = 100
+        paginated, err = send_request(page, per_page)
+        results << paginated
+
+        while paginated.size == per_page
+          break if page > 100
+
+          page = page + 1
+          paginated, err = send_request(page, per_page)
+          results << paginated if paginated.present?
+        end
+
+        results.flatten.uniq
+      end
+
+    private
+      def send_request(page, per_page)
+        if @query.present?
+          @api_client.send(@action, *@ids, page, per_page, @query)
+        else
+          @api_client.send(@action, *@ids, page, per_page)
+        end
+      end
+    end
+  end
+end

data/lib/phraseapp-in-context-editor-ruby/api_wrapper.rb

@@ -0,0 +1,59 @@
+require 'phraseapp-in-context-editor-ruby/api_collection'
+
+module PhraseApp
+  module InContextEditor
+    class ApiWrapper
+      def initialize
+        @api_client = PhraseApp::InContextEditor.api_client
+      end
+
+      def default_locale
+        @default_locale ||= select_default_locale
+      end
+
+      def default_translation(key)
+        params = PhraseApp::RequestParams::TranslationsByKeyParams.new
+        translations = PhraseApp::InContextEditor::ApiCollection.new(@api_client, "translations_by_key", project_and_key_id(key), params).collection
+        return unless translations.present?
+
+        translations.select{ |translation| translation.locale["id"] == default_locale.id }
+      end
+
+      def keys_with_prefix(prefix)
+        params = PhraseApp::RequestParams::KeysListParams.new(q:"#{prefix}*")
+        keys_list(params)
+      end
+
+      def keys_by_names(names)
+        names = names.join(',')
+        params = PhraseApp::RequestParams::KeysListParams.new(:q => "name:#{names}")
+        keys_list(params)
+      end
+
+      def keys_list(params)
+        PhraseApp::InContextEditor::ApiCollection.new(@api_client, "keys_list", project_id, params).collection
+      end
+
+      def blacklisted_keys
+        PhraseApp::InContextEditor::ApiCollection.new(@api_client, "exclude_rules_index", project_id).collection.map{ |rule| rule.name }
+      end
+
+      private
+
+      def select_default_locale
+        locales = PhraseApp::InContextEditor::ApiCollection.new(@api_client, "locales_list", project_id).collection
+        return unless locales.present?
+
+        locales.select{ |loc| loc.default }.first
+      end
+
+      def project_id
+        [PhraseApp::InContextEditor.project_id]
+      end
+
+      def project_and_key_id(key)
+        project_id << key.id
+      end
+    end
+  end
+end

data/lib/phraseapp-in-context-editor-ruby/backend_service.rb

@@ -0,0 +1,167 @@
+# -*- encoding : utf-8 -*-
+require 'phraseapp-in-context-editor-ruby/api_collection'
+require 'phraseapp-in-context-editor-ruby/delegate/i18n'
+
+module PhraseApp
+  module InContextEditor
+    class BackendService
+
+      attr_accessor :blacklisted_keys
+
+      def initialize(args = {})
+        self
+      end
+
+      def translate(*args)
+        if to_be_translated_without_phraseapp?(args)
+          I18n.translate_without_phraseapp(*args)
+        else
+          phraseapp_delegate_for(args)
+        end
+      end
+
+    protected
+      def to_be_translated_without_phraseapp?(args)
+        PhraseApp::InContextEditor.disabled? or has_been_given_blacklisted_key?(args) or has_been_given_ignored_key?(args) or has_been_forced_to_resolve_with_phraseapp?(args)
+      end
+
+      def has_been_given_blacklisted_key?(args)
+        key = given_key_from_args(args)
+        has_blacklist_entry_for_key?(key)
+      end
+
+      def has_been_given_ignored_key?(args)
+        key = given_key_from_args(args)
+        key_is_ignored?(key)
+      end
+
+      def has_been_forced_to_resolve_with_phraseapp?(args)
+        (args.last.is_a?(Hash) and args.last[:resolve] == false)
+      end
+
+      def given_key_from_args(args)
+        extract_normalized_key_from_args(args)
+      end
+
+      def has_blacklist_entry_for_key?(key)
+        blacklisted_keys.each do |blacklisted_key|
+          return true if present?(key.to_s[/\A#{blacklisted_key.gsub("*", ".*")}\Z/])
+        end
+        false
+      end
+
+      def key_is_ignored?(key)
+        PhraseApp::InContextEditor.ignored_keys.each do |ignored_key|
+          return true if present?(key.to_s[/\A#{ignored_key.gsub("*", ".*")}\Z/])
+        end
+        false
+      end
+
+      def blacklisted_keys
+        @blacklisted_keys ||= api_wrapper.blacklisted_keys
+      end
+
+      def phraseapp_delegate_for(args)
+        key = given_key_from_args(args)
+        return nil unless present?(key)
+        options = args[1].nil? ? {} : args[1]
+        PhraseApp::InContextEditor::Delegate::I18n.new(key, options, args)
+      end
+
+      def extract_normalized_key_from_args(args)
+        transformed_args = transform_args(args)
+        normalized_key(transformed_args)
+      end
+
+      def transform_args(args)
+        duped_args = args.map { |item| (item.is_a?(Symbol) or item.nil?) ? item : item.dup }
+        transform_args_based_on_caller(duped_args)
+      end
+
+      def normalized_key(duped_args)
+        splitted_args = split_args(duped_args)
+        key = I18n::Backend::Flatten.normalize_flat_keys(*splitted_args)
+        key.gsub!("..", ".")
+        key.gsub!(/^\./, '')
+        key
+      end
+
+      def split_args(args)
+        options = options_from_args(args)
+        key ||= args.shift
+        locale = options.delete(:locale) || I18n.locale
+        return [locale, key, options[:scope], nil]
+      end
+
+      def options_from_args(args)
+        args.last.is_a?(Hash) ? args.pop : {}
+      end
+
+      def transform_args_based_on_caller(args)
+        translation_caller = identify_caller
+
+        if translation_caller and args.first =~ /^\./
+          options = options_from_args(args)
+
+          if not present?(options[:scope]) and present?(translation_caller)
+            options[:scope] = translation_caller
+          end
+
+          args.push(options)
+          parts = args.first.to_s.split(".").select { |e| not blank?(e) }
+          args[0] = parts[0] if parts.size == 1
+        end
+
+        args
+      end
+
+      def identify_caller
+        translation_caller = nil
+        send(:caller)[0..6].each do |intermediate_caller|
+          translation_caller = calling_template(intermediate_caller) unless translation_caller
+        end
+
+        if present?(translation_caller)
+          find_lookup_scope(translation_caller)
+        else
+          nil
+        end
+      end
+
+      def calling_template(string)
+        string.match(/(views)(\/.+)(?>:[0-9]+:in)/)
+      end
+
+      def blank?(str)
+        raise "blank?(str) can only be given a String or nil" unless str.is_a?(String) or str.nil?
+        str.nil? or str == ''
+      end
+
+      def present?(str)
+        raise "present?(str) can only be given a String or nil" unless str.is_a?(String) or str.nil?
+        not blank?(str)
+      end
+
+      def find_lookup_scope(caller)
+        split_path = caller[2][1..-1].split(".")[0].split("/")
+
+        template_or_partial = remove_underscore_form_partial(split_path[-1])
+        split_path[-1] = template_or_partial
+
+        split_path.map!(&:to_sym)
+      end
+
+      def remove_underscore_form_partial(template_or_partial)
+        if template_or_partial.to_s[0,1] == "_"
+          template_or_partial.to_s[1..-1]
+        else
+          template_or_partial.to_s
+        end
+      end
+
+      def api_wrapper
+        @api_wrapper ||= PhraseApp::InContextEditor::ApiWrapper.new
+      end
+    end
+  end
+end