phraseapp-in-context-editor-ruby 1.0.0rc1

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

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+
+require 'phraseapp-in-context-editor-ruby'
+
+module PhraseApp
+  module InContextEditor
+    class Cache
+      attr_accessor :lifetime
+
+      def initialize(args={})
+        @store = {}
+        @lifetime = args.fetch(:lifetime, PhraseApp::InContextEditor.cache_lifetime)
+      end
+
+      def cached?(cache_key)
+        @store.has_key?(cache_key) && !expired?(cache_key)
+      end
+
+      def get(cache_key)
+        begin
+          @store.fetch(cache_key)[:payload]
+        rescue
+          nil
+        end
+      end
+
+      def set(cache_key, value)
+        @store[cache_key] = {timestamp: Time.now, payload: value}
+      end
+
+    private
+      def expired?(cache_key)
+        @store.fetch(cache_key)[:timestamp] < (Time.now - @lifetime)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# -*- encoding : utf-8 -*-
+
+module PhraseApp
+  module InContextEditor
+    class Config
+      def project_id
+        @@project_id = "" if !defined? @@project_id or @@project_id.nil?
+        @@project_id
+      end
+
+      def project_id=(project_id)
+        @@project_id = project_id
+      end
+
+      def access_token
+        @@access_token = "" if !defined? @@access_token or @@access_token.nil?
+        @@access_token
+      end
+
+      def access_token=(access_token)
+        @@access_token = access_token
+      end
+
+      def enabled
+        @@enabled = false if !defined? @@enabled or @@enabled.nil?
+        @@enabled
+      end
+
+      def enabled=(enabled)
+        @@enabled = enabled
+      end
+
+      def backend
+        @@backend ||= PhraseApp::InContextEditor::BackendService.new
+      end
+
+      def backend=(backend)
+        @@backend = backend
+      end
+
+      def api_client
+        @@api_client ||= authorized_api_client
+      end
+
+      def prefix
+        @@prefix ||= "{{__"
+      end
+
+      def prefix=(prefix)
+        @@prefix = prefix
+      end
+
+      def suffix
+        @@suffix ||= "__}}"
+      end
+
+      def suffix=(suffix)
+        @@suffix = suffix
+      end
+
+      def js_host
+        @@js_host ||= 'phraseapp.com'
+      end
+
+      def js_host=(js_host)
+        @@js_host = js_host
+      end
+
+      def js_use_ssl
+        @@js_use_ssl = true if !defined? @@js_use_ssl or @@js_use_ssl.nil?
+        @@js_use_ssl
+      end
+
+      def js_use_ssl=(js_use_ssl)
+        @@js_use_ssl = js_use_ssl
+      end
+
+      def cache_key_segments_initial
+        @@cache_key_segments_initial ||= ["simple_form"]
+      end
+
+      def cache_key_segments_initial=(cache_key_segments_initial=[])
+        @@cache_key_segments_initial = cache_key_segments_initial
+      end
+
+      def cache_lifetime
+        @@cache_lifetime ||= 300
+      end
+
+      def cache_lifetime=(cache_lifetime)
+        @@cache_lifetime = cache_lifetime
+      end
+
+      def ignored_keys
+        @@ignored_keys ||= []
+      end
+
+      def ignored_keys=(ignored_keys)
+        @@ignored_keys = ignored_keys
+      end
+
+    protected
+      def authorized_api_client
+        auth_handler = PhraseApp::Auth::AuthHandler.new(token: PhraseApp::InContextEditor.access_token)
+        PhraseApp::Auth.register_auth_handler(auth_handler)
+        PhraseApp::Client
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+
+module PhraseApp
+  module InContextEditor
+    module Delegate
+      class Base < String
+        def to_s
+          "#{decorated_key_name}"
+        end
+        alias :camelize :to_s
+        alias :underscore :to_s
+        alias :classify :to_s
+        alias :dasherize :to_s
+        alias :tableize :to_s
+
+        def self.log(message)
+          message = "phrase: #{message}"
+          if defined?(Rails) and Rails.respond_to?(:logger)
+            Rails.logger.warn(message)
+          else
+            $stderr.puts message
+          end
+        end
+
+      protected
+        def decorated_key_name
+          "#{PhraseApp::InContextEditor.prefix}phrase_#{normalized_display_key}#{PhraseApp::InContextEditor.suffix}"
+        end
+
+        def normalized_display_key
+          unless @display_key.nil?
+            @display_key.gsub("<", "[[[[[[html_open]]]]]]").gsub(">", "[[[[[[html_close]]]]]]")
+          else
+            @display_key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+
+require 'phraseapp-in-context-editor-ruby/delegate'
+
+module PhraseApp
+  module InContextEditor
+    module Delegate
+      class FastGettext < Base
+        def initialize(method, *args)
+          @method = method
+          params = params_from_args(args)
+          @display_key = params[:msgid]
+        end
+
+      private
+        def params_from_args(args)
+          params = case @method
+            when :_
+              {msgid: args.first}
+            when :n_
+              {msgid: args.first, msgid_plural: args[1], count: args.last}
+            when :s_
+              {msgid: args.first}
+            else
+              self.class.log("Unsupported FastGettext method #{@method}")
+              {}
+          end
+          params
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# -*- encoding : utf-8 -*-
+
+require 'phraseapp-in-context-editor-ruby/cache'
+require 'phraseapp-in-context-editor-ruby/hash_flattener'
+require 'phraseapp-in-context-editor-ruby/delegate'
+require 'phraseapp-in-context-editor-ruby/api_wrapper'
+require 'set'
+
+module PhraseApp
+  module InContextEditor
+    module Delegate
+      class I18n < Base
+        attr_accessor :key, :display_key, :options, :api_client, :fallback_keys, :original_args
+
+        def initialize(key, options={}, original_args=nil)
+          @display_key = @key = key
+          @options = options
+          @original_args = original_args
+
+          @fallback_keys = []
+
+          extract_fallback_keys
+          identify_key_to_display if @fallback_keys.any?
+          super(decorated_key_name)
+        end
+
+        def method_missing(*args, &block)
+          self.class.log "Trying to execute missing method ##{args.first} on key #{@key}"
+          if @key.respond_to?(args.first)
+            to_s.send(*args)
+          else
+            data = translation_or_subkeys
+            if data.respond_to?(args.first)
+              data.send(*args, &block)
+            else
+              self.class.log "You tried to execute the missing method ##{args.first} on key #{@key} which is not supported. Please make sure you treat your translations as strings only."
+              original_translation = I18n.translate_without_phraseapp(*@original_args)
+              original_translation.send(*args, &block)
+            end
+          end
+        end
+
+      private
+        def identify_key_to_display
+          key_names = [@key] | @fallback_keys
+          available_key_names = find_keys_within_phraseapp(key_names)
+          @display_key = @key
+          key_names.each do |item|
+            if available_key_names.include?(item)
+              @display_key = item
+              break
+            end
+          end
+        end
+
+        def find_keys_within_phraseapp(key_names)
+          key_names_to_check_against_api = key_names - pre_fetched(key_names)
+          pre_cached(key_names) | key_names_returned_from_api_for(key_names_to_check_against_api)
+        end
+
+        def pre_cached(key_names)
+          warm_translation_key_names_cache unless cache.cached?(:translation_key_names)
+          pre_cached_key_names = key_names.select { |key_name| key_name_precached?(key_name) }
+          pre_cached_key_names
+        end
+
+        def pre_fetched(key_names)
+          key_names.select { |key_name| covered_by_initial_caching?(key_name) }
+        end
+
+        def key_name_precached?(key_name)
+          covered = covered_by_initial_caching?(key_name)
+          in_cache = key_name_is_in_cache?(key_name)
+          covered && in_cache
+        end
+
+        def key_names_returned_from_api_for(key_names)
+          if key_names.size > 0
+            api_wrapper.keys_by_names(key_names).map{ |key| key.name }
+          else
+            []
+          end
+        end
+
+        def key_name_is_in_cache?(key_name)
+          cache.get(:translation_key_names).include?(key_name)
+        end
+
+        def covered_by_initial_caching?(key_name)
+          key_name.start_with?(*PhraseApp::InContextEditor.cache_key_segments_initial)
+        end
+
+        def extract_fallback_keys
+          fallback_items = []
+          if @options.has_key?(:default)
+            if @options[:default].kind_of?(Array)
+              fallback_items = @options[:default]
+            else
+              fallback_items << @options[:default]
+            end
+          end
+
+          fallback_items.each do |item|
+            process_fallback_item(item)
+          end
+        end
+
+        def scoped(item)
+          @options.has_key?(:scope) ? "#{@options[:scope]}.#{item}" : item
+        end
+
+        def process_fallback_item(item)
+          if item.kind_of?(Symbol)
+            entry = scoped(item.to_s)
+            @fallback_keys << entry
+            if @key == "helpers.label.#{entry}" # http://apidock.com/rails/v3.1.0/ActionView/Helpers/FormHelper/label
+              @fallback_keys << "activerecord.attributes.#{entry}"
+            end
+
+            if @key.start_with?("simple_form.") # special treatment for simple form
+              @fallback_keys << "activerecord.attributes.#{item.to_s}"
+            end
+          end
+        end
+
+        def translation_or_subkeys
+          keys = api_wrapper.keys_with_prefix(@key)
+          return nil unless keys.present?
+
+          if keys.size == 1
+            translation_content_for_key(keys.first)
+          else
+            translation_hash = keys.inject({}) do |hash, key|
+              hash[key.name] = translation_content_for_key(key)
+              hash
+            end
+
+            PhraseApp::InContextEditor::HashFlattener.expand_flat_hash(translation_hash, @key)
+          end
+        end
+
+        def cache
+          Thread.current[:phraseapp_cache] ||= build_cache
+        end
+
+        def build_cache
+          cache = PhraseApp::InContextEditor::Cache.new
+        end
+
+        def warm_translation_key_names_cache
+          cache.set(:translation_key_names, prefetched_key_names)
+        end
+
+        def prefetched_key_names
+          prefetched = Set.new
+          PhraseApp::InContextEditor.cache_key_segments_initial.each do |prefix|
+            api_wrapper.keys_with_prefix(prefix).each do |key|
+              prefetched.add(key.name)
+            end
+          end
+          prefetched
+        end
+
+        def key_names_from_nested(segment, data)
+          key_names = Set.new
+          PhraseApp::InContextEditor::HashFlattener.flatten(data, nil) do |key, value|
+            key_names.add("#{segment}.#{key}") unless value.is_a?(Hash)
+          end unless (data.is_a?(String) || data.nil?)
+          key_names
+        end
+
+        def translation_content_for_key(key)
+          default_translations = api_wrapper.default_translation(key)
+          return unless default_translations.present?
+
+          if key.plural
+            default_translations.inject({}) do |hash, translation|
+              hash[translation.plural_suffix.to_sym] = translation.content
+              hash
+            end
+          else
+            default_translations.first.content
+          end
+        end
+
+        def api_wrapper
+          @api_wrapper ||= InContextEditor::ApiWrapper.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+require 'phraseapp-in-context-editor-ruby'
+require 'i18n'
+
+if defined? Rails
+  module PhraseApp
+    module InContextEditor
+      class Engine < Rails::Engine
+        initializer 'phraseapp-in-context-editor-ruby', after: :disable_dependency_loading do |app|
+          if PhraseApp::InContextEditor.enabled?
+            require 'phraseapp-in-context-editor-ruby/adapters/i18n'
+            require 'phraseapp-in-context-editor-ruby/adapters/fast_gettext'
+          end
+
+          ActionView::Base.send :include, PhraseApp::InContextEditor::ViewHelpers
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# -*- encoding : utf-8 -*-
+module PhraseApp
+  module InContextEditor
+    module HashFlattener
+      FLATTEN_SEPARATOR = "."
+      SEPARATOR_ESCAPE_CHAR = "\001"
+
+      def self.flatten(hash, escape, previous_key=nil, &block)
+        hash.each_pair do |key, value|
+          key = escape_default_separator(key) if escape
+          current_key = [previous_key, key].compact.join(FLATTEN_SEPARATOR).to_sym
+          yield current_key, value
+          flatten(value, escape, current_key, &block) if value.is_a?(Hash)
+        end
+      end
+
+      def self.expand_flat_hash(flat_hash, prefix=nil)
+        flat_hash ||= []
+        result = flat_hash.map do |key, value|
+          key = key.gsub(/#{prefix}[\.]?/, '') if prefix
+          to_nested_hash(key, value)
+        end
+
+        result = result.inject({}) { |hash, subhash| hash.deep_merge!(subhash) }
+        result
+      end
+
+      def self.to_nested_hash key, value
+        if contains_only_dots?(key) or starts_with_dot?(key) or ends_with_dot?(key)
+          {key.to_sym => value}
+        else
+          key.to_s.split(".").reverse.inject(value) { |hash, part| {part.to_sym => hash} }
+        end
+      end
+
+      def self.contains_only_dots?(string)
+        string.to_s.gsub(/\./, "").length == 0
+      end
+
+      def self.starts_with_dot?(string)
+        string.to_s.start_with?(".")
+      end
+
+      def self.ends_with_dot?(string)
+        string.to_s.end_with?(".")
+      end
+
+      def self.escape_default_separator(key)
+        key.to_s.tr(FLATTEN_SEPARATOR, SEPARATOR_ESCAPE_CHAR)
+      end
+    end
+  end
+end