phraseapp_updater 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90f3eb1a3fc564c81e37c06c3de35f659cb27490e3b7280f329e762a505e78c4
-  data.tar.gz: 8548103775510c36d7bad59957de3397cd1b3550fb2de8f4d37ff609a7ce120c
+  metadata.gz: 6279bf1f85138efd48f74dfad8c33bc374c484d763a13864a985b6b7008cb877
+  data.tar.gz: 4d18b2a5b27fed7564625b9ee19b4172a1bfabf976cb889d8f468ac57e3c9a22
 SHA512:
-  metadata.gz: 0f4afe7e685edf935a7f68f8d2682b88c660c01a79ea644fa5205e25450af8108bee671334415408b416e9a1d9a4c4eb01b9ddb4da2e635b22c953c5cc83e0ff
-  data.tar.gz: db6342214253090ae81c35fa058719a9c96863bf17d11f47577a6312542c64e5782fb59b4fb71416f2ab88a7bcbc03526f182c330adee1f6d865db144fab70d8
+  metadata.gz: 8d31f320c4c72c182f3664f90a9d19fe07a8b5debc4d4253f092c5ab16effa25aa94ac2281a6a3a857da500042f354ad20c5852a943fd311faf5dbbd79bd8f38
+  data.tar.gz: 1ab2a71f775c3eb7ed9c0d8c2d2ca9ee92b5d633de1439e929a096fa9f1b3b7ee66da9e6756ae058804936f37ce1a5c075306853bfd68c2a541cca760bb7a4f5

data/bin/phraseapp_updater

@@ -7,6 +7,7 @@ require 'phraseapp_updater'
 class PhraseAppUpdaterCLI < Thor
   class_option :default_locale, type: :string, default: 'en',   desc: 'PhraseApp default locale'
   class_option :file_format,    type: :string, default: 'json', desc: 'Filetype of localization files.'
+  class_option :verbose,        type: :boolean, default: false, desc: 'Verbose output'
 
   desc 'setup <locale_path>',
        'Create a new PhraseApp project, initializing it with locale files at <locale_path>. the new project ID is printed to STDOUT'
@@ -22,7 +23,8 @@ class PhraseAppUpdaterCLI < Thor
                  options[:phraseapp_api_key],
                  options[:phraseapp_project_name],
                  options[:file_format],
-                 options[:parent_commit])
+                 options[:parent_commit],
+                 verbose: options[:verbose])
 
       updater.upload_directory(locales_path)
 
@@ -50,6 +52,7 @@ class PhraseAppUpdaterCLI < Thor
     ENV['PREFIX']      = options[:prefix]
     ENV['BRANCH']      = options.fetch(:branch) { sh('git rev-parse --abbrev-ref HEAD').chomp }
     ENV['REMOTE']      = options.fetch(:remote) { sh("git config branch.#{ENV['BRANCH']}.remote").chomp }
+    ENV['VERBOSE']     = options[:verbose] ? 't' : 'f'
 
     shell_script_path = File.join(__dir__, 'synchronize_phraseapp.sh')
     exec(shell_script_path)
@@ -67,7 +70,8 @@ class PhraseAppUpdaterCLI < Thor
       updater = PhraseAppUpdater.new(
         options[:phraseapp_api_key],
         options[:phraseapp_project_id],
-        options[:file_format])
+        options[:file_format],
+        verbose: options[:verbose])
 
       updater.download_to_directory(target_path)
       parent_commit = updater.read_parent_commit
@@ -94,7 +98,8 @@ class PhraseAppUpdaterCLI < Thor
       updater = PhraseAppUpdater.new(
         options[:phraseapp_api_key],
         options[:phraseapp_project_id],
-        options[:file_format])
+        options[:file_format],
+        verbose: options[:verbose])
 
       updater.upload_directory(source_path)
       updater.update_parent_commit(options[:parent_commit])
@@ -110,7 +115,8 @@ class PhraseAppUpdaterCLI < Thor
       updater = PhraseAppUpdater.new(
         options[:phraseapp_api_key],
         options[:phraseapp_project_id],
-        options[:file_format])
+        options[:file_format],
+        verbose: options[:verbose])
 
       updater.update_parent_commit(options[:parent_commit])
     end
@@ -131,7 +137,7 @@ class PhraseAppUpdaterCLI < Thor
     validate_readable_path!('path2', path2)
 
     handle_errors do
-      updater = PhraseAppUpdater.new(nil, nil, options[:file_format])
+      updater = PhraseAppUpdater.new(nil, nil, options[:file_format], verbose: options[:verbose])
       diffs = updater.diff_directories(path1, path2)
       if diffs.empty?
         exit(0)
@@ -162,7 +168,7 @@ class PhraseAppUpdaterCLI < Thor
     validate_writable_path!('to', result_path)
 
     handle_errors do
-      updater = PhraseAppUpdater.new(nil, nil, options[:file_format])
+      updater = PhraseAppUpdater.new(nil, nil, options[:file_format], verbose: options[:verbose])
       updater.merge_directories(our_path, their_path, ancestor_path, result_path)
     end
   end
@@ -192,7 +198,7 @@ class PhraseAppUpdaterCLI < Thor
     # pass `nil` to `merge_files`.
     ancestor = nil if File.zero?(ancestor)
 
-    updater = PhraseAppUpdater.new(nil, nil, file_format)
+    updater = PhraseAppUpdater.new(nil, nil, file_format, verbose: options[:verbose])
     updater.merge_files(ours, theirs, ancestor, to)
   end
 

data/bin/synchronize_phraseapp.sh

@@ -13,7 +13,7 @@ fi
 
 # Configuration is via environment, and expected to be provided from a Ruby
 # driver.
-for variable in PHRASEAPP_API_KEY PHRASEAPP_PROJECT_ID BRANCH REMOTE PREFIX FILE_FORMAT NO_COMMIT; do
+for variable in PHRASEAPP_API_KEY PHRASEAPP_PROJECT_ID BRANCH REMOTE PREFIX FILE_FORMAT NO_COMMIT VERBOSE; do
     if [ -z "${!variable}" ]; then
         echo "Error: must specify $variable" >&2
         exit 1
@@ -30,6 +30,7 @@ current_phraseapp_path=$(make_temporary_directory)
 common_ancestor=$(phraseapp_updater download "${current_phraseapp_path}" \
                       --phraseapp_api_key="${PHRASEAPP_API_KEY}" \
                       --phraseapp_project_id="${PHRASEAPP_PROJECT_ID}" \
+                      --verbose="${VERBOSE}" \
                       --file_format="${FILE_FORMAT}")
 
 # If common_ancestor is not available or reachable from BRANCH, we've been
@@ -74,6 +75,7 @@ if [ "${phraseapp_changed}" = 't' ] && [ "${branch_changed}" = 't' ]; then
     merge_resolution_path=$(make_temporary_directory)
     phraseapp_updater merge "${common_ancestor_path}" "${current_branch_path}" "${current_phraseapp_path}" \
                       --to "${merge_resolution_path}" \
+                      --verbose="${VERBOSE}"          \
                       --file_format="${FILE_FORMAT}"
 
     if [ "$NO_COMMIT" != 't' ]; then
@@ -92,6 +94,7 @@ if [ "${phraseapp_changed}" = 't' ] && [ "${branch_changed}" = 't' ]; then
                            -p "${current_branch}" \
                            -p "${phraseapp_commit}" \
                            -m "Merged locale changes from PhraseApp" \
+                           -m "Since common ancestor ${common_ancestor}" \
                            -m "X-PhraseApp-Merge: ${phraseapp_commit}")
 
         # Push to BRANCH
@@ -108,6 +111,7 @@ if [ "${phraseapp_changed}" = 't' ] && [ "${branch_changed}" = 't' ]; then
                       --parent_commit="${new_parent_commit}" \
                       --phraseapp_api_key="${PHRASEAPP_API_KEY}" \
                       --phraseapp_project_id="${PHRASEAPP_PROJECT_ID}" \
+                      --verbose="${VERBOSE}" \
                       --file_format="${FILE_FORMAT}"
 
 elif [ "${branch_changed}" = 't' ]; then
@@ -118,6 +122,7 @@ elif [ "${branch_changed}" = 't' ]; then
                       --parent_commit="${current_branch}" \
                       --phraseapp_api_key="${PHRASEAPP_API_KEY}" \
                       --phraseapp_project_id="${PHRASEAPP_PROJECT_ID}" \
+                      --verbose="${VERBOSE}" \
                       --file_format="${FILE_FORMAT}"
 
 elif [ "${phraseapp_changed}" = 't' ]; then
@@ -127,7 +132,8 @@ elif [ "${phraseapp_changed}" = 't' ]; then
         updated_branch_tree=$(replace_nested_tree "${current_branch}^{tree}" "${PREFIX}" "${current_phraseapp_tree}")
         update_commit=$(git commit-tree "${updated_branch_tree}" \
                             -p "${current_branch}" \
-                            -m "Incorporate locale changes from PhraseApp")
+                            -m "Incorporate locale changes from PhraseApp" \
+                            -m "Since common ancestor ${common_ancestor}")
 
         git push "${REMOTE}" "${update_commit}:refs/heads/${BRANCH}"
 
@@ -135,6 +141,7 @@ elif [ "${phraseapp_changed}" = 't' ]; then
         phraseapp_updater update_parent_commit \
                           --parent_commit="${update_commit}" \
                           --phraseapp_api_key="${PHRASEAPP_API_KEY}" \
+                          --verbose="${VERBOSE}" \
                           --phraseapp_project_id="${PHRASEAPP_PROJECT_ID}"
     else
         echo "Only PhraseApp changed: not committing to $BRANCH branch" >&2

data/lib/phraseapp_updater.rb

@@ -10,16 +10,17 @@ require 'phraseapp_updater/yml_config_loader'
 class PhraseAppUpdater
   using IndexBy
 
-  def self.for_new_project(phraseapp_api_key, phraseapp_project_name, file_format, parent_commit)
+  def self.for_new_project(phraseapp_api_key, phraseapp_project_name, file_format, parent_commit, verbose: false)
     api = PhraseAppAPI.new(phraseapp_api_key, nil, LocaleFile.class_for_file_format(file_format))
     project_id = api.create_project(phraseapp_project_name, parent_commit)
-    return self.new(phraseapp_api_key, project_id, file_format), project_id
+    return self.new(phraseapp_api_key, project_id, file_format, verbose: verbose), project_id
   end
 
-  def initialize(phraseapp_api_key, phraseapp_project_id, file_format, default_locale: 'en')
+  def initialize(phraseapp_api_key, phraseapp_project_id, file_format, default_locale: 'en', verbose: false)
     @locale_file_class = LocaleFile.class_for_file_format(file_format)
     @default_locale    = default_locale
     @phraseapp_api     = PhraseAppAPI.new(phraseapp_api_key, phraseapp_project_id, @locale_file_class)
+    @verbose           = verbose
   end
 
   def diff_directories(our_path, their_path)
@@ -84,6 +85,7 @@ class PhraseAppUpdater
     locale_names = Set.new.merge(ours.keys).merge(theirs.keys)
 
     locale_names.map do |locale_name|
+      STDERR.puts "Merging #{locale_name}" if @verbose
       our_file      = ours[locale_name]
       their_file    = theirs[locale_name]
       ancestor_file = ancestors[locale_name]
@@ -118,7 +120,7 @@ class PhraseAppUpdater
     else
       ancestor_file ||= empty_locale_file(our_file.locale_name)
 
-      resolved_content = Differ.resolve!(
+      resolved_content = Differ.new(verbose: @verbose).resolve!(
         original:  ancestor_file.parsed_content,
         primary:   our_file.parsed_content,
         secondary: their_file.parsed_content)

data/lib/phraseapp_updater/differ.rb

@@ -1,144 +1,160 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'hashdiff'
 require 'deep_merge'
 
 class PhraseAppUpdater
   class Differ
-    SEPARATOR = "~~~"
+    SEPARATOR = '~~~'
     using IndexBy
 
-    class << self
-      # Resolution strategy is that primary always wins in the event of a conflict
-      def resolve_diffs(primary:, secondary:, secondary_deleted_prefixes:)
-        primary   = primary.index_by   { |op, path, from, to| path }
-        secondary = secondary.index_by { |op, path, from, to| path }
-
-        # As well as explicit conflicts, we want to make sure that deletions or
-        # incompatible type changes to a `primary` key prevent addition of child
-        # keys in `secondary`. Because input hashes are flattened, it's never
-        # possible for a given path and its prefix to be in the same input.
-        # For example, in:
-        #
-        # primary   = [["+", "a", 1]]
-        # secondary = [["+", "a.b", 2]]
-        #
-        # the secondary change is impossible to perform on top of the primary, and
-        # must be blocked.
-        #
-        # This applies in reverse: prefixes of paths in `p` need to be available
-        # as hashes, so must not appear as terminals in `s`:
-        #
-        # primary   = [["+", "a.b", 2]]
-        # secondary = [["+", "a",   1]]
-        primary_prefixes = primary.keys.flat_map { |p| path_prefixes(p) }.to_set
-
-        # Remove conflicting entries from secondary, recording incompatible
-        # changes.
-        path_conflicts = []
-        secondary.delete_if do |path, diff|
-          if primary_prefixes.include?(path) || primary.keys.any? { |pk| path.start_with?(pk) }
-            path_conflicts << path unless primary.has_key?(path) && diff == primary[path]
-            true
-          else
-            false
-          end
-        end
-
-        # For all path conflicts matching secondary_deleted_prefixes, additionally
-        # remove other changes with the same prefix.
-        prefix_conflicts = secondary_deleted_prefixes.select do |prefix|
-          path_conflicts.any? { |path| path.start_with?(prefix) }
-        end
+    def initialize(verbose: false)
+      @verbose = verbose
+    end
 
-        secondary.delete_if do |path, diff|
-          prefix_conflicts.any? { |prefix| path.start_with?(prefix) }
+    # Resolution strategy is that primary always wins in the event of a conflict
+    def resolve_diffs(primary:, secondary:, secondary_deleted_prefixes:)
+      primary   = primary.index_by   { |op, path, from, to| path }
+      secondary = secondary.index_by { |op, path, from, to| path }
+
+      # As well as explicit conflicts, we want to make sure that deletions or
+      # incompatible type changes to a `primary` key prevent addition of child
+      # keys in `secondary`. Because input hashes are flattened, it's never
+      # possible for a given path and its prefix to be in the same input.
+      # For example, in:
+      #
+      # primary   = [["+", "a", 1]]
+      # secondary = [["+", "a.b", 2]]
+      #
+      # the secondary change is impossible to perform on top of the primary, and
+      # must be blocked.
+      #
+      # This applies in reverse: prefixes of paths in `p` need to be available
+      # as hashes, so must not appear as terminals in `s`:
+      #
+      # primary   = [["+", "a.b", 2]]
+      # secondary = [["+", "a",   1]]
+      primary_prefixes = primary.keys.flat_map { |p| path_prefixes(p) }.to_set
+
+      # Remove conflicting entries from secondary, recording incompatible
+      # changes.
+      path_conflicts = []
+      secondary.delete_if do |path, diff|
+        if primary_prefixes.include?(path) || primary.keys.any? { |pk| path.start_with?(pk) }
+          path_conflicts << path unless primary.has_key?(path) && diff == primary[path]
+          true
+        else
+          false
         end
+      end
 
-        primary.values + secondary.values
+      # For all path conflicts matching secondary_deleted_prefixes, additionally
+      # remove other changes with the same prefix.
+      prefix_conflicts = secondary_deleted_prefixes.select do |prefix|
+        path_conflicts.any? { |path| path.start_with?(prefix) }
       end
 
-      def apply_diffs(hash, diffs)
-        deep_compact!(HashDiff.patch!(hash, diffs))
+      secondary.delete_if do |path, diff|
+        prefix_conflicts.any? { |prefix| path.start_with?(prefix) }
       end
 
-      def resolve!(original:, primary:, secondary:)
-        # To appropriately cope with type changes on either sides, flatten the
-        # trees before calculating the difference and then expand afterwards.
-        f_original  = flatten(original)
-        f_primary   = flatten(primary)
-        f_secondary = flatten(secondary)
-
-        primary_diffs   = HashDiff.diff(f_original, f_primary)
-        secondary_diffs = HashDiff.diff(f_original, f_secondary)
-
-        # However, flattening discards one critical piece of information: when we
-        # have deleted or clobbered an entire prefix (subtree) from the original,
-        # we want to consider this deletion atomic. If any of the changes is
-        # cancelled, they must all be. Motivating example:
-        #
-        # original:  { word: { one: "..", "many": ".." } }
-        # primary:   { word: { one: "..", "many": "..", "zero": ".." } }
-        # secondary: { word: ".." }
-        # would unexpectedly result in { word: { zero: ".." } }.
-        #
-        # Additionally calculate subtree prefixes that were deleted in `secondary`:
-        secondary_deleted_prefixes =
-          HashDiff.diff(original, secondary, delimiter: SEPARATOR).lazy
+      primary.values + secondary.values
+    end
+
+    def apply_diffs(hash, diffs)
+      deep_compact!(HashDiff.patch!(hash, diffs))
+    end
+
+    def resolve!(original:, primary:, secondary:)
+      # To appropriately cope with type changes on either sides, flatten the
+      # trees before calculating the difference and then expand afterwards.
+      f_original  = flatten(original)
+      f_primary   = flatten(primary)
+      f_secondary = flatten(secondary)
+
+      primary_diffs   = HashDiff.diff(f_original, f_primary)
+      secondary_diffs = HashDiff.diff(f_original, f_secondary)
+
+      # However, flattening discards one critical piece of information: when we
+      # have deleted or clobbered an entire prefix (subtree) from the original,
+      # we want to consider this deletion atomic. If any of the changes is
+      # cancelled, they must all be. Motivating example:
+      #
+      # original:  { word: { one: "..", "many": ".." } }
+      # primary:   { word: { one: "..", "many": "..", "zero": ".." } }
+      # secondary: { word: ".." }
+      # would unexpectedly result in { word: { zero: ".." } }.
+      #
+      # Additionally calculate subtree prefixes that were deleted in `secondary`:
+      secondary_deleted_prefixes =
+        HashDiff.diff(original, secondary, delimiter: SEPARATOR).lazy
           .select { |op, path, from, to| (op == "-" || op == "~") && from.is_a?(Hash) && !to.is_a?(Hash) }
           .map    { |op, path, from, to| path }
           .to_a
 
 
-        resolved_diffs = resolve_diffs(primary:   primary_diffs,
-                                       secondary: secondary_diffs,
-                                       secondary_deleted_prefixes: secondary_deleted_prefixes)
-        HashDiff.patch!(f_original, resolved_diffs)
+      resolved_diffs = resolve_diffs(primary:   primary_diffs,
+                                     secondary: secondary_diffs,
+                                     secondary_deleted_prefixes: secondary_deleted_prefixes)
 
-        expand(f_original)
-      end
+      if @verbose
+        STDERR.puts('Primary diffs:')
+        primary_diffs.each { |d| STDERR.puts(d.inspect) }
 
+        STDERR.puts('Secondary diffs:')
+        secondary_diffs.each { |d| STDERR.puts(d.inspect) }
 
-      # Prefer everything in current except deletions,
-      # which are restored from previous if available
-      def restore_deletions(current, previous)
-        current.deep_merge(previous)
+        STDERR.puts('Resolution:')
+        resolved_diffs.each { |d| STDERR.puts(d.inspect) }
       end
 
-      private
+      HashDiff.patch!(f_original, resolved_diffs)
+
+      expand(f_original)
+    end
+
+
+    # Prefer everything in current except deletions,
+    # which are restored from previous if available
+    def restore_deletions(current, previous)
+      current.deep_merge(previous)
+    end
+
+    private
 
-      def flatten(hash, prefix = nil, acc = {})
-        hash.each do |k, v|
-          k = "#{prefix}#{SEPARATOR}#{k}" if prefix
-          if v.is_a?(Hash)
-            flatten(v, k, acc)
-          else
-            acc[k] = v
-          end
+    def flatten(hash, prefix = nil, acc = {})
+      hash.each do |k, v|
+        k = "#{prefix}#{SEPARATOR}#{k}" if prefix
+        if v.is_a?(Hash)
+          flatten(v, k, acc)
+        else
+          acc[k] = v
         end
-        acc
       end
+      acc
+    end
 
-      def expand(flat_hash)
-        flat_hash.each_with_object({}) do |(key, value), root|
-          path = key.split(SEPARATOR)
-          leaf_key = path.pop
-          leaf = path.inject(root) do |node, path_key|
-            node[path_key] ||= {}
-          end
-          raise ArgumentError.new("Type conflict in flattened hash expand: expected no key at #{key}") if leaf.has_key?(leaf_key)
-          leaf[leaf_key] = value
+    def expand(flat_hash)
+      flat_hash.each_with_object({}) do |(key, value), root|
+        path = key.split(SEPARATOR)
+        leaf_key = path.pop
+        leaf = path.inject(root) do |node, path_key|
+          node[path_key] ||= {}
         end
+        raise ArgumentError.new("Type conflict in flattened hash expand: expected no key at #{key}") if leaf.has_key?(leaf_key)
+        leaf[leaf_key] = value
       end
+    end
 
-      def path_prefixes(path_string)
-        path = path_string.split(SEPARATOR)
-        parents = []
-        path.inject do |acc, el|
-          parents << acc
-          "#{acc}#{SEPARATOR}#{el}"
-        end
-        parents
+    def path_prefixes(path_string)
+      path = path_string.split(SEPARATOR)
+      parents = []
+      path.inject do |acc, el|
+        parents << acc
+        "#{acc}#{SEPARATOR}#{el}"
       end
+      parents
     end
   end
 end

data/lib/phraseapp_updater/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class PhraseAppUpdater
-  VERSION = '2.0.4'
+  VERSION = '2.0.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phraseapp_updater
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - Kevin Griffin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-07 00:00:00.000000000 Z
+date: 2019-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor