kintsugi 0.6.2 → 0.7.0

data/lib/kintsugi/cli.rb

@@ -33,23 +33,31 @@ module Kintsugi
     def create_driver_subcommand
       option_parser =
         OptionParser.new do |opts|
-          opts.banner = "Usage: kintsugi driver BASE OURS THEIRS ORIGINAL_FILE_PATH\n" \
+          opts.banner = "Usage: kintsugi driver BASE OURS THEIRS ORIGINAL_FILE_PATH [options]\n" \
             "Uses Kintsugi as a Git merge driver. Parameters " \
             "should be the path to base version of the file, path to ours version, path to " \
             "theirs version, and the original file path."
 
+          opts.on("--interactive-resolution=FLAG", TrueClass, "In case a conflict that requires " \
+            "human decision to resolve, show an interactive prompt with choices to resolve it")
+
           opts.on("-h", "--help", "Prints this help") do
             puts opts
             exit
           end
         end
 
-      driver_action = lambda { |_, arguments|
+      driver_action = lambda { |options, arguments|
         if arguments.count != 4
           puts "Incorrect number of arguments to 'driver' subcommand\n\n"
           puts option_parser
           exit(1)
         end
+
+        unless options[:"interactive-resolution"].nil?
+          Settings.interactive_resolution = options[:"interactive-resolution"]
+        end
+
         Kintsugi.three_way_merge(arguments[0], arguments[1], arguments[2], arguments[3])
         warn "\e[32mKintsugi auto-merged #{arguments[3]}\e[0m"
       }
@@ -64,8 +72,9 @@ module Kintsugi
     def create_install_driver_subcommand
       option_parser =
         OptionParser.new do |opts|
-          opts.banner = "Usage: kintsugi install-driver\n" \
-            "Installs Kintsugi as a Git merge driver globally. "
+          opts.banner = "Usage: kintsugi install-driver [driver-options]\n" \
+            "Installs Kintsugi as a Git merge driver globally. `driver-options` will be passed " \
+            "to `kintsugi driver`."
 
           opts.on("-h", "--help", "Prints this help") do
             puts opts
@@ -73,7 +82,7 @@ module Kintsugi
           end
         end
 
-      action = lambda { |_, arguments|
+      action = lambda { |options, arguments|
         if arguments.count != 0
           puts "Incorrect number of arguments to 'install-driver' subcommand\n\n"
           puts option_parser
@@ -85,7 +94,7 @@ module Kintsugi
           exit(1)
         end
 
-        install_kintsugi_driver_globally
+        install_kintsugi_driver_globally(options)
         puts "Done! 🪄"
       }
 
@@ -96,9 +105,10 @@ module Kintsugi
       )
     end
 
-    def install_kintsugi_driver_globally
+    def install_kintsugi_driver_globally(options)
       `git config --global merge.kintsugi.name "Kintsugi driver"`
-      `git config --global merge.kintsugi.driver "kintsugi driver %O %A %B %P"`
+      kintsugi_command = "kintsugi driver %O %A %B %P #{options}"
+      `git config --global merge.kintsugi.driver "#{kintsugi_command}"`
 
       attributes_file_path = global_attributes_file_path
       FileUtils.mkdir_p(File.dirname(attributes_file_path))
@@ -185,6 +195,9 @@ module Kintsugi
 
         opts.on("--allow-duplicates", "Allow to add duplicates of the same entity")
 
+        opts.on("--interactive-resolution=FLAG", TrueClass, "In case a conflict that requires " \
+                "human decision to resolve, show an interactive prompt with choices to resolve it")
+
         opts.on_tail("\nSUBCOMMANDS\n#{subcommands_descriptions(subcommands)}")
       end
 
@@ -199,6 +212,10 @@ module Kintsugi
           Settings.allow_duplicates = true
         end
 
+        unless options[:"interactive-resolution"].nil?
+          Settings.interactive_resolution = options[:"interactive-resolution"]
+        end
+
         project_file_path = File.expand_path(arguments[0])
         Kintsugi.resolve_conflicts(project_file_path, options[:"changes-output-path"])
         puts "Resolved conflicts successfully"

data/lib/kintsugi/conflict_resolver.rb

@@ -0,0 +1,130 @@
+# Copyright (c) 2023 Lightricks. All rights reserved.
+# Created by Ben Yohay.
+# frozen_string_literal: true
+
+require "tty-prompt"
+
+module Kintsugi
+  class ConflictResolver
+    class << self
+      # Should be called when trying to add a subgroup with name `subgroup_name` whose containing
+      # group with path `containing_group_path` doesn't exist. Returns `true` if the cotaining
+      # group should be created and `false` if adding the subgroup should be ignored.
+      def create_nonexistent_group_when_adding_subgroup?(containing_group_path, subgroup_name)
+        resolve_merge_error(
+          "Trying to create group '#{subgroup_name}' inside a group that doesn't exist. The " \
+          "group's path is '#{containing_group_path}'",
+          {
+            "Create containing group with path '#{containing_group_path}'": true,
+            "Ignore adding group '#{subgroup_name}'": false
+          }
+        )
+      end
+
+      # Should be called when trying to add a file with name `file_name` whose containing group
+      # with path `containing_group_path` doesn't exist. Returns `true` if the cotaining group
+      # should be created and `false` if adding the file should be ignored.
+      def create_nonexistent_group_when_adding_file?(containing_group_path, file_name)
+        resolve_merge_error(
+          "Trying to add or move a file with name '#{file_name}' to a group that doesn't exist. " \
+          "The group's path is '#{containing_group_path}'",
+          {
+            "Create group with path '#{containing_group_path}'": true,
+            "Ignore adding file '#{file_name}'": false
+          }
+        )
+      end
+
+      # Should be called when trying to apply changes to a component with path `path` that doesn't
+      # exist. Returns `true` if the component should be created and `false` if applying the changes
+      # to it should be ignored.
+      def create_nonexistent_component_when_changing_it?(path)
+        resolve_merge_error(
+          "Trying to apply change to a component that doesn't exist at path '#{path}'",
+          {
+            'Create component and the components that contain it': true,
+            'Ignore change to component': false
+          }
+        )
+      end
+
+      # Should be called when trying to merge `new_hash` into `new_hash` but `new_hash` contains
+      # keys that exist in `old_hash`. Returns `true` if the keys should be overriden from
+      # `new_hash`, `false` to keep the values from `old_hash`.
+      def override_values_when_keys_already_exist_in_hash?(hash_name, old_hash, new_hash)
+        resolve_merge_error(
+          "Trying to add values to hash of attribute named '#{hash_name}': Merging hash " \
+          "#{new_hash} into existing hash #{old_hash} but it contains values that already " \
+          "exist",
+          {
+            'Override values from new hash': true,
+            'Ignore values from new hash': false
+          }
+        )
+      end
+
+      # Should be called when trying to remove entries from a hash of an attribute named
+      # `hash_name`. The values of those entries were expected to be `expected_values` but instead
+      # they are `actual_values`. Returns `true` if the entries should be removed anyway, `false`
+      # to keep the entries.
+      def remove_entries_when_unexpected_values_in_hash?(hash_name, expected_values, actual_values)
+        resolve_merge_error(
+          "Trying to remove entries from hash of attribute named '#{hash_name}': Expected values " \
+          "for keys to be '#{expected_values}' but the existing values are '#{actual_values}'",
+          {
+            'Remove entries anyway': true,
+            'Keep entries': false
+          }
+        )
+      end
+
+      # Should be called when setting a string named `string_name` to value `new_value` and its
+      # expected value is `expected_value` but it has a value of `actual_value`. Returns `true` if
+      # the string should be set to `new_value`, `false` if the `actual_value` should remain.
+      def set_value_to_string_when_unxpected_value?(
+        string_name, new_value, expected_value, actual_value
+      )
+        resolve_merge_error(
+          "Trying to change value of attribute named '#{string_name} from '#{new_value}' to " \
+          "'#{expected_value || "nil"}', but the existing value is '#{actual_value}'",
+          {
+            "Set to new value '#{new_value}'": true,
+            "Keep existing value '#{actual_value}'": false
+          }
+        )
+      end
+
+      # Should be called when trying to remove a `component` who's expected to have a hash equal to
+      # `change` but they are not equal. Returns `true` if `component` should be removed anyway,
+      # `false` otherwise.
+      def remove_component_when_unexpected_hash?(component, change)
+        resolve_merge_error(
+          "Trying to remove a component named '#{component.display_name}': Expected hash of " \
+          "#{change} but its hash is #{component.to_tree_hash}",
+          {
+            'Remove object anyway': true,
+            'Keep object': false
+          }
+        )
+      end
+
+      private
+
+      def resolve_merge_error(message, options)
+        unless Settings.interactive_resolution
+          raise MergeError, "Merge error: #{message}"
+        end
+
+        prompt = TTY::Prompt.new
+        options = options.merge(
+          {Abort: -> { raise MergeError, "Merge error: #{message}" }}
+        )
+
+        prompt.select(
+          "A merge conflict that needs manual intervention occurred: #{message}. Choose one:",
+          options
+        )
+      end
+    end
+  end
+end

data/lib/kintsugi/merge.rb

@@ -42,7 +42,8 @@ module Kintsugi
         File.write(changes_output_path, JSON.pretty_generate(change))
       end
 
-      apply_change_and_copy_to_original_path(ours_project, change, project_file_path)
+      apply_change_and_copy_to_original_path(ours_project, change, project_file_path,
+                                             theirs_project)
     end
 
     # Merges the changes done between `theirs_project_path` and `base_project_path` to the file at
@@ -82,15 +83,17 @@ module Kintsugi
         Xcodeproj::Differ.project_diff(theirs_temporary_project, base_temporary_project,
                                        :added, :removed)
 
-      apply_change_and_copy_to_original_path(ours_temporary_project, change, ours_project_path)
+      apply_change_and_copy_to_original_path(ours_temporary_project, change, ours_project_path,
+                                             theirs_temporary_project)
     end
 
     private
 
     PROJECT_FILE_NAME = "project.pbxproj"
 
-    def apply_change_and_copy_to_original_path(project, change, original_project_file_path)
-      apply_change_to_project(project, change)
+    def apply_change_and_copy_to_original_path(project, change, original_project_file_path,
+                                               theirs_project)
+      apply_change_to_project(project, change, theirs_project)
       project.save
       FileUtils.cp(File.join(project.path, PROJECT_FILE_NAME), original_project_file_path)
     end

data/lib/kintsugi/settings.rb

@@ -10,9 +10,17 @@ module Kintsugi
       # otherwise.
       attr_writer :allow_duplicates
 
+      # `true` if Kintsugi should ask the user for guide on how to resolve some conflicts
+      # interactively, `false` if an error should be thrown instead.
+      attr_writer :interactive_resolution
+
       def allow_duplicates
         @allow_duplicates || false
       end
+
+      def interactive_resolution
+        @interactive_resolution.nil? ? $stdout.isatty : @interactive_resolution
+      end
     end
   end
 end

data/lib/kintsugi/version.rb

@@ -3,6 +3,6 @@
 module Kintsugi
   # This module holds the Kintsugi version information.
   module Version
-    STRING = "0.6.2"
+    STRING = "0.7.0"
   end
 end

data/lib/kintsugi/xcodeproj_extensions.rb

@@ -6,6 +6,16 @@ require "xcodeproj"
 
 module Xcodeproj
   class Project
+    # Returns the group found at `path`. If `path` is empty returns the main group. Returns `nil` if
+    # the group at path was not found.
+    #
+    # @param  [String] Path to the group.
+    #
+    # @return [PBXGroup/PBXVariantGroup/PBXFileReference]
+    def group_or_file_at_path(path)
+      path.empty? ? self.main_group : self[path]
+    end
+
     # Extends `ObjectDictionary` to act like an `Object` if `self` repreresents a project reference.
     class ObjectDictionary
       @@old_to_tree_hash = instance_method(:to_tree_hash)
@@ -29,6 +39,45 @@ module Xcodeproj
     end
 
     module Object
+      # Modifies `PBXContainerItemProxy` to include relevant data in `displayName`.
+      # Currently, its `display_name` is just a constant for all `PBXContainerItemProxy` objects.
+      class PBXContainerItemProxy
+        def display_name
+          "#{self.remote_info} (#{self.remote_global_id_string})"
+        end
+      end
+
+      # Modifies `PBXReferenceProxy` to include more data in `displayName` to make it unique.
+      class PBXReferenceProxy
+        @@old_display_name = instance_method(:display_name)
+
+        def display_name
+          if self.remote_ref.nil?
+            @@old_display_name.bind(self).call
+          else
+            @@old_display_name.bind(self).call + " - " + self.remote_ref.display_name
+          end
+        end
+      end
+
+      # Modifies `PBXBuildFile` to calculate `ascii_plist_annotation` based on the underlying
+      # object's `ascii_plist_annotation` instead of relying on its `display_name`, as
+      # `display_name` might contain information that shouldn't be written to the project.
+      class PBXBuildFile
+        def ascii_plist_annotation
+          underlying_annotation =
+            if product_ref
+              product_ref.ascii_plist_annotation
+            elsif file_ref
+              file_ref.ascii_plist_annotation
+            else
+              super
+            end
+
+          " #{underlying_annotation.strip} in #{GroupableHelper.parent(self).display_name} "
+        end
+      end
+
       # Extends `XCBuildConfiguration` to convert array settings (which might be either array or
       # string) to actual arrays in `to_tree_hash` so diffs are always between arrays. This means
       # that if the values in both `ours` and `theirs` are different strings, we will know to solve
@@ -128,7 +177,6 @@ module Xcodeproj
     #         Second array to the difference operation.
     #
     # @return [Array]
-    #
     def self.array_non_unique_diff(value_1, value_2)
       value_2_elements_by_count = value_2.reduce({}) do |hash, element|
         updated_element_hash = hash.key?(element) ? {element => hash[element] + 1} : {element => 1}