phraseapp-in-context-editor-ruby 1.3.1 → 2.0.0

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

@@ -1,46 +0,0 @@
-require 'phraseapp-in-context-editor-ruby/fallback_keys_fetcher'
-require 'phraseapp-in-context-editor-ruby/key_names_cache'
-
-module PhraseApp
-  module InContextEditor
-    class DisplayableKeyIdentifier
-      attr_reader :api_wrapper, :key_names_cache
-
-      def initialize(api_wrapper)
-        @api_wrapper = api_wrapper
-        @key_names_cache = KeyNamesCache.new(@api_wrapper)
-      end
-
-      def identify(key_name, options)
-        fallback_key_names = FallbackKeysFetcher.extract_fallback_keys(key_name, options)
-        return key_name if fallback_key_names.empty?
-
-        key_names = [key_name] | fallback_key_names
-        available_key_names = find_keys_within_phraseapp(key_names)
-
-        key_names.each do |item|
-          if available_key_names.include?(item)
-            return item
-          end
-        end
-
-        return key_name
-      end
-
-      private
-
-      def find_keys_within_phraseapp(key_names)
-        key_names_to_check_against_api = key_names - @key_names_cache.pre_fetched(key_names)
-        @key_names_cache.pre_cached(key_names) | key_names_returned_from_api_for(key_names_to_check_against_api)
-      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
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module PhraseApp
-  module InContextEditor
-    class FallbackKeysFetcher
-
-      def self.extract_fallback_keys(key, options)
-        fallback_items = []
-        if options.has_key?(:default)
-          if options[:default].kind_of?(Array)
-            fallback_items = options[:default]
-          else
-            fallback_items << options[:default]
-          end
-        end
-
-        return fallback_items.map{ |item| process_fallback_item(item, key, options) }.flatten.uniq
-      end
-
-      def self.process_fallback_item(item, key, options)
-        fallback_keys = []
-        if item.kind_of?(Symbol)
-          fallback_key_name = item.to_s
-          if options.has_key?(:scope)
-            if options[:scope].is_a?(Array)
-              fallback_key_name = "#{options[:scope].join(".")}.#{item}"
-            else
-              fallback_key_name = "#{options[:scope]}.#{item}"
-            end
-          end
-          fallback_keys << fallback_key_name
-
-          if key == "helpers.label.#{fallback_key_name}" # http://apidock.com/rails/v3.1.0/ActionView/Helpers/FormHelper/label
-            fallback_keys << "activerecord.attributes.#{fallback_key_name}"
-          end
-
-          if key.start_with?("simple_form.") # special treatment for simple form
-            fallback_keys << "activerecord.attributes.#{item}"
-          end
-        end
-
-        return fallback_keys
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# -*- 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

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

@@ -1,53 +0,0 @@
-module PhraseApp
-  module InContextEditor
-    class KeyNamesCache
-      attr_reader :api_wrapper
-
-      def initialize(api_wrapper)
-        @api_wrapper = api_wrapper
-      end
-
-      def pre_cached(key_names)
-        unless cache.cached?(:translation_key_names)
-          cache.set(:translation_key_names, prefetched_key_names)
-        end
-
-        return key_names.select { |key_name| key_name_precached?(key_name) }
-      end
-
-      def pre_fetched(key_names)
-        key_names.select { |key_name| covered_by_initial_caching?(key_name) }
-      end
-
-      private
-
-      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 covered_by_initial_caching?(key_name)
-        key_name.start_with?(*PhraseApp::InContextEditor.cache_key_segments_initial)
-      end
-
-      def key_name_is_in_cache?(key_name)
-        cache.get(:translation_key_names).include?(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)
-        return covered && in_cache
-      end
-
-      def cache
-        RequestStore.store[:phraseapp_cache] ||= PhraseApp::InContextEditor::Cache.new
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module PhraseApp
-  module InContextEditor
-    VERSION = "1.3.1"
-  end
-end