kintsugi 0.7.9 → 0.7.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e84a9556f00f729599cefe60241abf1e60e025dfd3445fe8878990214d12932b
-  data.tar.gz: e719d02da96de57206c02c6846370cf0baf712e9ca79c58e1ce8e958aa6996cb
+  metadata.gz: feebfac564140617fc5d55b773eadb7bc12b90ce0a10c1498827fd445319c36c
+  data.tar.gz: 364efec483aa9be794146d57d22d3ce0093bdeadc29c5cc16bc837bf42147088
 SHA512:
-  metadata.gz: a1629a6c641c5926489bf84ff8e840da1d90f3a4af17745aeed51fd70e9da054dbbdbcf36644b83017d262a327348a8e924dea42e02e6cffa7caa924d4e4f2e4
-  data.tar.gz: 9dccb781f8b52926e7ba1a2fcfbfdeec54c8a2fe6f3581c6fea877f3a8e983ee13019441d73d4cb7aa2b42fd4b96aea727ab18dea352e7b3cf9580233159b5d8
+  metadata.gz: b12c34ac0ba743b080e81cc006cfbea332335493d66f5703bf40bc9ae84e7b2bec7d352d67fd2dcc8f1bd401c75d6d438516ba23e5d0bc6c68c42d1cad270d44
+  data.tar.gz: 012a869ace7be6b2869cb060181d7aebb2ee231c27a811f17b85e9a4b7904fd0046e44aa9cd647db05e77ea4d8775b8ccee7acdb99b9abda0d3ba54c308f8817

data/kintsugi.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "tty-prompt", "~> 0"
-  spec.add_dependency "xcodeproj", ">= 1.19.0", "<= 1.27.0"
+  spec.add_dependency "xcodeproj", ">= 1.26.0", "<= 1.27.0"
 
   spec.add_development_dependency "git", "~> 1.11"
   spec.add_development_dependency "rake", "~> 13.0"

data/lib/kintsugi/apply_change_to_project.rb

@@ -24,6 +24,12 @@ end
 
 module Kintsugi
   class << self
+    # Isas of components whose additions and removals are handled by the main group pipeline
+    # (`apply_group_additions`/`apply_group_removals`). `PBXFileSystemSynchronizedRootGroup` is the
+    # Xcode 16 "buildable folder" object, which lives in the group tree like a group.
+    GROUP_PIPELINE_ISAS =
+      %w[PBXGroup PBXVariantGroup PBXFileSystemSynchronizedRootGroup].freeze
+
     # Applies the change specified by `change` to `project`.
     #
     # @param  [Xcodeproj::Project] project
@@ -45,6 +51,7 @@ module Kintsugi
       @change_source_project = change_source_project
       @ignored_components_group_paths = []
       @created_components_group_paths = []
+      @pending_exception_references = []
 
       # We iterate over the main group and project references first because they might create file
       # or project references that are referenced in other parts.
@@ -65,6 +72,11 @@ module Kintsugi
                                 change["rootObject"].reject { |key|
                                   %w[mainGroup projectReferences].include?(key)
                                 }, "")
+
+      # Exception sets reference targets and build phases that may only be created later in the
+      # change (and groups are linked to their targets only in the rootObject pass above), so their
+      # references are resolved here, once everything exists.
+      resolve_pending_exception_references
     end
 
     private
@@ -107,7 +119,7 @@ module Kintsugi
 
     def apply_group_additions(project, additions, force_create_containing_group: false)
       additions.each do |change, path|
-        next unless %w[PBXGroup PBXVariantGroup].include?(change["isa"])
+        next unless GROUP_PIPELINE_ISAS.include?(change["isa"])
 
         group_type = Module.const_get("Xcodeproj::Project::#{change["isa"]}")
         containing_group = project.group_or_file_at_path(path)
@@ -244,7 +256,8 @@ module Kintsugi
       when Xcodeproj::Project::PBXFileReference
         apply_file_changes(project, [[component_change, containing_group_path]], [],
                            force_create_containing_group: true)
-      when Xcodeproj::Project::PBXGroup
+      when Xcodeproj::Project::PBXGroup,
+           Xcodeproj::Project::PBXFileSystemSynchronizedRootGroup
         apply_group_additions(project, [[component_change, containing_group_path]],
                               force_create_containing_group: true)
       else
@@ -256,14 +269,16 @@ module Kintsugi
 
     def apply_group_removals(project, removals)
       removals.sort_by(&:last).reverse.each do |change, path|
-        next unless %w[PBXGroup PBXVariantGroup].include?(change["isa"])
+        next unless GROUP_PIPELINE_ISAS.include?(change["isa"])
 
         group_path = join_path(path, change["displayName"])
 
         # by now we've deleted all of this group's children in the project, so we need to adapt the
         # change to the expected current state of the group, that is, without any children.
+        # `PBXFileSystemSynchronizedRootGroup` has no `children` attribute, so we must not inject an
+        # empty one, otherwise `remove_component`'s tree hash comparison would never match.
         change_without_children = change.dup
-        change_without_children["children"] = []
+        change_without_children["children"] = [] if change.key?("children")
 
         remove_component(project[group_path], change_without_children)
       end
@@ -291,12 +306,7 @@ module Kintsugi
       if change[:removed].is_a?(Hash)
         remove_component(component, change[:removed])
       elsif change[:removed].is_a?(Array)
-        unless component.nil?
-          (change[:removed]).each do |removed_change|
-            child = child_component_of_object_list(component, removed_change["displayName"])
-            remove_component(child, removed_change)
-          end
-        end
+        remove_children_from_object_list(component, change[:removed]) unless component.nil?
       elsif !change[:removed].nil?
         raise MergeError, "Unsupported removed change type for #{change[:removed]}"
       end
@@ -323,6 +333,22 @@ module Kintsugi
       end
     end
 
+    def remove_children_from_object_list(object_list, removed_changes)
+      removed_changes.each do |removed_change|
+        child = child_component_of_object_list(object_list, removed_change["displayName"])
+        if removed_change["isa"] == "PBXFileSystemSynchronizedRootGroup"
+          # A target references the buildable folder object; unlinking it must detach the reference,
+          # not unconditionally delete the shared object. `ObjectList#delete` is reference-counted:
+          # it removes the object only when this was its last referrer, so a folder still referenced
+          # by the main group or another target survives. (Full deletion of the folder itself is
+          # driven separately by its main group entry, via `apply_group_removals`.)
+          object_list.delete(child) unless child.nil?
+        else
+          remove_component(child, removed_change)
+        end
+      end
+    end
+
     def resolve_nonexistent_component(parent_component, change_path)
       source_project_component = component_at_path(@change_source_project, change_path)
       group_path = group_path_of_group_based_component(source_project_component)
@@ -353,6 +379,10 @@ module Kintsugi
       elsif component.is_a?(Xcodeproj::Project::PBXFileReference) ||
           component.is_a?(Xcodeproj::Project::PBXGroup)
         component.hierarchy_path.delete_prefix("/")
+      elsif component.is_a?(Xcodeproj::Project::PBXFileSystemSynchronizedRootGroup)
+        # A synchronized root group is not a `PBXGroup`, so it has no `hierarchy_path` instance
+        # method; the groupable helper computes the same path from its parent chain.
+        Xcodeproj::Project::Object::GroupableHelper.hierarchy_path(component).delete_prefix("/")
       end
     end
 
@@ -652,6 +682,13 @@ module Kintsugi
         add_file_reference(component, change, change_path)
       when "PBXGroup"
         add_group(component, change, change_path)
+      when "PBXFileSystemSynchronizedRootGroup"
+        add_file_system_synchronized_root_group(component, change, change_path)
+      when "PBXFileSystemSynchronizedBuildFileExceptionSet"
+        add_file_system_synchronized_build_file_exception_set(component, change, change_path)
+      when "PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet"
+        add_file_system_synchronized_group_build_phase_membership_exception_set(component, change,
+                                                                                change_path)
       when "PBXContainerItemProxy"
         add_container_item_proxy(component, change, change_path)
       when "PBXTargetDependency"
@@ -768,6 +805,239 @@ module Kintsugi
       end
     end
 
+    # Known limitation: buildable folders have no stable identity in a project diff (they're
+    # compared by value), so relocating a folder between parent groups while it stays linked to a
+    # target reads as remove-from-A + add-to-B. The old object (and its target link) is removed, and
+    # the new object is created but not re-linked to the target, since the target's own change is
+    # empty. Such a merge can drop the folder's target membership; re-verify after relocating.
+    def add_file_system_synchronized_root_group(containing_component, change, change_path)
+      case containing_component
+      when Xcodeproj::Project::PBXNativeTarget
+        # The group was already created in the group tree by the main group pass. Resolve it by its
+        # position in the tree so we reuse the exact same object, even when another buildable folder
+        # shares its name in a different parent group.
+        group = resolve_file_system_synchronized_root_group(containing_component, change)
+        if group.nil?
+          raise MergeError, "No file system synchronized root group matching #{change} was " \
+                            "found in the group tree. Change path: #{change_path}"
+        end
+
+        # Dedup by object identity, not display name: one target can legitimately link several
+        # same-named folders from different parent groups, each a distinct object.
+        already_linked = containing_component.file_system_synchronized_groups.any? do |linked|
+          linked.uuid == group.uuid
+        end
+        return if !Settings.allow_duplicates && already_linked
+
+        containing_component.file_system_synchronized_groups << group
+      else
+        raise MergeError, "Trying to add file system synchronized root group to an unsupported " \
+                          "component type #{containing_component.isa}. Change is: #{change}"
+      end
+    end
+
+    def resolve_file_system_synchronized_root_group(target, change)
+      candidates = target.project.objects.select do |object|
+        object.isa == "PBXFileSystemSynchronizedRootGroup" &&
+          object.display_name == change["displayName"]
+      end
+      return candidates.first if candidates.length <= 1
+
+      # More than one buildable folder shares this name (in different parent groups). Match against
+      # the folders the change's target links in the source project, comparing hierarchy paths as
+      # strings. A folder's own `path`/`display_name` may itself contain "/", so this must not be
+      # split into segments, so path-walking helpers like `group_or_file_at_path` can't be used.
+      source_hierarchies = source_synchronized_root_group_hierarchies(target, change)
+      source_matching = candidates.select do |candidate|
+        source_hierarchies.include?(synchronized_root_group_hierarchy_path(candidate))
+      end
+      return candidates.first if source_matching.empty?
+
+      # Prefer a folder not already linked to this target, so a target linking two same-named
+      # folders resolves each addition to a distinct object rather than dropping the second.
+      linked_uuids = target.file_system_synchronized_groups.map(&:uuid)
+      source_matching.find { |candidate| !linked_uuids.include?(candidate.uuid) } ||
+        source_matching.first
+    end
+
+    # Hierarchy paths (in source order) of the buildable folders the change's target links that
+    # match `change`. A target may link several same-named folders from different parents; their
+    # identity lets us map each addition to the right destination object.
+    def source_synchronized_root_group_hierarchies(target, change)
+      source_target = find_target(@change_source_project, target.display_name)
+      (source_target&.file_system_synchronized_groups || [])
+        .select { |group| group.to_tree_hash == change }
+        .map { |group| synchronized_root_group_hierarchy_path(group) }
+        .compact
+    end
+
+    # Groupable helper raises a `RuntimeError` consistency error (rather than returning nil) for an
+    # object with no parent group; treat that as "no hierarchy" so a stray unparented candidate
+    # can't abort the merge. Narrowly rescued so unrelated errors still surface.
+    def synchronized_root_group_hierarchy_path(group)
+      Xcodeproj::Project::Object::GroupableHelper.hierarchy_path(group)
+    rescue RuntimeError
+      nil
+    end
+
+    def add_file_system_synchronized_build_file_exception_set(containing_component, change,
+                                                              change_path)
+      unless containing_component.is_a?(Xcodeproj::Project::PBXFileSystemSynchronizedRootGroup)
+        raise MergeError, "Trying to add file system synchronized build file exception set to an " \
+                          "unsupported component type #{containing_component.isa}. Change is: " \
+                          "#{change}"
+      end
+      return if exception_set_already_exists?(containing_component, change)
+
+      exception_set = containing_component.project.new(
+        Xcodeproj::Project::PBXFileSystemSynchronizedBuildFileExceptionSet
+      )
+      containing_component.exceptions << exception_set
+      add_attributes_to_component(exception_set, change, change_path, ignore_keys: ["target"])
+      resolve_or_defer_exception_reference(exception_set, :target, change["target"])
+    end
+
+    def add_file_system_synchronized_group_build_phase_membership_exception_set(
+      containing_component, change, change_path
+    )
+      unless containing_component.is_a?(Xcodeproj::Project::PBXFileSystemSynchronizedRootGroup)
+        raise MergeError, "Trying to add file system synchronized group build phase membership " \
+                          "exception set to an unsupported component type " \
+                          "#{containing_component.isa}. Change is: #{change}"
+      end
+      return if exception_set_already_exists?(containing_component, change)
+
+      exception_set = containing_component.project.new(
+        Xcodeproj::Project::PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet
+      )
+      containing_component.exceptions << exception_set
+      add_attributes_to_component(exception_set, change, change_path, ignore_keys: ["buildPhase"])
+      resolve_or_defer_exception_reference(exception_set, :build_phase, change["buildPhase"])
+    end
+
+    # `true` if an equivalent exception set already exists on `group`. This is intentionally NOT
+    # gated on `Settings.allow_duplicates`: a synchronized root group is referenced from both the
+    # main group and its target(s), so the same exception addition is visited through several graph
+    # paths, and two exception sets identical in target/build phase + membership are meaningless.
+    def exception_set_already_exists?(group, change)
+      group.exceptions.any? { |exception_set| exception_set_matches_change?(exception_set, change) }
+    end
+
+    def exception_set_matches_change?(exception_set, change)
+      signature = exception_set.to_tree_hash
+      pending = @pending_exception_references.find { |set, _, _| set.equal?(exception_set) }
+      unless pending.nil?
+        _, kind, reference = pending
+        signature = signature.merge(exception_reference_key(kind) => reference)
+      end
+      # `displayName` is derived from the (possibly still-unresolved) reference and the folder name,
+      # so it carries no information the reference key and simple attributes don't already carry;
+      # excluding it avoids a spurious mismatch when the reference is still pending (nil).
+      signature.reject { |key, _| key == "displayName" } ==
+        change.reject { |key, _| key == "displayName" }
+    end
+
+    def exception_reference_key(kind)
+      kind == :target ? "target" : "buildPhase"
+    end
+
+    # Resolves the target/build phase an exception set references. The target may be created, and
+    # the group linked to its targets, only later, so unresolvable references are recorded and
+    # retried by `resolve_pending_exception_references` after the whole change is applied. Build
+    # phase resolution always defers: it needs the group already linked to a target.
+    def resolve_or_defer_exception_reference(exception_set, kind, reference)
+      # Only the target reference is resolved eagerly (it just needs the target to exist). The build
+      # phase reference is always deferred, because the phase it points to might itself be created
+      # later in the same change (e.g. a target and its build phases added together).
+      if kind == :target
+        resolved = resolve_exception_reference(exception_set, kind, reference)
+        unless resolved.nil?
+          assign_exception_reference(exception_set, kind, resolved)
+          return
+        end
+      end
+
+      @pending_exception_references << [exception_set, kind, reference]
+    end
+
+    def resolve_pending_exception_references
+      @pending_exception_references.each do |exception_set, kind, reference|
+        resolved = resolve_exception_reference(exception_set, kind, reference)
+        if resolved.nil?
+          puts "Warning: Couldn't resolve #{kind} reference #{reference.inspect} for exception " \
+               "set '#{exception_set.display_name}'."
+          next
+        end
+
+        assign_exception_reference(exception_set, kind, resolved)
+      end
+      @pending_exception_references = []
+    end
+
+    def resolve_exception_reference(exception_set, kind, reference)
+      case kind
+      when :target
+        find_target(exception_set.project, reference)
+      when :build_phase
+        find_synchronized_group_build_phase(exception_set, reference)
+      end
+    end
+
+    def assign_exception_reference(exception_set, kind, resolved)
+      case kind
+      when :target then exception_set.target = resolved
+      when :build_phase then exception_set.build_phase = resolved
+      end
+    end
+
+    # Finds the build phase an exception set references. The reference carries its owning target,
+    # so we resolve that target by name (unique) then its build phase by name. This disambiguates
+    # same-named phases (e.g. "Sources") when the group is shared by several targets. Returns nil
+    # when the target isn't created yet, so the caller can defer.
+    def find_synchronized_group_build_phase(exception_set, reference)
+      project = exception_set.project
+      target_name = reference.is_a?(Hash) ? reference["target"] : nil
+      phase_name = reference.is_a?(Hash) ? reference["name"] : reference
+
+      candidate_targets =
+        if target_name.nil?
+          synchronized_group_referencing_targets(exception_set)
+        else
+          target = find_target(project, target_name)
+          return nil if target.nil?
+
+          [target]
+        end
+
+      matching_build_phases = candidate_targets.flat_map(&:build_phases).select do |build_phase|
+        build_phase.display_name == phase_name
+      end
+      if matching_build_phases.length > 1
+        puts "Debug: Multiple build phases named '#{phase_name}'. Using the first one."
+      end
+      matching_build_phases.first
+    end
+
+    # The targets that reference the exception set's owning synchronized root group. Used as a
+    # fallback when a build phase reference doesn't carry its owning target. The groupable helper
+    # raises `RuntimeError` for an unparented set (e.g. its group was removed earlier in the same
+    # change); fall back to all native targets rather than aborting the merge.
+    def synchronized_group_referencing_targets(exception_set)
+      project = exception_set.project
+      group =
+        begin
+          Xcodeproj::Project::Object::GroupableHelper.parent(exception_set)
+        rescue RuntimeError
+          nil
+        end
+      return project.native_targets if group.nil?
+
+      referencing_targets = project.native_targets.select do |target|
+        target.file_system_synchronized_groups.any? { |linked| linked.uuid == group.uuid }
+      end
+      referencing_targets.empty? ? project.native_targets : referencing_targets
+    end
+
     def add_build_rule(target, change, change_path)
       build_rule = target.project.new(Xcodeproj::Project::PBXBuildRule)
       target.build_rules << build_rule

data/lib/kintsugi/version.rb

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

data/lib/kintsugi/xcodeproj_extensions.rb

@@ -126,6 +126,69 @@ module Xcodeproj
         end
       end
 
+      # Modifies `PBXFileSystemSynchronizedBuildFileExceptionSet`'s `to_tree_hash` to serialize its
+      # `target` as a reference (by display name) instead of recursing into it. Without this, the
+      # target expands into a hash that contains the synchronized root group owning this exception
+      # set, which owns this exception set, causing infinite recursion.
+      class PBXFileSystemSynchronizedBuildFileExceptionSet
+        # xcodeproj 1.27.0's `display_name` interpolates `#{target.name}`; guard against a nil target
+        # (which occurs transiently while the target reference is resolved) to avoid `NoMethodError`
+        # during serialization or tree hashing. `GroupableHelper.parent` raises (and re-interpolates
+        # `display_name`, recursing to a stack overflow) when the set has no referrers, so only call
+        # it when a parent actually exists.
+        def display_name
+          folder_name = referrers.empty? ? nil : GroupableHelper.parent(self)&.display_name
+          "Exceptions for \"#{folder_name}\" folder in \"#{target&.name}\" target"
+        end
+
+        def to_tree_hash
+          hash = { 'displayName' => display_name, 'isa' => isa }
+          self.class.simple_attributes.each do |attribute|
+            value = attribute.get_value(self)
+            hash[attribute.plist_name] = value unless value.nil?
+          end
+          hash['target'] = target.display_name if target
+          hash
+        end
+      end
+
+      # Same fix as `PBXFileSystemSynchronizedBuildFileExceptionSet`, for the build phase membership
+      # variant, whose recursing reference is `build_phase`.
+      class PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet
+        # xcodeproj 1.27.0's `display_name` calls `build_phase.name`, which build phases don't
+        # implement, raising `NoMethodError` on any serialization or tree hash of this object. Use
+        # the build phase's `display_name` (e.g. "Sources") instead. Also guard the parent lookup,
+        # which otherwise raises and recurses to a stack overflow when the set has no referrers.
+        def display_name
+          folder_name = referrers.empty? ? nil : GroupableHelper.parent(self)&.display_name
+          "Exceptions for \"#{folder_name}\" folder in \"#{build_phase&.display_name}\" build phase"
+        end
+
+        def to_tree_hash
+          hash = { 'displayName' => display_name, 'isa' => isa }
+          self.class.simple_attributes.each do |attribute|
+            value = attribute.get_value(self)
+            hash[attribute.plist_name] = value unless value.nil?
+          end
+          hash['buildPhase'] = build_phase_reference if build_phase
+          hash
+        end
+
+        # Serializes `build_phase` as a reference that also carries its owning target, so it can be
+        # resolved unambiguously even when the owning group is shared by multiple targets that each
+        # have a build phase with the same name (e.g. "Sources").
+        def build_phase_reference
+          reference = { 'name' => build_phase.display_name }
+          # Match by UUID: xcodeproj compares build phases by value, so `include?` would match a
+          # same-named empty phase on an unrelated target.
+          owning_target = build_phase.project.native_targets.find do |target|
+            target.build_phases.any? { |phase| phase.uuid == build_phase.uuid }
+          end
+          reference['target'] = owning_target.display_name unless owning_target.nil?
+          reference
+        end
+      end
+
       # By default, for this type, the `display_name` is used when calling `ascii_plist_annotation` (which is used
       # to serialize the project to disk). In the case where the `display_name` contains a "plugin:" prefix, which
       # means that the package is a plugin, the prefix is ommitted so just the package name is used.