i18n-processes 0.1.0

data/lib/i18n/processes/google_translation.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'easy_translate'
+require 'i18n/processes/html_keys'
+
+module I18n::Processes
+  module GoogleTranslation
+    # @param [I18n::Processes::Tree::Siblings] forest to translate to the locales of its root nodes
+    # @param [String] from locale
+    # @return [I18n::Processes::Tree::Siblings] translated forest
+    def google_translate_forest(forest, from)
+      forest.inject empty_forest do |result, root|
+        translated = google_translate_list(root.key_values(root: true), to: root.key, from: from)
+        result.merge! Data::Tree::Siblings.from_flat_pairs(translated)
+      end
+    end
+
+    # @param [Array<[String, Object]>] list of key-value pairs
+    # @return [Array<[String, Object]>] translated list
+    def google_translate_list(list, opts) # rubocop:disable Metrics/AbcSize
+      return [] if list.empty?
+      opts = opts.dup
+      opts[:key] ||= translation_config[:api_key]
+      validate_google_translate_api_key! opts[:key]
+      key_pos = list.each_with_index.inject({}) { |idx, ((k, _v), i)| idx.update(k => i) }
+      # copy reference keys as is, instead of translating
+      reference_key_vals = list.select { |_k, v| v.is_a? Symbol } || []
+      list -= reference_key_vals
+      result = list.group_by { |k_v| html_key? k_v[0], opts[:from] }.map do |is_html, list_slice|
+        fetch_google_translations list_slice, opts.merge(is_html ? { html: true } : { format: 'text' })
+      end.reduce(:+) || []
+      result.concat(reference_key_vals)
+      result.sort! { |a, b| key_pos[a[0]] <=> key_pos[b[0]] }
+      result
+    end
+
+    # @param [Array<[String, Object]>] list of key-value pairs
+    # @return [Array<[String, Object]>] translated list
+    def fetch_google_translations(list, opts)
+      from_values(list, EasyTranslate.translate(to_values(list), opts)).tap do |result|
+        fail CommandError, 'Google Translate returned no results. Make sure billing information is set at https://code.google.com/apis/console.' if result.blank?
+      end
+    end
+
+    private
+
+    def validate_google_translate_api_key!(key)
+      fail CommandError, 'Set Google API key via GOOGLE_TRANSLATE_API_KEY environment variable or translation.api_key in config/i18n-processes.yml. Get the key at https://code.google.com/apis/console.' if key.blank?
+    end
+
+    # @param [Array<[String, Object]>] list of key-value pairs
+    # @return [Array<String>] values for translation extracted from list
+    def to_values(list)
+      list.map { |l| dump_value l[1] }.flatten.compact
+    end
+
+    # @param [Array<[String, Object]>] list
+    # @param [Array<String>] translated_values
+    # @return [Array<[String, Object]>] translated key-value pairs
+    def from_values(list, translated_values)
+      keys                = list.map(&:first)
+      untranslated_values = list.map(&:last)
+      keys.zip parse_value(untranslated_values, translated_values.to_enum)
+    end
+
+    # Prepare value for translation.
+    # @return [String, Array<String, nil>, nil] value for Google Translate or nil for non-string values
+    def dump_value(value)
+      case value
+      when Array
+        # dump recursively
+        value.map { |v| dump_value v }
+      when String
+        replace_interpolations value
+      end
+    end
+
+    # Parse translated value from the each_translated enumerator
+    # @param [Object] untranslated
+    # @param [Enumerator] each_translated
+    # @return [Object] final translated value
+    def parse_value(untranslated, each_translated)
+      case untranslated
+      when Array
+        # implode array
+        untranslated.map { |from| parse_value(from, each_translated) }
+      when String
+        restore_interpolations untranslated, each_translated.next
+      else
+        untranslated
+      end
+    end
+
+    INTERPOLATION_KEY_RE  = /%\{[^}]+}/
+    UNTRANSLATABLE_STRING = 'zxzxzx'
+
+    # @param [String] value
+    # @return [String] 'hello, %{name}' => 'hello, <round-trippable string>'
+    def replace_interpolations(value)
+      i = -1
+      value.gsub INTERPOLATION_KEY_RE do
+        i += 1
+        "#{UNTRANSLATABLE_STRING}#{i}"
+      end
+    end
+
+    # @param [String] untranslated
+    # @param [String] translated
+    # @return [String] 'hello, <round-trippable string>' => 'hello, %{name}'
+    def restore_interpolations(untranslated, translated)
+      return translated if untranslated !~ INTERPOLATION_KEY_RE
+      values = untranslated.scan(INTERPOLATION_KEY_RE)
+      translated.gsub(/#{Regexp.escape(UNTRANSLATABLE_STRING)}\d+/i) do |m|
+        values[m[UNTRANSLATABLE_STRING.length..-1].to_i]
+      end
+    rescue StandardError => e
+      raise CommandError.new(e, <<-TEXT.strip)
+Error when restoring interpolations:
+  original: "#{untranslated}"
+  response: "#{translated}"
+  error: #{e.message} (#{e.class.name})
+      TEXT
+    end
+  end
+end

data/lib/i18n/processes/html_keys.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module HtmlKeys
+    HTML_KEY_PATTERN = /[.\-_]html\z/
+    MAYBE_PLURAL_HTML_KEY_PATTERN = /[.\-_]html\.[^.]+\z/
+
+    def html_key?(full_key, locale)
+      # rubocop:disable Style/DoubleNegation
+      !!(full_key =~ HTML_KEY_PATTERN ||
+          full_key =~ MAYBE_PLURAL_HTML_KEY_PATTERN &&
+              depluralize_key(split_key(full_key, 2)[1], locale) =~ HTML_KEY_PATTERN)
+      # rubocop:enable Style/DoubleNegation
+    end
+  end
+end

data/lib/i18n/processes/ignore_keys.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module I18n::Processes::IgnoreKeys
+  # whether to ignore the key
+  # will also apply global ignore rules
+  # @param [:missing, :unused, :eq_base] ignore_type
+  def ignore_key?(key, ignore_type, locale = nil)
+    key =~ ignore_pattern(ignore_type, locale)
+  end
+
+  # @param type [nil, :missing, :unused, :eq_base] type
+  # @param locale [String] only when type is :eq_base
+  # @return [Regexp] a regexp that matches all the keys ignored for the type (and locale)
+  def ignore_pattern(type, locale = nil)
+    @ignore_patterns              ||= HashWithIndifferentAccess.new
+    @ignore_patterns[type]        ||= {}
+    @ignore_patterns[type][locale] ||= begin
+      global = ignore_config.presence || []
+      type_ignore = ignore_config(type).presence || []
+      patterns = if type_ignore.is_a?(Array)
+                   global + type_ignore
+                 elsif type_ignore.is_a?(Hash)
+                   # ignore per locale
+                   global + (type_ignore['all'] || []) +
+                     type_ignore.select { |k, _v| k.to_s =~ /\b#{locale}\b/ }.values.flatten(1).compact
+                 end
+      compile_patterns_re patterns
+    end
+  end
+end

data/lib/i18n/processes/key_pattern_matching.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module I18n::Processes::KeyPatternMatching
+  module_function # rubocop:disable Style/ModuleFunction
+
+  MATCH_NOTHING = /\z\A/
+
+  # one regex to match any
+  def compile_patterns_re(key_patterns)
+    if key_patterns.blank?
+      # match nothing
+      MATCH_NOTHING
+    else
+      /(?:#{ key_patterns.map { |p| compile_key_pattern p } * '|' })/m
+    end
+  end
+
+  # convert pattern to regex
+  # In patterns:
+  #      *     is like .* in regexs
+  #      :     matches a single key
+  #   { a, b.c } match any in set, can use : and *, match is captured
+  def compile_key_pattern(key_pattern)
+    return key_pattern if key_pattern.is_a?(Regexp)
+    /\A#{key_pattern_re_body(key_pattern)}\z/
+  end
+
+  def key_pattern_re_body(key_pattern)
+    key_pattern
+      .gsub(/\./, '\.')
+      .gsub(/\*/, '.*')
+      .gsub(/:/, '(?<=^|\.)[^.]+?(?=\.|$)')
+      .gsub(/\{(.*?)}/) { "(#{Regexp.last_match(1).strip.gsub(/\s*,\s*/, '|')})" }
+  end
+end

data/lib/i18n/processes/locale_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module LocaleList
+    module_function
+
+    # @return locales converted to strings, with base locale first, the rest sorted alphabetically
+    def normalize_locale_list(locales, base_locale, include_base = false)
+      locales = Array(locales).map(&:to_s).sort
+      if locales.include?(base_locale)
+        [base_locale] + (locales - [base_locale])
+      elsif include_base
+        [base_locale] + locales
+      else
+        locales
+      end
+    end
+  end
+end

data/lib/i18n/processes/locale_pathname.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module LocalePathname
+    class << self
+      def replace_locale(path, from, to)
+        path && path.gsub(path_locale_re(from), to)
+      end
+
+      private
+
+      def path_locale_re(locale)
+        (@path_locale_res ||= {})[locale] ||= %r{(?<=^|[/.])#{locale}(?=[/.])}
+      end
+    end
+  end
+end

data/lib/i18n/processes/logging.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module I18n::Processes::Logging
+  module_function
+
+  MUTEX = Mutex.new
+  PROGRAM_NAME = File.basename($PROGRAM_NAME)
+
+  def warn_deprecated(message)
+    log_stderr Rainbow("#{program_name}: [DEPRECATED] #{message}").yellow.bright
+  end
+
+  def log_verbose(message = nil)
+    log_stderr Rainbow(message || yield).blue.bright if ::I18n::Processes.verbose?
+  end
+
+  def log_warn(message)
+    log_stderr Rainbow("#{program_name}: [WARN] #{message}").yellow
+  end
+
+  def log_error(message)
+    log_stderr Rainbow("#{program_name}: #{message}").red.bright
+  end
+
+  def log_stderr(*args)
+    MUTEX.synchronize do
+      # 1. We don't want output from different threads to get intermixed.
+      # 2. StringIO is currently not thread-safe (blows up) on JRuby:
+      # https://github.com/jruby/jruby/issues/4417
+      $stderr.puts(*args)
+    end
+  end
+
+  def program_name
+    PROGRAM_NAME
+  end
+end

data/lib/i18n/processes/missing_keys.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'set'
+module I18n::Processes
+  module MissingKeys
+    MISSING_TYPES = {
+      used: { glyph: '✗', summary: 'used in code but missing from base locale' },
+      diff: { glyph: '∅', summary: 'translated in one locale but not in the other' }
+    }.freeze
+
+    def self.missing_keys_types
+      @missing_keys_types ||= MISSING_TYPES.keys
+    end
+
+    def missing_keys_types
+      MissingKeys.missing_keys_types
+    end
+
+    # @param types [:used, :diff] all if `nil`.
+    # @return [Siblings]
+    def missing_keys(locales: nil, types: nil, base_locale: nil)
+      locales ||= self.locales
+      types   ||= missing_keys_types
+      base = base_locale || self.base_locale
+      types.inject(empty_forest) do |f, type|
+        f.merge! send(:"missing_#{type}_forest", locales, base)
+      end
+    end
+
+    def eq_base_keys(opts = {})
+      locales = Array(opts[:locales]).presence || self.locales
+      (locales - [base_locale]).inject(empty_forest) do |tree, locale|
+        tree.merge! equal_values_tree(locale, base_locale)
+      end
+    end
+
+    def missing_diff_forest(locales, base = base_locale)
+      tree = empty_forest
+      # present in base but not locale
+      (locales - [base]).each do |locale|
+        tree.merge! missing_diff_tree(locale, base)
+      end
+      if locales.include?(base)
+        # present in locale but not base
+        (self.locales - [base]).each do |locale|
+          tree.merge! missing_diff_tree(base, locale)
+        end
+      end
+      tree
+    end
+
+    def missing_used_forest(locales, _base = base_locale)
+      locales.inject(empty_forest) do |forest, locale|
+        forest.merge! missing_used_tree(locale)
+      end
+    end
+
+    # keys present in compared_to, but not in locale
+    def missing_diff_tree(locale, compared_to = base_locale)
+      data[compared_to].select_keys do |key, _node|
+        locale_key_missing? locale, depluralize_key(key, compared_to)
+      end.set_root_key!(locale, type: :missing_diff).keys do |_key, node|
+        # change path and locale to base
+        data = { locale: locale, missing_diff_locale: node.data[:locale] }
+        # $stderr.puts Rainbow("data: #{data}").green
+        if node.data.key?(:path)
+          data[:path] = LocalePathname.replace_locale(node.data[:path], node.data[:locale], locale)
+        end
+        # $stderr.puts Rainbow("data: #{node.data}").green
+        node.data.update data
+      end
+    end
+
+    # keys used in the code missing translations in locale
+    def missing_used_tree(locale)
+      used_tree(strict: true).select_keys do |key, _node|
+        locale_key_missing?(locale, key)
+      end.set_root_key!(locale, type: :missing_used)
+    end
+
+    def equal_values_tree(locale, compare_to = base_locale)
+      base = data[compare_to].first.children
+      data[locale].select_keys(root: false) do |key, node|
+        other_node = base[key]
+        other_node && !node.reference? && node.value == other_node.value && !ignore_key?(key, :eq_base, locale)
+      end.set_root_key!(locale, type: :eq_base)
+    end
+
+    def locale_key_missing?(locale, key)
+      !key_value?(key, locale) && !external_key?(key) && !ignore_key?(key, :missing)
+    end
+
+    # @param [::I18n::Processes::Data::Tree::Siblings] forest
+    # @yield [::I18n::Processes::Data::Tree::Node]
+    # @yieldreturn [Boolean] whether to collapse the node
+    def collapse_same_key_in_locales!(forest)
+      locales_and_node_by_key = {}
+      to_remove               = []
+      forest.each do |root|
+        locale = root.key
+        root.keys do |key, node|
+          next unless yield node
+          if locales_and_node_by_key.key?(key)
+            locales_and_node_by_key[key][0] << locale
+          else
+            locales_and_node_by_key[key] = [[locale], node]
+          end
+          to_remove << node
+        end
+      end
+      forest.remove_nodes_and_emptied_ancestors! to_remove
+      locales_and_node_by_key.each_with_object({}) do |(key, (locales, node)), inv|
+        (inv[locales.sort.join('+')] ||= []) << [key, node]
+      end.map do |locales, keys_nodes|
+        keys_nodes.each do |(key, node)|
+          forest["#{locales}.#{key}"] = node
+        end
+      end
+      forest
+    end
+  end
+end

data/lib/i18n/processes/path.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module I18n::Processes:: Path
+
+  def origin_files(locale)
+    source = locale == base_locale ? source_path : translation_path[locale.to_sym]
+    [].tap do |file|
+      source.map do |path|
+        path = path[-1] == '/' ? path : path + '/'
+        group = Dir.glob("#{path}**/**")
+        file << group.reject { |x| File.directory?(x) }
+      end
+    end
+  end
+
+  def get_dic(path)
+    {}.tap do |dic|
+      File.open(path).each_line do |line|
+        key = line.split('=').first
+        value = line.split('=').last
+        dic[key] = value
+      end
+    end
+  end
+
+  def source_path
+    config_file[:data][:source]
+  end
+
+  def translation_path
+    config_file[:data][:translation]
+  end
+
+  def translated_path
+    config_file[:data][:translated]
+  end
+
+  def config_file
+    file = Dir.glob(File.join('**', '*.yml')).select{ |x| x.include?'i18n-processes' }
+    YAML.load_file(file.first).deep_symbolize_keys unless file.empty?
+  end
+end

data/lib/i18n/processes/plural_keys.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'set'
+module I18n::Processes::PluralKeys
+  PLURAL_KEY_SUFFIXES = Set.new %w[zero one two few many other]
+  PLURAL_KEY_RE = /\.(?:#{PLURAL_KEY_SUFFIXES.to_a * '|'})$/
+
+  def collapse_plural_nodes!(tree)
+    tree.leaves.map(&:parent).compact.uniq.each do |node|
+      children = node.children
+      next unless plural_forms?(children)
+      node.value    = children.to_hash
+      node.children = nil
+      node.data.merge! children.first.data
+    end
+    tree
+  end
+
+  # @param [String] key i18n key
+  # @param [String] locale to pull key data from
+  # @return [String] the base form if the key is a specific plural form (e.g. apple for apple.many), the key otherwise.
+  def depluralize_key(key, locale = base_locale)
+    return key if key !~ PLURAL_KEY_RE
+    key_name = last_key_part(key)
+    parent_key = key[0..- (key_name.length + 2)]
+    nodes = tree("#{locale}.#{parent_key}").presence || (locale != base_locale && tree("#{base_locale}.#{parent_key}"))
+    if nodes && plural_forms?(nodes)
+      parent_key
+    else
+      key
+    end
+  end
+
+  def plural_forms?(s)
+    s.present? && s.all? { |node| node.leaf? && plural_suffix?(node.key) }
+  end
+
+  def plural_suffix?(key)
+    PLURAL_KEY_SUFFIXES.include?(key)
+  end
+end

data/lib/i18n/processes/rainbow_utils.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module RainbowUtils
+    # TODO: This method can be removed after below PR is released.
+    # https://github.com/sickill/rainbow/pull/53
+    def self.faint_color(str)
+      presenter = Rainbow(str)
+      return presenter unless Rainbow.enabled
+      Rainbow::Presenter.new(Rainbow::StringUtils.wrap_with_sgr(presenter, [2]))
+    end
+  end
+end

data/lib/i18n/processes/references.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module References
+    # Given a raw usage tree and a tree of reference keys in the data, return 3 trees:
+    # 1. Raw references -- a subset of the usages tree with keys that are reference key usages.
+    # 2. Resolved references -- all the used references in their fully resolved form.
+    # 3. Reference keys -- all the used reference keys.
+    def process_references(usages,
+                           data_refs = merge_reference_trees(data_forest.select_keys { |_, node| node.reference? }))
+      fail ArgumentError, 'usages must be a Data::Tree::Instance' unless usages.is_a?(Data::Tree::Siblings)
+      fail ArgumentError, 'all_references must be a Data::Tree::Instance' unless data_refs.is_a?(Data::Tree::Siblings)
+      raw_refs = empty_forest
+      resolved_refs = empty_forest
+      refs = empty_forest
+      data_refs.key_to_node.each do |ref_key_part, ref_node|
+        usages.each do |usage_node|
+          next unless usage_node.key == ref_key_part
+          if ref_node.leaf?
+            process_leaf!(ref_node, usage_node, raw_refs, resolved_refs, refs)
+          else
+            process_non_leaf!(ref_node, usage_node, raw_refs, resolved_refs, refs)
+          end
+        end
+      end
+      [raw_refs, resolved_refs, refs]
+    end
+
+    private
+
+    # @param [I18n::Processes::Data::Tree::Node] ref
+    # @param [I18n::Processes::Data::Tree::Node] usage
+    # @param [I18n::Processes::Data::Tree::Siblings] raw_refs
+    # @param [I18n::Processes::Data::Tree::Siblings] resolved_refs
+    # @param [I18n::Processes::Data::Tree::Siblings] refs
+    def process_leaf!(ref, usage, raw_refs, resolved_refs, refs)
+      refs.merge_node!(Data::Tree::Node.new(key: ref.key, data: usage.data)) unless refs.key_to_node.key?(ref.key)
+      new_resolved_refs = Data::Tree::Siblings.from_key_names([ref.value.to_s]) do |_, resolved_node|
+        raw_refs.merge_node!(usage)
+        if usage.leaf?
+          resolved_node.data.merge!(usage.data)
+        else
+          resolved_node.children = usage.children
+        end
+        resolved_node.leaves { |node| node.data[:ref_info] = [ref.full_key, ref.value.to_s] }
+      end
+      add_occurences! refs.key_to_node[ref.key].data, new_resolved_refs
+      resolved_refs.merge! new_resolved_refs
+    end
+
+    # @param [Hash] ref_data
+    # @param [I18n::Processes::Data::Tree::Siblings] new_resolved_refs
+    def add_occurences!(ref_data, new_resolved_refs)
+      ref_data[:occurrences] ||= []
+      new_resolved_refs.leaves do |leaf|
+        ref_data[:occurrences].concat(leaf.data[:occurrences] || [])
+      end
+      ref_data[:occurrences].sort_by!(&:path)
+      ref_data[:occurrences].uniq!
+    end
+
+    # @param [I18n::Processes::Data::Tree::Node] ref
+    # @param [I18n::Processes::Data::Tree::Node] usage
+    # @param [I18n::Processes::Data::Tree::Siblings] raw_refs
+    # @param [I18n::Processes::Data::Tree::Siblings] resolved_refs
+    # @param [I18n::Processes::Data::Tree::Siblings] refs
+    def process_non_leaf!(ref, usage, raw_refs, resolved_refs, refs)
+      child_raw_refs, child_resolved_refs, child_refs = process_references(usage.children, ref.children)
+      raw_refs.merge_node! Data::Tree::Node.new(key: ref.key, children: child_raw_refs) unless child_raw_refs.empty?
+      resolved_refs.merge! child_resolved_refs
+      refs.merge_node! Data::Tree::Node.new(key: ref.key, children: child_refs) unless child_refs.empty?
+    end
+
+    # Given a forest of references, merge trees into one tree, ensuring there are no conflicting references.
+    # @param roots [I18n::Processes::Data::Tree::Siblings]
+    # @return [I18n::Processes::Data::Tree::Siblings]
+    def merge_reference_trees(roots)
+      roots.inject(empty_forest) do |forest, root|
+        root.keys do |full_key, node|
+          if full_key == node.value.to_s
+            log_warn(
+              "Self-referencing key #{node.full_key(root: false).inspect} in #{node.data[:locale].inspect}"
+            )
+          end
+        end
+        forest.merge!(
+          root.children,
+          on_leaves_merge: lambda do |node, other|
+            if node.value != other.value
+              log_warn(
+                'Conflicting references: '\
+            "#{node.full_key(root: false)} ⮕ #{node.value} in #{node.data[:locale]},"\
+            " but ⮕ #{other.value} in #{other.data[:locale]}"
+              )
+            end
+          end
+        )
+      end
+    end
+  end
+end

data/lib/i18n/processes/reports/base.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module I18n::Processes::Reports
+  class Base
+    include I18n::Processes::Logging
+
+    def initialize(task = I18n::Processes::BaseProcess.new)
+      @task = task
+    end
+
+    attr_reader :task
+    delegate :base_locale, :locales, to: :task
+
+    protected
+
+    def missing_type_info(type)
+      ::I18n::Processes::MissingKeys::MISSING_TYPES[type.to_s.sub(/\Amissing_/, '').to_sym]
+    end
+
+    def missing_title(forest)
+      "Missing translations (#{forest.leaves.count || '∅'})"
+    end
+
+    def unused_title(key_values)
+      "All keys (#{key_values.count || '∅'})"
+    end
+
+    def eq_base_title(key_values, locale = base_locale)
+      "Same value as #{locale} (#{key_values.count || '∅'})"
+    end
+
+    def used_title(keys_nodes, filter)
+      used_n = keys_nodes.map { |_k, node| node.data[:occurrences].size }.reduce(:+).to_i
+      "#{keys_nodes.size} key#{'s' if keys_nodes.size != 1}#{" matching '#{filter}'" if filter}"\
+      "#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n > 0}"
+    end
+
+    # Sort keys by their attributes in order
+    # @param [Hash] order e.g. {locale: :asc, type: :desc, key: :asc}
+    def sort_by_attr!(objects, order = { locale: :asc, key: :asc })
+      order_keys = order.keys
+      objects.sort! do |a, b|
+        by = order_keys.detect { |k| a[k] != b[k] }
+        order[by] == :desc ? b[by] <=> a[by] : a[by] <=> b[by]
+      end
+      objects
+    end
+
+    def forest_to_attr(forest)
+      forest.keys(root: false).map do |key, node|
+        { key: key, value: node.value, type: node.data[:type], locale: node.root.key, data: node.data }
+      end
+    end
+
+    def format_locale(locale)
+      return '' unless locale
+      if locale.split('+') == task.locales.sort
+        'all'
+      else
+        locale.tr '+', ' '
+      end
+    end
+
+    def collapse_missing_tree!(forest)
+      forest = task.collapse_plural_nodes!(forest)
+      forest = task.collapse_same_key_in_locales!(forest) { |node| node.data[:type] == :missing_used }
+      forest
+    end
+
+  end
+end