cocoapods-spm 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e61ad227d509165fab0c8f3e832aa06d05524fa7c2cbfd4d7cc8f393252fc60f
-  data.tar.gz: 66f6bf9e254c7a99edc55f304fcf34ea60867fbbb9f138a6473eb200b6fa9f32
+  metadata.gz: 922b55ffd54350ec1e1be78c273b0078acfcdf7bca7f29c87281367507ffcf13
+  data.tar.gz: 9e0d2e7202e2d5486d92e039aae84b0caeb690b7c6e8c73a3b57110177ec8b14
 SHA512:
-  metadata.gz: e48c19f9a2ed81601a69cca75ceda44b9353bf76f996458dc3398dad8e7b0ed2fa6fff8ce03cad91122cdcf6f7603a5cc1070b9944dfab98a0d1ff5081f82740
-  data.tar.gz: d26d1674591412b761b92e51154142b5e76f7515464b0e462d5b26a06caeadd3162df96308d2ff34b1cb3d27c554eb33715d2248b7e66e2e58e1d56ceb4b1214
+  metadata.gz: c02a69fa12d098b6103d3eccb6dbf5b19ba50473b8c23913b6e5f17c9fd067c7fac3539c9a84264ba9a614c20771c4f641c0640a6c63a862aa2c5d7fc6e35154
+  data.tar.gz: 5bafa557cfb91f192eaf0923e5e86503a490442104f102abd69a5b1e458395fcb1980394e0d4a65a567dd80f93bff1034ea118f37e09d2cf038dd8e83eaa4597

data/lib/cocoapods-spm/config/spm.rb

@@ -16,7 +16,7 @@ module Pod
       def initialize
         @dsl_config = {
           :dont_prebuild_macros => false,
-          :dont_prebuild_macros_if_exist => true
+          :dont_prebuild_macros_if_exist => true,
         }
         @cli_config = {}
       end
@@ -77,6 +77,10 @@ module Pod
         pkg_umbrella_dir / ".build" / "checkouts"
       end
 
+      def pkg_artifacts_dir
+        pkg_umbrella_dir / ".build" / "artifacts"
+      end
+
       def pkg_metadata_dir
         @pkg_metadata_dir ||= prepare_dir(pkg_root_dir / "metadata")
       end

data/lib/cocoapods-spm/def/podfile.rb

@@ -1,10 +1,11 @@
 require "cocoapods-spm/config"
+require "cocoapods-spm/helpers/patch"
 
 module Pod
   class Podfile
+    include Mixin::PatchingBehavior
     attr_accessor :spm_resolver
 
-    alias origin_pod pod
     def config_cocoapods_spm(options)
       SPM::Config.instance.dsl_config = options
     end
@@ -13,7 +14,7 @@ module Pod
       @macro_pods ||= {}
     end
 
-    def pod(name = nil, *requirements)
+    patch_method :pod do |name = nil, *requirements|
       macro = requirements[0].delete(:macro) if requirements.first.is_a?(Hash)
       macro ||= {}
       unless macro.empty?
@@ -27,6 +28,10 @@ module Pod
       current_target_definition.store_spm_pkg(name, options)
     end
 
+    def spm_pkgs
+      spm_pkgs_by_aggregate_target.values.flatten.uniq(&:name)
+    end
+
     def spm_pkgs_for(target)
       spm_pkgs_by_aggregate_target[target.to_s]
     end

data/lib/cocoapods-spm/def/spm_dependency.rb

@@ -15,8 +15,10 @@ module Pod
       end
 
       def inspect
-        "#<#{self.class} name=#{name} product=#{product} pkg=#{pkg}>"
+        "#<#{self.class} #{name}/#{product} pkg=#{pkg}>"
       end
+
+      alias to_s inspect
     end
   end
 end

data/lib/cocoapods-spm/def/spm_package.rb

@@ -42,9 +42,11 @@ module Pod
       end
 
       def inspect
-        "#<#{self.class} name=#{name}>"
+        "#<#{self.class} #{name}>"
       end
 
+      alias to_s inspect
+
       def local?
         @relative_path != nil
       end

data/lib/cocoapods-spm/helpers/patch.rb

@@ -0,0 +1,14 @@
+module Mixin
+  module PatchingBehavior
+    def patch_method(method_name, &block)
+      raw_method_name = "origin_#{method_name}"
+      alias_method raw_method_name, method_name
+      define_method(method_name, &block)
+      private raw_method_name
+    end
+
+    def self.included(base)
+      base.extend(self)
+    end
+  end
+end

data/lib/cocoapods-spm/hooks/helpers/update_script.rb

@@ -0,0 +1,61 @@
+require "cocoapods-spm/hooks/base"
+
+module Pod
+  module SPM
+    module UpdateScript
+      module Mixin
+        def update_script(options = {})
+          script_name = options[:name]
+          content_by_target = options[:content_by_target]
+
+          aggregate_targets.each do |target|
+            lines, input_paths, output_paths = content_by_target.call(target)
+            next if input_paths.empty?
+
+            update_script_content(
+              path: target.send("#{script_name}_path"),
+              before: options[:insert_before],
+              insert: lines.join("\n")
+            )
+
+            # Update input/output files
+            user_build_configurations.each_key do |config|
+              append_contents = lambda do |method_name, contents|
+                target.send(method_name, config).open("a") do |f|
+                  contents.each { |p| f << "\n" << p }
+                end
+              end
+              append_contents.call("#{script_name}_input_files_path", input_paths)
+              append_contents.call("#{script_name}_output_files_path", output_paths)
+            end
+          end
+        end
+
+        private
+
+        def update_script_content(options = {})
+          match_content = options[:before]
+          insert_content = <<~SH
+            # --------------------------------------------------------
+            # Added by `cocoapods-spm`
+            # --------------------------------------------------------
+            #{options[:insert]}
+            # --------------------------------------------------------
+          SH
+          options[:path].open("r+") do |f|
+            content = f.read
+            offset = content.index(match_content) unless match_content.nil?
+            if offset.nil?
+              f << "\n" << insert_content
+            else
+              f.seek(offset)
+              after_content = f.read
+              f.seek(offset)
+              f << "\n" << insert_content << after_content
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/hooks/post_integrate/5.update_settings.rb

@@ -1,5 +1,5 @@
 require "cocoapods-spm/hooks/base"
-require "cocoapods-spm/metadata"
+require "cocoapods-spm/macro/metadata"
 
 module Pod
   module SPM
@@ -18,7 +18,7 @@ module Pod
           @macro_plugin_flag_by_config ||= begin
             hash = user_build_configurations.keys.to_h do |config|
               flags = macro_pods.keys.map do |name|
-                metadata = Metadata.for_pod(name)
+                metadata = MacroMetadata.for_pod(name)
                 impl_module_name = metadata.macro_impl_name
                 plugin_executable_path =
                   "${PODS_ROOT}/../.spm.pods/#{name}/.prebuilt/#{config.to_s.downcase}/" \
@@ -47,7 +47,7 @@ module Pod
             update_targets: lambda do |target, _, _|
               {
                 "OTHER_SWIFT_FLAGS" => modulemap_args_for_target(target, prefix: "-Xcc"),
-                "OTHER_CFLAGS" => modulemap_args_for_target(target)
+                "OTHER_CFLAGS" => modulemap_args_for_target(target),
               }
             end
           )
@@ -62,7 +62,7 @@ module Pod
               {
                 "OTHER_LDFLAGS" => linker_flags_for(target),
                 "FRAMEWORK_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}/PackageFrameworks\"",
-                "LIBRARY_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}\""
+                "LIBRARY_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}\"",
               }
             end
           )
@@ -87,9 +87,8 @@ module Pod
         def modulemap_args_for_target(target, prefix: nil)
           @spm_resolver
             .result
-            .spm_products_for(target)
-            .reject { |p| p.headers_path.nil? }
-            .map { |p| "-fmodule-map-file=\"${GENERATED_MODULEMAP_DIR}/#{p.name}.modulemap\"" }
+            .spm_targets_for(target)
+            .filter_map(&:clang_modulemap_arg)
             .map { |v| prefix.nil? ? v : "#{prefix} #{v}" }
             .join(" ")
         end

data/lib/cocoapods-spm/hooks/post_integrate/6.update_embed_frameworks_script.rb

@@ -1,52 +1,30 @@
 require "cocoapods-spm/hooks/base"
+require "cocoapods-spm/hooks/helpers/update_script"
 
 module Pod
   module SPM
     class Hook
       class UpdateEmbedFrameworksScript < Hook
-        def run
-          aggregate_targets.each do |target|
-            next if framework_paths_for(target).empty?
+        include UpdateScript::Mixin
 
-            update_embed_frameworks_script(target)
-            user_build_configurations.each_key do |config|
-              update_embed_frameworks_script_files_path(target, config)
+        def run
+          update_script(
+            name: :embed_frameworks_script,
+            content_by_target: lambda do |target|
+              input_paths = framework_paths_for(target)
+              output_paths = input_paths.map do |p|
+                "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/#{File.basename(p)}"
+              end
+              lines = input_paths.map { |p| "install_framework \"#{p}\"" }
+              [lines, input_paths, output_paths]
             end
-          end
+          )
         end
 
         private
 
         def framework_paths_for(target)
-          @spm_resolver.result.spm_products_for(target).select(&:dynamic?).map do |p|
-            "${BUILT_PRODUCTS_DIR}/PackageFrameworks/#{p.name}.framework"
-          end
-        end
-
-        def update_embed_frameworks_script(target)
-          lines = framework_paths_for(target).map { |p| "install_framework \"#{p}\"" }
-          target.embed_frameworks_script_path.open("a") do |f|
-            f << "\n" << <<~SH
-              # --------------------------------------------------------
-              # Added by `cocoapods-spm` to embed SPM package frameworks
-              # --------------------------------------------------------
-              #{lines.join("\n")}
-              # --------------------------------------------------------
-            SH
-          end
-        end
-
-        def update_embed_frameworks_script_files_path(target, config)
-          input_paths = framework_paths_for(target)
-          output_paths = input_paths.map do |p|
-            "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/#{File.basename(p)}"
-          end
-          target.embed_frameworks_script_input_files_path(config).open("a") do |f|
-            input_paths.each { |p| f << "\n" << p }
-          end
-          target.embed_frameworks_script_output_files_path(config).open("a") do |f|
-            output_paths.each { |p| f << "\n" << p }
-          end
+          @spm_resolver.result.spm_targets_for(target).select(&:dynamic?).map(&:built_framework_path).uniq
         end
       end
     end

data/lib/cocoapods-spm/hooks/post_integrate/7.update_copy_resources_script.rb

@@ -0,0 +1,33 @@
+require "cocoapods-spm/hooks/base"
+require "cocoapods-spm/hooks/helpers/update_script"
+
+module Pod
+  module SPM
+    class Hook
+      class UpdateCopyResourcesScript < Hook
+        include UpdateScript::Mixin
+
+        def run
+          update_script(
+            name: :copy_resources_script,
+            insert_before: Generator::CopyResourcesScript::RSYNC_CALL,
+            content_by_target: lambda do |target|
+              input_paths = resource_paths_for(target)
+              output_paths = input_paths.map do |p|
+                "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/#{File.basename(p)}"
+              end
+              lines = input_paths.map { |p| "install_resource \"#{p}\"" }
+              [lines, input_paths, output_paths]
+            end
+          )
+        end
+
+        private
+
+        def resource_paths_for(target)
+          @spm_resolver.result.spm_targets_for(target).flat_map(&:resources).map(&:built_resource_path).uniq
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/macro/metadata.rb

@@ -0,0 +1,11 @@
+require "cocoapods-spm/swift/package/description"
+
+module Pod
+  module SPM
+    class MacroMetadata < Swift::PackageDescription
+      def self.for_pod(name)
+        from_file(Config.instance.macro_root_dir / name / "metadata.json")
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/macro/prebuilder.rb

@@ -1,4 +1,4 @@
-require "cocoapods-spm/metadata"
+require "cocoapods-spm/macro/metadata"
 
 module Pod
   module SPM
@@ -39,7 +39,7 @@ module Pod
 
         raw = Dir.chdir(macro_downloaded_dir) { `swift package dump-package` }
         metadata_path.write(raw)
-        @metadata = Metadata.from_s(raw)
+        @metadata = MacroMetadata.from_s(raw)
       end
 
       def prebuild_macro_impl

data/lib/cocoapods-spm/main.rb

@@ -1,5 +1,4 @@
 require "cocoapods-spm/config"
-require "cocoapods-spm/metadata"
 require "cocoapods-spm/executables"
 require "cocoapods-spm/def/target_definition"
 require "cocoapods-spm/def/podfile"

data/lib/cocoapods-spm/patch/aggregate_target.rb

@@ -1,13 +1,25 @@
+require "cocoapods-spm/helpers/patch"
+
 module Pod
   class AggregateTarget
-    alias origin_includes_frameworks? includes_frameworks?
+    include Mixin::PatchingBehavior
+
+    private
 
-    def includes_frameworks?
+    patch_method :includes_frameworks? do
       origin_includes_frameworks? || includes_dynamic_spm_dependencies?
     end
 
+    patch_method :includes_resources? do
+      origin_includes_resources? || includes_spm_resouces?
+    end
+
     def includes_dynamic_spm_dependencies?
-      podfile.spm_resolver.result.spm_products_for(self).any?(&:dynamic?)
+      podfile.spm_resolver.result.spm_targets_for(self).any?(&:dynamic?)
+    end
+
+    def includes_spm_resouces?
+      !podfile.spm_resolver.result.spm_targets_for(self).all? { |t| t.resources.empty? }
     end
   end
 end

data/lib/cocoapods-spm/patch/installer.rb

@@ -1,19 +1,19 @@
+require "cocoapods-spm/helpers/patch"
 require "cocoapods-spm/resolver"
 require "cocoapods-spm/macro/pod_installer"
 require "cocoapods-spm/hooks/base"
 
 module Pod
   class Installer
+    include Mixin::PatchingBehavior
     include SPM::Config::Mixin
 
-    alias origin_resolve_dependencies resolve_dependencies
-    def resolve_dependencies
+    patch_method :resolve_dependencies do
       origin_resolve_dependencies
       resolve_spm_dependencies
     end
 
-    alias origin_create_pod_installer create_pod_installer
-    def create_pod_installer(pod_name)
+    patch_method :create_pod_installer do |pod_name|
       if macro_pods.include?(pod_name)
         macro_pod_installer = MacroPodInstaller.new(
           sandbox,
@@ -28,8 +28,7 @@ module Pod
       end
     end
 
-    alias origin_integrate integrate
-    def integrate
+    patch_method :integrate do
       run_spm_pre_integrate_hooks
       origin_integrate
       run_spm_post_integrate_hooks
@@ -40,7 +39,7 @@ module Pod
     def hook_options
       {
         :spm_resolver => @spm_resolver,
-        :analysis_result => @analysis_result
+        :analysis_result => @analysis_result,
       }
     end
 

data/lib/cocoapods-spm/resolver/recursive_target_resolver.rb

@@ -0,0 +1,37 @@
+module Pod
+  module SPM
+    class Resolver
+      class RecursiveTargetResolver
+        require "cocoapods-spm/swift/package/project_packages"
+
+        include Config::Mixin
+
+        def initialize(podfile, result)
+          @podfile = podfile
+          @result = result
+        end
+
+        def resolve
+          resolve_recursive_targets
+        end
+
+        private
+
+        def project_pkgs
+          @result.project_pkgs ||= Swift::ProjectPackages.new(
+            src_dir: spm_config.pkg_checkouts_dir,
+            write_json_to_dir: spm_config.pkg_metadata_dir
+          )
+        end
+
+        def resolve_recursive_targets
+          @result.spm_dependencies_by_target.values.flatten.uniq(&:product).each do |dep|
+            next if dep.pkg.use_default_xcode_linking?
+
+            project_pkgs.resolve_recursive_targets_of(dep.pkg.name, dep.product)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/resolver/result.rb

@@ -2,48 +2,52 @@ module Pod
   module SPM
     class Resolver
       class Result
+        include Config::Mixin
+
+        ATTRS = {
+          :spm_pkgs => [],
+          :spm_dependencies_by_target => {},
+          :project_pkgs => nil,
+        }.freeze
+
         class WritableResult < Result
-          attr_accessor :spm_pkgs, :spm_dependencies_by_target, :spm_products, :metadata_cache
+          ATTRS.each_key { |x| attr_accessor x }
 
           def to_read_only
-            Result.new(
-              spm_pkgs: spm_pkgs,
-              spm_dependencies_by_target: spm_dependencies_by_target,
-              spm_products: spm_products,
-              metadata_cache: metadata_cache
-            )
+            Result.new(ATTRS.to_h { |x| [x, instance_variable_get("@#{x}")] })
           end
         end
 
-        attr_reader :spm_pkgs, :spm_dependencies_by_target, :spm_products, :metadata_cache
+        ATTRS.each_key { |x| attr_reader x }
 
         def initialize(options = {})
-          @spm_pkgs = options[:spm_pkgs] || []
-          @spm_dependencies_by_target = options[:spm_dependencies_by_target] || {}
-          @spm_products = options[:spm_products] || {}
-          @metadata_cache = options[:metadata_cache] || {}
+          ATTRS.each do |k, v|
+            instance_variable_set("@#{k}", options[k] || v)
+          end
         end
 
-        def metadata_of(name)
-          return @metadata_cache[name] if @metadata_cache.key?(name)
-
-          raise Informative, "Metadata of `#{name}` does not exist"
+        def spm_pkgs_for(target)
+          spm_dependencies_for(target).map(&:pkg).uniq(&:name)
         end
 
         def spm_dependencies_for(target)
           @spm_dependencies_by_target[target.to_s].to_a
         end
 
-        def spm_products_for(target)
-          spm_dependencies_for(target).flat_map { |d| @spm_products[d.product].to_a }.uniq(&:name)
+        def spm_targets_for(target, exclude_default_xcode_linking: true)
+          targets = spm_dependencies_for(target).flat_map do |d|
+            project_pkgs.resolve_recursive_targets_of(d.pkg.name, d.product)
+          end.uniq(&:name)
+          return targets.reject(&:use_default_xcode_linking?) if exclude_default_xcode_linking
+
+          targets
         end
 
         def linker_flags_for(target)
-          flags = spm_dependencies_for(target).flat_map { |d| d.pkg.linker_flags }
-          flags += spm_products_for(target).map do |p|
-            p.linked_as_framework? ? "-framework \"#{p.name}\"" : "-l\"#{p.name}.o\""
-          end
-          flags.uniq
+          (
+            spm_targets_for(target).flat_map(&:linker_flags) +
+            spm_pkgs_for(target).flat_map(&:linker_flags)
+          ).uniq
         end
       end
     end

data/lib/cocoapods-spm/resolver.rb

@@ -6,20 +6,22 @@ module Pod
     class Resolver
       require "cocoapods-spm/resolver/result"
       require "cocoapods-spm/resolver/target_dep_resolver"
-      require "cocoapods-spm/resolver/product_dep_resolver"
+      require "cocoapods-spm/resolver/recursive_target_resolver"
 
       def initialize(podfile, aggregate_targets)
         @_result = Result::WritableResult.new
         @podfile = podfile
         @aggregate_targets = aggregate_targets
         @umbrella_pkg = nil
-        @target_dep_resolver = TargetDependencyResolver.new(podfile, aggregate_targets, @_result)
-        @product_dep_resolver = ProductDependencyResolver.new(podfile, @_result)
+        @resolvers = [
+          TargetDependencyResolver.new(podfile, aggregate_targets, @_result),
+          RecursiveTargetResolver.new(podfile, @_result),
+        ]
       end
 
       def resolve
         generate_umbrella_pkg
-        resolvers.each(&:resolve)
+        @resolvers.each(&:resolve)
         validate!
       end
 
@@ -29,10 +31,6 @@ module Pod
 
       private
 
-      def resolvers
-        [@target_dep_resolver, @product_dep_resolver]
-      end
-
       def generate_umbrella_pkg
         @umbrella_pkg = Pod::SPM::UmbrellaPackage.new(@podfile).prepare
       end

data/lib/cocoapods-spm/swift/package/base.rb

@@ -0,0 +1,54 @@
+require "json"
+
+module Pod
+  module Swift
+    class PackageDescriptionBaseObject
+      attr_reader :raw, :parent
+
+      def initialize(raw, parent: nil)
+        @raw = raw
+        @parent = parent
+      end
+
+      def root
+        @root ||= begin
+          node = self
+          node = node.parent until node.parent.nil?
+          node
+        end
+      end
+
+      def pkg_name
+        root.name
+      end
+
+      def self.from_s(str)
+        new(JSON.parse(str))
+      end
+
+      def self.from_file(path)
+        from_s(File.read(path))
+      end
+
+      def inspect
+        "#<#{self.class} #{name}>"
+      end
+
+      alias to_s inspect
+
+      def [](key)
+        raw[key]
+      end
+
+      def name
+        raw["name"]
+      end
+
+      def dup_with_attrs(options = {})
+        copy = dup
+        options.each { |key, value| copy.instance_variable_set("@#{key}", value) }
+        copy
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/swift/package/description.rb

@@ -0,0 +1,56 @@
+require "cocoapods-spm/swift/package/base"
+
+module Pod
+  module Swift
+    class PackageDescription < PackageDescriptionBaseObject
+      include SPM::Config::Mixin
+      autoload :Target, "cocoapods-spm/swift/package/target"
+      autoload :Product, "cocoapods-spm/swift/package/product"
+
+      def src_dir
+        @src_dir ||= begin
+          path = raw.fetch("packageKind", {}).fetch("root", [])[0]
+          Pathname.new(path) unless path.nil?
+        end
+      end
+
+      def artifacts_dir
+        spm_config.pkg_artifacts_dir / slug
+      end
+
+      def slug
+        src_dir.nil? ? name : src_dir.basename.to_s
+      end
+
+      def targets
+        @targets ||= raw.fetch("targets", []).flat_map { |h| Target.new(h, parent: self) }
+      end
+
+      def products
+        @products ||= raw.fetch("products", []).flat_map { |h| Product.new(h, parent: nil) }
+      end
+
+      def targets_of_product(name)
+        matched_products = products.select { |p| p.name == name }
+        dynamic = matched_products.any?(&:dynamic?)
+        matched_products
+          .flat_map do |p|
+            targets.select { |t| p.target_names.include?(t.name) }.map do |t|
+              t.dup_with_attrs(dynamic: dynamic, product_name: name)
+            end
+          end
+      end
+
+      def macro_impl_name
+        targets.find(&:macro?)&.name
+      end
+
+      def use_default_xcode_linking?
+        return @use_default_xcode_linking unless @use_default_xcode_linking.nil?
+
+        pkg = pod_config.podfile.spm_pkgs.find { |t| t.name == name }
+        @use_default_xcode_linking = pkg&.use_default_xcode_linking?
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/swift/package/product.rb

@@ -0,0 +1,17 @@
+require "cocoapods-spm/swift/package/base"
+
+module Pod
+  module Swift
+    class PackageDescription
+      class Product < PackageDescriptionBaseObject
+        def dynamic?
+          @dynamic ||= raw.fetch("type", {}).fetch("library", []).include?("dynamic")
+        end
+
+        def target_names
+          raw["targets"]
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/swift/package/project_packages.rb

@@ -0,0 +1,56 @@
+require "cocoapods-spm/swift/package/description"
+
+module Pod
+  module Swift
+    class ProjectPackages
+      def initialize(options = {})
+        @src_dir = options[:src_dir]
+        raise Informative, "src_dir must not be nil" if @src_dir.nil?
+
+        @json_dir = options[:write_json_to_dir]
+        @pkg_desc_cache = {}
+        load
+      end
+
+      def resolve_recursive_targets_of(pkg_name, product_name)
+        @recursive_targets_cache ||= {}
+        return @recursive_targets_cache[product_name] if @recursive_targets_cache.key(product_name)
+
+        res = []
+        to_visit = pkg_desc_of(pkg_name).targets_of_product(product_name)
+        until to_visit.empty?
+          target = to_visit.pop
+          res << target
+          to_visit += target.resolve_dependencies(@pkg_desc_cache)
+        end
+        @recursive_targets_cache[product_name] = res.uniq(&:name)
+      end
+
+      def pkg_desc_of(name)
+        return @pkg_desc_cache[name] if @pkg_desc_cache.key?(name)
+
+        raise Informative, "Package description of `#{name}` does not exist!"
+      end
+
+      private
+
+      def load
+        @src_dir.glob("*").each do |dir|
+          next if dir.glob("Package*.swift").empty?
+
+          raw = Dir.chdir(dir) { `swift package dump-package` }
+          pkg_desc = PackageDescription.from_s(raw)
+          write_data = lambda do |name|
+            @pkg_desc_cache[name] = pkg_desc
+            (@json_dir / "#{name}.json").write(raw) unless @json_dir.nil?
+          end
+
+          pkg_name = pkg_desc.name
+          pkg_slug = dir.basename.to_s
+          write_data.call(pkg_name)
+          write_data.call(pkg_slug) unless pkg_name == pkg_slug
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/swift/package/resources.rb

@@ -0,0 +1,17 @@
+require "cocoapods-spm/swift/package/base"
+
+module Pod
+  module Swift
+    class PackageDescription
+      class Resources < PackageDescriptionBaseObject
+        def name
+          "#{pkg_name}_#{parent.name}"
+        end
+
+        def built_resource_path
+          "${PODS_CONFIGURATION_BUILD_DIR}/#{name}.bundle"
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/swift/package/target.rb

@@ -0,0 +1,96 @@
+require "cocoapods-spm/swift/package/base"
+
+module Pod
+  module Swift
+    class PackageDescription
+      autoload :Resources, "cocoapods-spm/swift/package/resources"
+
+      class Target < PackageDescriptionBaseObject
+        def type
+          raw["type"]
+        end
+
+        def macro?
+          type == "macro"
+        end
+
+        def binary?
+          return @binary unless @binary.nil?
+
+          @binary = type == "binary"
+        end
+
+        def dynamic?
+          @dynamic
+        end
+
+        def framework_name
+          @product_name || name
+        end
+
+        def public_headers_path
+          raw["publicHeadersPath"]
+        end
+
+        def clang_modulemap_arg
+          return nil if public_headers_path.nil?
+
+          "-fmodule-map-file=\"${GENERATED_MODULEMAP_DIR}/#{name}.modulemap\""
+        end
+
+        def resources
+          raw.fetch("resources", []).flat_map { |h| Resources.new(h, parent: self) }
+        end
+
+        def linker_flags
+          return ["-framework \"#{framework_name}\""] if dynamic?
+          return ["-l\"#{name}.o\""] unless binary?
+
+          case binary_basename
+          when /(\S+)\.framework/ then ["-framework \"#{$1}\""]
+          when /lib(\S+)\.a/ then ["-library \"#{$1}\""]
+          when /(\S+\.a)/ then ["\"${PODS_CONFIGURATION_BUILD_DIR}/#{$1}\""]
+          else []
+          end
+        end
+
+        def resolve_dependencies(pkg_desc_cache)
+          raw.fetch("dependencies", []).flat_map do |hash|
+            type = ["byName", "target", "product"].find { |k| hash.key?(k) }
+            if type.nil?
+              raise Informative, "Unexpected dependency type. Must be either `byName`, `target`, or `product`."
+            end
+
+            name = hash[type][0]
+            pkg_name = hash.key?("product") ? hash["product"][1] : self.pkg_name
+            pkg_desc = pkg_desc_cache[pkg_name]
+            find_by_target = -> { pkg_desc.targets.select { |t| t.name == name } }
+            find_by_product = -> { pkg_desc.targets_of_product(name) }
+            next find_by_target.call if hash.key?("target")
+            next find_by_product.call if hash.key?("product")
+
+            # byName, could be either a target or a product
+            next find_by_target.call || find_by_product.call
+          end
+        end
+
+        def built_framework_path
+          "${BUILT_PRODUCTS_DIR}/PackageFrameworks/#{framework_name}.framework"
+        end
+
+        def binary_basename
+          return nil unless binary?
+
+          @binary_basename ||= begin
+            paths = (root.artifacts_dir / name).glob("*.xcframework/*/*.{a,framework}")
+            paths[0].basename.to_s unless paths.empty?
+          end
+        end
+
+        def use_default_xcode_linking?
+          root.use_default_xcode_linking?
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-spm
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Thuyen Trinh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-20 00:00:00.000000000 Z
+date: 2024-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xcodeproj
@@ -46,24 +46,32 @@ files:
 - lib/cocoapods-spm/def/target_definition.rb
 - lib/cocoapods-spm/def/xcodeproj.rb
 - lib/cocoapods-spm/executables.rb
+- lib/cocoapods-spm/helpers/patch.rb
 - lib/cocoapods-spm/hooks/base.rb
+- lib/cocoapods-spm/hooks/helpers/update_script.rb
 - lib/cocoapods-spm/hooks/post_integrate/1.add_spm_pkgs.rb
 - lib/cocoapods-spm/hooks/post_integrate/5.update_settings.rb
 - lib/cocoapods-spm/hooks/post_integrate/6.update_embed_frameworks_script.rb
+- lib/cocoapods-spm/hooks/post_integrate/7.update_copy_resources_script.rb
 - lib/cocoapods-spm/macro/fetcher.rb
+- lib/cocoapods-spm/macro/metadata.rb
 - lib/cocoapods-spm/macro/pod_installer.rb
 - lib/cocoapods-spm/macro/prebuilder.rb
 - lib/cocoapods-spm/main.rb
-- lib/cocoapods-spm/metadata.rb
 - lib/cocoapods-spm/patch/aggregate_target.rb
 - lib/cocoapods-spm/patch/installer.rb
 - lib/cocoapods-spm/resolver.rb
-- lib/cocoapods-spm/resolver/product.rb
-- lib/cocoapods-spm/resolver/product_dep_resolver.rb
+- lib/cocoapods-spm/resolver/recursive_target_resolver.rb
 - lib/cocoapods-spm/resolver/result.rb
 - lib/cocoapods-spm/resolver/target_dep_resolver.rb
 - lib/cocoapods-spm/resolver/umbrella_package.rb
 - lib/cocoapods-spm/resolver/validator.rb
+- lib/cocoapods-spm/swift/package/base.rb
+- lib/cocoapods-spm/swift/package/description.rb
+- lib/cocoapods-spm/swift/package/product.rb
+- lib/cocoapods-spm/swift/package/project_packages.rb
+- lib/cocoapods-spm/swift/package/resources.rb
+- lib/cocoapods-spm/swift/package/target.rb
 - lib/cocoapods_plugin.rb
 homepage: https://github.com/trinhngocthuyen/cocoapods-spm
 licenses:

data/lib/cocoapods-spm/metadata.rb

@@ -1,50 +0,0 @@
-require "json"
-
-module Pod
-  module SPM
-    class Metadata
-      attr_reader :raw
-
-      def initialize(raw)
-        @raw = raw
-      end
-
-      def self.from_s(str)
-        new(JSON.parse(str))
-      end
-
-      def self.from_file(path)
-        from_s(File.read(path))
-      end
-
-      def self.for_pod(name)
-        from_file(Config.instance.macro_root_dir / name / "metadata.json")
-      end
-
-      def [](key)
-        raw[key]
-      end
-
-      def targets
-        raw["targets"]
-      end
-
-      def products
-        raw["products"]
-      end
-
-      def product_names_of_target(name)
-        names = products.select { |h| h["targets"].include?(name) }.map { |h| h["name"] }
-        names.empty? ? [name] : names
-      end
-
-      def targets_of_type(type)
-        targets.select { |t| t["type"] == type }
-      end
-
-      def macro_impl_name
-        targets_of_type("macro").first&.fetch("name")
-      end
-    end
-  end
-end

data/lib/cocoapods-spm/resolver/product.rb

@@ -1,31 +0,0 @@
-module Pod
-  module SPM
-    class Resolver
-      class Product
-        attr_reader :pkg, :name, :linkage, :headers_path, :binary
-
-        alias binary? binary
-
-        def initialize(options = {})
-          @pkg = options[:pkg]
-          @name = options[:name]
-          @linkage = options.fetch(:linkage, :static)
-          @headers_path = options[:headers_path]
-          @binary = options[:binary]
-        end
-
-        def inspect
-          "#<#{self.class} #{pkg}/#{name}>"
-        end
-
-        def dynamic?
-          @linkage == :dynamic
-        end
-
-        def linked_as_framework?
-          dynamic? || binary?
-        end
-      end
-    end
-  end
-end

data/lib/cocoapods-spm/resolver/product_dep_resolver.rb

@@ -1,134 +0,0 @@
-module Pod
-  module SPM
-    class Resolver
-      class ProductDependencyResolver
-        require "cocoapods-spm/resolver/product"
-
-        include Config::Mixin
-
-        def initialize(podfile, result)
-          @podfile = podfile
-          @result = result
-        end
-
-        def resolve
-          generate_metadata
-          resolve_dynamic_products
-          resolve_binary_targets
-          resolve_headers_path_by_target
-          resolve_product_deps
-        end
-
-        private
-
-        def generate_metadata
-          spm_config.pkg_checkouts_dir.glob("*").each do |dir|
-            next if dir.glob("Package*.swift").empty?
-
-            raw = Dir.chdir(dir) { `swift package dump-package` }
-            metadata = Metadata.from_s(raw)
-            write_metadata = lambda do |name|
-              (spm_config.pkg_metadata_dir / "#{name}.json").write(raw)
-              @result.metadata_cache[name] = metadata
-            end
-
-            pkg_name = metadata["name"]
-            pkg_slug = dir.basename.to_s
-            write_metadata.call(pkg_name)
-            write_metadata.call(pkg_slug) unless pkg_name == pkg_slug
-          end
-        end
-
-        def resolve_dynamic_products
-          @dynamic_products ||= Set.new
-          @result.metadata_cache.each_value do |metadata|
-            metadata.products.each do |h|
-              library_types = h.fetch("type", {}).fetch("library", [])
-              @dynamic_products << h["name"] if library_types.include?("dynamic")
-            end
-          end
-        end
-
-        def resolve_binary_targets
-          @binary_targets ||= Set.new
-          @result.metadata_cache.each_value do |metadata|
-            metadata.targets.each do |h|
-              @binary_targets << h["name"] if h["type"] == "binary"
-            end
-          end
-        end
-
-        def resolve_headers_path_by_target
-          @headers_path_by_product ||= {}
-          @result.metadata_cache.each_value do |metadata|
-            metadata.targets.each do |h|
-              next unless h.key?("publicHeadersPath")
-
-              metadata.product_names_of_target(h["name"]).each do |name|
-                @headers_path_by_product[name] = h["publicHeadersPath"]
-              end
-            end
-          end
-        end
-
-        def resolve_product_deps
-          @result.spm_dependencies_by_target.values.flatten.uniq(&:product).each do |dep|
-            next if dep.pkg.use_default_xcode_linking?
-
-            verify_product_exists_in_pkg(dep.pkg.name, dep.product)
-            product = create_product(dep.pkg.name, dep.product)
-            recursive_products_of(product)
-          end
-        end
-
-        def verify_product_exists_in_pkg(pkg, name)
-          return unless @result.metadata_of(pkg).products.find { |h| h["name"] == name }.nil?
-
-          raise Informative, "Package `#{pkg}` does not contain product named `#{name}`"
-        end
-
-        def recursive_products_of(product)
-          products = [product] + direct_products_of(product).flat_map do |child|
-            [child] + recursive_products_of(child)
-          end.uniq(&:name)
-          @result.spm_products[product.name] = products
-          products
-        end
-
-        def direct_products_of(product)
-          metadata = @result.metadata_of(product.pkg)
-          metadata
-            .products
-            .find { |h| h["name"] == product.name }
-            .to_h
-            .fetch("targets", [product.name])
-            .flat_map do |t|
-              metadata
-                .targets
-                .find { |h| h["name"] == t }
-                .fetch("dependencies", [])
-                .map { |h| product_from_hash(h, metadata) }
-            end
-        end
-
-        def product_from_hash(hash, metadata)
-          type = ["byName", "target", "product"].find { |k| hash.key?(k) }
-          name = hash[type][0] unless type.nil?
-          pkg = metadata["name"]
-          pkg = hash["product"][1] if hash.key?("product")
-          create_product(pkg, name)
-        end
-
-        def create_product(pkg, name)
-          Product.new(
-            pkg: pkg,
-            name: name,
-            linkage: @dynamic_products.include?(name) ? :dynamic : :static,
-            headers_path: @headers_path_by_product[name],
-            binary: @binary_targets.include?(name)
-          )
-        end
-      end
-    end
-  end
-end