cocoapods-spm 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b31c9b35087187bc68aa7537abeb5fec4fb45e496c767382b8b8300ebadebf30
-  data.tar.gz: fa9dcb1a770f7aeb42db04739bc81ae9ff52c9e0fffe0368e7769f36e1b99977
+  metadata.gz: e61ad227d509165fab0c8f3e832aa06d05524fa7c2cbfd4d7cc8f393252fc60f
+  data.tar.gz: 66f6bf9e254c7a99edc55f304fcf34ea60867fbbb9f138a6473eb200b6fa9f32
 SHA512:
-  metadata.gz: e644e4b8ba131f6eac0694ee25548e85f0782fadc794d68c944a18c969671f175aa14baaa0928b31cbbdbea0a8b3e14cd8ca01fb78022d8b4db1a66f676758e7
-  data.tar.gz: ea77387bf7c1e8ecb35fc00693450d0456b3535490561c4012397ab347127381719038d3ce6de88b529ba3966645d40d9d42adc8e5481763006f731f0c4e82d2
+  metadata.gz: e48c19f9a2ed81601a69cca75ceda44b9353bf76f996458dc3398dad8e7b0ed2fa6fff8ce03cad91122cdcf6f7603a5cc1070b9944dfab98a0d1ff5081f82740
+  data.tar.gz: d26d1674591412b761b92e51154142b5e76f7515464b0e462d5b26a06caeadd3162df96308d2ff34b1cb3d27c554eb33715d2248b7e66e2e58e1d56ceb4b1214

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

@@ -0,0 +1,11 @@
+module Pod
+  module SPM
+    class Config
+      module PodConfigMixin
+        def pod_config
+          Pod::Config.instance
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Pod
+  module SPM
+    class Config
+      module ProjectConfigMixin
+        def project_config
+          ProjectConfig.instance
+        end
+      end
+
+      class ProjectConfig
+        def self.instance
+          @instance ||= ProjectConfig.new
+        end
+
+        def workspace
+          @workspace ||= Pod::Config.instance.podfile.defined_in_file.parent.glob("*.xcworkspace").first
+        end
+
+        def scheme
+          workspace.parent.glob("*.xcodeproj/**/*.xcscheme").first.basename(".xcscheme")
+        end
+
+        def default_derived_data_path
+          @default_derived_data_path ||= begin
+            raw = `xcodebuild -showBuildSettings -workspace #{workspace.shellescape} -scheme #{scheme.shellescape}`
+            Pathname(raw[/BUILD_DIR = (.*)/, 1]).parent.parent
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Pod
+  module SPM
+    class Config
+      module SPMConfigMixin
+        def spm_config
+          Config.instance
+        end
+
+        def macro_pods
+          pod_config.podfile.macro_pods
+        end
+      end
+
+      attr_accessor :dsl_config, :cli_config
+
+      def initialize
+        @dsl_config = {
+          :dont_prebuild_macros => false,
+          :dont_prebuild_macros_if_exist => true
+        }
+        @cli_config = {}
+      end
+
+      def self.instance
+        @instance ||= Config.new
+      end
+
+      def merged_config
+        @dsl_config.merge(@cli_config)
+      end
+
+      def dont_prebuild_macros?
+        merged_config[:dont_prebuild_macros]
+      end
+
+      def dont_prebuild_macros_if_exist?
+        merged_config[:dont_prebuild_macros_if_exist]
+      end
+
+      def macro_config
+        merged_config[:config] || merged_config[:default_macro_config] || "debug"
+      end
+
+      def all_macros
+        @all_macros ||= Pod::Config.instance.podfile.macro_pods.keys
+      end
+
+      def macros
+        merged_config[:all] ? all_macros : (merged_config[:macros] || [])
+      end
+
+      def root_dir
+        @root_dir ||= Pathname(".spm.pods")
+      end
+
+      def pkg_root_dir
+        @pkg_root_dir ||= prepare_dir(root_dir / "packages")
+      end
+
+      def macro_root_dir
+        root_dir # To be updated: rootdir / "macros"
+      end
+
+      def macro_downloaded_root_dir
+        macro_root_dir / ".downloaded"
+      end
+
+      def macro_downloaded_sandbox
+        @macro_downloaded_sandbox ||= Sandbox.new(macro_downloaded_root_dir)
+      end
+
+      def pkg_umbrella_dir
+        @pkg_umbrella_dir ||= prepare_dir(root_dir / ".umbrella")
+      end
+
+      def pkg_checkouts_dir
+        pkg_umbrella_dir / ".build" / "checkouts"
+      end
+
+      def pkg_metadata_dir
+        @pkg_metadata_dir ||= prepare_dir(pkg_root_dir / "metadata")
+      end
+
+      private
+
+      def prepare_dir(dir)
+        dir.mkpath
+        dir
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/config.rb

@@ -1,64 +1,14 @@
+require "cocoapods-spm/config/spm"
+require "cocoapods-spm/config/pod"
+require "cocoapods-spm/config/project"
+
 module Pod
   module SPM
     class Config
       module Mixin
-        def spm_config
-          Config.instance
-        end
-
-        def macro_pods
-          Pod::Config.instance.podfile.macro_pods
-        end
-      end
-
-      attr_accessor :dsl_config, :cli_config
-
-      def initialize
-        @dsl_config = {
-          :dont_prebuild_macros => false,
-          :dont_prebuild_macros_if_exist => true
-        }
-        @cli_config = {}
-      end
-
-      def self.instance
-        @instance ||= Config.new
-      end
-
-      def merged_config
-        @dsl_config.merge(@cli_config)
-      end
-
-      def dont_prebuild_macros?
-        merged_config[:dont_prebuild_macros]
-      end
-
-      def dont_prebuild_macros_if_exist?
-        merged_config[:dont_prebuild_macros_if_exist]
-      end
-
-      def macro_config
-        merged_config[:config] || merged_config[:default_macro_config] || "debug"
-      end
-
-      def all_macros
-        @all_macros ||= Pod::Config.instance.podfile.macro_pods.keys
-      end
-
-      def macros
-        merged_config[:all] ? all_macros : (merged_config[:macros] || [])
-      end
-
-      def macro_root_dir
-        @macro_root_dir ||= Pathname(".spm.pods")
-      end
-
-      def macro_downloaded_root_dir
-        macro_root_dir / ".downloaded"
-      end
-
-      def macro_downloaded_sandbox
-        @macro_downloaded_sandbox ||= Sandbox.new(macro_downloaded_root_dir)
+        include ProjectConfigMixin
+        include PodConfigMixin
+        include SPMConfigMixin
       end
     end
   end

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

@@ -2,7 +2,7 @@ require "cocoapods-spm/config"
 
 module Pod
   class Podfile
-    attr_accessor :spm_analyzer
+    attr_accessor :spm_resolver
 
     alias origin_pod pod
     def config_cocoapods_spm(options)
@@ -33,10 +33,14 @@ module Pod
 
     def spm_pkgs_by_aggregate_target
       @spm_pkgs_by_aggregate_target ||= begin
-        common_spm_pkgs = root_target_definitions.flat_map(&:spm_pkgs)
-        target_definition_list.reject(&:abstract?).to_h do |target|
-          [target.to_s, (common_spm_pkgs + target.spm_pkgs).uniq(&:name)]
+        dict = {}
+        to_visit = root_target_definitions.map { |t| [t, []] }
+        until to_visit.empty?
+          target, acc = to_visit.pop
+          dict[target.to_s] = (target.spm_pkgs + acc).uniq
+          to_visit += target.children.map { |t| [t, dict[target.to_s]] }
         end
+        dict
       end
     end
 

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

@@ -14,15 +14,6 @@ module Pod
         @pkg = pkg
       end
 
-      def linkage
-        # TODO: How to detect the linkage of an SPM library?
-        @pkg.linkage.is_a?(Hash) ? @pkg.linkage[@product] : @pkg.linkage
-      end
-
-      def dynamic?
-        linkage == :dynamic
-      end
-
       def inspect
         "#<#{self.class} name=#{name} product=#{product} pkg=#{pkg}>"
       end

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

@@ -4,7 +4,7 @@ require "cocoapods-spm/def/spm_dependency"
 module Pod
   module SPM
     class Package
-      attr_reader :name, :requirement, :url, :relative_path, :linkage
+      attr_reader :name, :requirement, :url, :relative_path, :linking_opts
 
       def initialize(name, options = {})
         @name = name
@@ -13,14 +13,23 @@ module Pod
         @linkage = nil
         @url = nil
         @requirement = nil
+        @linking_opts = {}
         parse_options(options)
       end
 
       def parse_options(options)
         @url = options[:url] || options[:git]
-        @linkage = options[:linkage]
         @relative_path = relative_path_from(options)
         @requirement = requirement_from(options)
+        @linking_opts = options[:linking] || {}
+      end
+
+      def slug
+        @slug ||= File.basename(@url || @relative_path, ".*")
+      end
+
+      def absolute_path
+        (Pathname("Pods") / relative_path).realpath.to_s
       end
 
       def relative_path_from(options)
@@ -40,6 +49,14 @@ module Pod
         @relative_path != nil
       end
 
+      def use_default_xcode_linking?
+        @linking_opts.fetch(:use_default_xcode_linking, false)
+      end
+
+      def linker_flags
+        @linking_opts[:linker_flags] || []
+      end
+
       def to_dependencies
         if (products = @_options[:products])
           products.map { |product| Dependency.new(@name, product: product, pkg: self) }

data/lib/cocoapods-spm/hooks/base.rb

@@ -10,7 +10,7 @@ module Pod
       def initialize(context, options = {})
         @context = context
         @options = options
-        @spm_analyzer = options[:spm_analyzer]
+        @spm_resolver = options[:spm_resolver]
         @analysis_result = options[:analysis_result]
       end
 
@@ -38,12 +38,16 @@ module Pod
         Config.instance
       end
 
+      def podfile
+        pod_config.podfile
+      end
+
       def run; end
 
       def self.run_hooks(phase, context, options)
         Dir["#{__dir__}/#{phase}/*.rb"].sort.each do |f|
           require f
-          id = File.basename(f, ".*")
+          id = File.basename(f, ".*").split(".").last
           cls_name = "Pod::SPM::Hook::#{id.camelize}"
           UI.message "- Running hook: #{cls_name}" do
             cls_name.constantize.new(context, options).run

data/lib/cocoapods-spm/hooks/post_integrate/{add_spm_pkgs.rb → 1.add_spm_pkgs.rb}

@@ -1,12 +1,12 @@
 require "cocoapods-spm/hooks/base"
-require "cocoapods-spm/installer/analyzer"
+require "cocoapods-spm/resolver"
 
 module Pod
   module SPM
     class Hook
       class AddSpmPkgs < Hook
         def run
-          return unless @spm_analyzer.spm_pkgs
+          return if @spm_resolver.result.spm_pkgs.empty?
 
           add_spm_pkg_refs_to_project
           add_spm_products_to_targets
@@ -20,7 +20,7 @@ module Pod
         end
 
         def add_spm_pkg_refs_to_project
-          @spm_pkg_refs = @spm_analyzer.spm_pkgs.to_h do |pkg|
+          @spm_pkg_refs = @spm_resolver.result.spm_pkgs.to_h do |pkg|
             pkg_ref = pkg.create_pkg_ref(pods_project)
             pods_project.root_object.package_references << pkg_ref
             [pkg.name, pkg_ref]
@@ -33,17 +33,14 @@ module Pod
 
         def add_spm_products_to_targets
           pods_project.targets.each do |target|
-            @spm_analyzer.spm_dependencies_by_target[target.name].to_a.each do |dep|
+            @spm_resolver.result.spm_dependencies_by_target[target.name].to_a.each do |dep|
               pkg_ref = spm_pkg_refs[dep.pkg.name]
               target_dep_ref = pkg_ref.create_target_dependency_ref(dep.product)
               target.dependencies << target_dep_ref
+              target.package_product_dependencies << target_dep_ref.product_ref if dep.pkg.use_default_xcode_linking?
             end
           end
         end
-
-        def podfile
-          Pod::Config.instance.podfile
-        end
       end
     end
   end

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

@@ -6,15 +6,16 @@ module Pod
     class Hook
       class UpdateSettings < Hook
         def run
-          update_other_swift_flags
+          update_macro_plugin_flags
+          update_modulemap_flags
           update_swift_include_paths
           update_linker_flags
         end
 
         private
 
-        def other_swift_flags_by_config
-          @other_swift_flags_by_config ||= begin
+        def macro_plugin_flag_by_config
+          @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)
@@ -31,19 +32,29 @@ module Pod
           end
         end
 
-        def update_other_swift_flags
+        def update_macro_plugin_flags
           return if spm_config.all_macros.empty?
 
-          # For prebuilt macros
           perform_settings_update(
             update_targets: lambda do |_, _, config|
-              { "OTHER_SWIFT_FLAGS" => other_swift_flags_by_config[config] }
+              { "OTHER_SWIFT_FLAGS" => macro_plugin_flag_by_config[config] }
+            end
+          )
+        end
+
+        def update_modulemap_flags
+          perform_settings_update(
+            update_targets: lambda do |target, _, _|
+              {
+                "OTHER_SWIFT_FLAGS" => modulemap_args_for_target(target, prefix: "-Xcc"),
+                "OTHER_CFLAGS" => modulemap_args_for_target(target)
+              }
             end
           )
         end
 
         def update_linker_flags
-          return if @spm_analyzer.spm_pkgs.empty?
+          return if @spm_resolver.result.spm_pkgs.empty?
 
           # For packages to work in the main target
           perform_settings_update(
@@ -58,22 +69,30 @@ module Pod
         end
 
         def linker_flags_for(target)
-          spm_deps = @spm_analyzer.spm_dependencies_by_target[target.to_s].to_a
-          framework_flags = spm_deps.select(&:dynamic?).map { |d| "-framework \"#{d.product}\"" }
-          library_flags = spm_deps.reject(&:dynamic?).map { |d| "-l\"#{d.product}.o\"" }
-          framework_flags + library_flags
+          return [] if !target.is_a?(Pod::AggregateTarget) && target.build_as_static?
+
+          @spm_resolver.result.linker_flags_for(target)
         end
 
         def update_swift_include_paths
-          return if @spm_analyzer.spm_pkgs.empty?
+          return if @spm_resolver.result.spm_pkgs.empty? && spm_config.all_macros.empty?
 
-          # For macro packages
           perform_settings_update(
             update_targets: lambda do |_, _, _|
               { "SWIFT_INCLUDE_PATHS" => "$(PODS_CONFIGURATION_BUILD_DIR)" }
             end
           )
         end
+
+        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\"" }
+            .map { |v| prefix.nil? ? v : "#{prefix} #{v}" }
+            .join(" ")
+        end
       end
     end
   end

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

@@ -18,12 +18,8 @@ module Pod
         private
 
         def framework_paths_for(target)
-          @dynamic_deps_by_target ||=
-            @spm_analyzer
-            .spm_dependencies_by_target
-            .transform_values { |deps| deps.select(&:dynamic?) }
-          @dynamic_deps_by_target[target.to_s].map do |d|
-            "${BUILT_PRODUCTS_DIR}/PackageFrameworks/#{d.product}.framework"
+          @spm_resolver.result.spm_products_for(target).select(&:dynamic?).map do |p|
+            "${BUILT_PRODUCTS_DIR}/PackageFrameworks/#{p.name}.framework"
           end
         end
 

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

@@ -37,13 +37,9 @@ module Pod
         raise "Package.swift not exist in #{macro_downloaded_dir}" \
           unless (macro_downloaded_dir / "Package.swift").exist?
 
-        UI.message "Generating metadata at: #{metadata_path}" do
-          raw = Dir.chdir(macro_downloaded_dir) do
-            swift! ["package", "dump-package"]
-          end
-          metadata_path.write(raw)
-          @metadata = Metadata.from_s(raw)
-        end
+        raw = Dir.chdir(macro_downloaded_dir) { `swift package dump-package` }
+        metadata_path.write(raw)
+        @metadata = Metadata.from_s(raw)
       end
 
       def prebuild_macro_impl

data/lib/cocoapods-spm/metadata.rb

@@ -21,10 +21,23 @@ module Pod
         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

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

@@ -7,7 +7,7 @@ module Pod
     end
 
     def includes_dynamic_spm_dependencies?
-      podfile.spm_analyzer.spm_dependencies_for(self).any?(&:dynamic?)
+      podfile.spm_resolver.result.spm_products_for(self).any?(&:dynamic?)
     end
   end
 end

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

@@ -1,4 +1,4 @@
-require "cocoapods-spm/installer/analyzer"
+require "cocoapods-spm/resolver"
 require "cocoapods-spm/macro/pod_installer"
 require "cocoapods-spm/hooks/base"
 
@@ -39,7 +39,7 @@ module Pod
 
     def hook_options
       {
-        :spm_analyzer => @spm_analyzer,
+        :spm_resolver => @spm_resolver,
         :analysis_result => @analysis_result
       }
     end
@@ -55,10 +55,10 @@ module Pod
     end
 
     def resolve_spm_dependencies
-      UI.section "Analyzing SPM dependencies" do
-        @spm_analyzer ||= Pod::Installer::SPMAnalyzer.new(podfile, aggregate_targets)
-        @spm_analyzer.analyze
-        podfile.spm_analyzer = @spm_analyzer
+      UI.section "Resolving SPM dependencies" do
+        @spm_resolver ||= SPM::Resolver.new(podfile, aggregate_targets)
+        @spm_resolver.resolve
+        podfile.spm_resolver = @spm_resolver
       end
     end
   end

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,134 @@
+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

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

@@ -0,0 +1,51 @@
+module Pod
+  module SPM
+    class Resolver
+      class Result
+        class WritableResult < Result
+          attr_accessor :spm_pkgs, :spm_dependencies_by_target, :spm_products, :metadata_cache
+
+          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
+            )
+          end
+        end
+
+        attr_reader :spm_pkgs, :spm_dependencies_by_target, :spm_products, :metadata_cache
+
+        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] || {}
+        end
+
+        def metadata_of(name)
+          return @metadata_cache[name] if @metadata_cache.key?(name)
+
+          raise Informative, "Metadata of `#{name}` does not exist"
+        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)
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Pod
+  module SPM
+    class Resolver
+      class TargetDependencyResolver
+        def initialize(podfile, aggregate_targets, result)
+          @podfile = podfile
+          @aggregate_targets = aggregate_targets
+          @result = result
+        end
+
+        def resolve
+          resolve_spm_pkgs
+          resolve_spm_dependencies_by_target
+        end
+
+        private
+
+        def resolve_spm_pkgs
+          @result.spm_pkgs = @podfile.target_definition_list.flat_map(&:spm_pkgs).uniq
+        end
+
+        def resolve_spm_dependencies_by_target
+          resolve_dependencies_for_targets
+          resolve_dependencies_for_aggregate_targets
+          @result.spm_dependencies_by_target.values.flatten.each { |d| d.pkg = spm_pkg_for(d.name) }
+        end
+
+        def resolve_dependencies_for_targets
+          specs = @aggregate_targets.flat_map(&:specs).uniq
+          specs.each do |spec|
+            @result.spm_dependencies_by_target[spec.name] = spec.spm_dependencies
+          end
+        end
+
+        def resolve_dependencies_for_aggregate_targets
+          @aggregate_targets.each do |target|
+            spm_dependencies = target.specs.flat_map(&:spm_dependencies)
+            @result.spm_dependencies_by_target[target.to_s] = merge_spm_dependencies(spm_dependencies)
+          end
+
+          @podfile.spm_pkgs_by_aggregate_target.each do |target, pkgs|
+            existing = @result.spm_dependencies_by_target[target].to_a
+            spm_dependencies = pkgs.flat_map(&:to_dependencies)
+            @result.spm_dependencies_by_target[target] = merge_spm_dependencies(existing + spm_dependencies)
+          end
+        end
+
+        def merge_spm_dependencies(deps)
+          deps_by_name = Hash.new { |h, k| h[k] = [] }
+          deps.each { |d| deps_by_name[d.name] << d }
+          deps_by_name.each do |name, ds|
+            deps_by_name[name] = ds.uniq { |d| [d.name, d.product] }
+          end
+          deps_by_name.values.flatten
+        end
+
+        def spm_pkg_for(name)
+          @_spm_pkgs_by_name ||= @result.spm_pkgs.to_h { |pkg| [pkg.name, pkg] }
+          @_spm_pkgs_by_name[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Pod
+  module SPM
+    class UmbrellaPackage
+      include Config::Mixin
+
+      def initialize(podfile)
+        @podfile = podfile
+        @spm_pkgs = @podfile.target_definition_list.flat_map(&:spm_pkgs).uniq
+      end
+
+      def prepare
+        generate_pkg_swift
+        swift_pkg_resolve
+        create_symlinks_to_local_pkgs
+        self
+      end
+
+      private
+
+      def generate_pkg_swift
+        swift_tools_version = "5.7"
+        dependencies = @spm_pkgs.map do |pkg|
+          # https://developer.apple.com/documentation/packagedescription/package/dependency
+          next ".package(path: \"#{pkg.absolute_path}\")" if pkg.local?
+
+          tail = case pkg.requirement[:kind]
+                 when "exactVersion"
+                   "exact: \"#{pkg.requirement[:version]}\""
+                 when "branch"
+                   "branch: \"#{pkg.requirement[:branch]}\""
+                 when "revision"
+                   "revision: \"#{pkg.requirement[:revision]}\""
+                 else
+                   # TODO: Handle this
+                   "todo: \"handle this\""
+                 end
+          ".package(url: \"#{pkg.url}\", #{tail})"
+        end
+
+        package_content = <<~HEREDOC
+          // swift-tools-version:#{swift_tools_version}
+          import PackageDescription
+
+          let package = Package(
+            name: "_umbrella_",
+            dependencies: [
+              #{dependencies.join(",\n    ")}
+            ]
+          )
+        HEREDOC
+        (spm_config.pkg_umbrella_dir / "Package.swift").write(package_content)
+      end
+
+      def swift_pkg_resolve
+        Dir.chdir(spm_config.pkg_umbrella_dir) { `swift package resolve` }
+      end
+
+      def create_symlinks_to_local_pkgs
+        @spm_pkgs.select(&:local?).each do |pkg|
+          dst_dir = spm_config.pkg_checkouts_dir / pkg.slug
+          dst_dir.delete if dst_dir.exist?
+          File.symlink(pkg.absolute_path, dst_dir)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/{installer → resolver}/validator.rb

@@ -1,10 +1,10 @@
 module Pod
-  class Installer
-    class SPMValidator
-      def initialize(aggregate_targets, spm_pkgs, spm_dependencies_by_target)
+  module SPM
+    class Validator
+      def initialize(aggregate_targets, result)
         @aggregate_targets = aggregate_targets
-        @spm_pkgs = spm_pkgs
-        @spm_dependencies_by_target = spm_dependencies_by_target
+        @spm_pkgs = result.spm_pkgs
+        @spm_dependencies_by_target = result.spm_dependencies_by_target
       end
 
       def validate!

data/lib/cocoapods-spm/resolver.rb

@@ -0,0 +1,45 @@
+require "cocoapods-spm/resolver/validator"
+require "cocoapods-spm/resolver/umbrella_package"
+
+module Pod
+  module SPM
+    class Resolver
+      require "cocoapods-spm/resolver/result"
+      require "cocoapods-spm/resolver/target_dep_resolver"
+      require "cocoapods-spm/resolver/product_dep_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)
+      end
+
+      def resolve
+        generate_umbrella_pkg
+        resolvers.each(&:resolve)
+        validate!
+      end
+
+      def result
+        @result ||= @_result.to_read_only
+      end
+
+      private
+
+      def resolvers
+        [@target_dep_resolver, @product_dep_resolver]
+      end
+
+      def generate_umbrella_pkg
+        @umbrella_pkg = Pod::SPM::UmbrellaPackage.new(@podfile).prepare
+      end
+
+      def validate!
+        Validator.new(@aggregate_targets, result).validate!
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-spm
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Thuyen Trinh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-05 00:00:00.000000000 Z
+date: 2024-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xcodeproj
@@ -36,6 +36,9 @@ files:
 - lib/cocoapods-spm/command/prebuild.rb
 - lib/cocoapods-spm/command/spm.rb
 - lib/cocoapods-spm/config.rb
+- lib/cocoapods-spm/config/pod.rb
+- lib/cocoapods-spm/config/project.rb
+- lib/cocoapods-spm/config/spm.rb
 - lib/cocoapods-spm/def/podfile.rb
 - lib/cocoapods-spm/def/spec.rb
 - lib/cocoapods-spm/def/spm_dependency.rb
@@ -44,11 +47,9 @@ files:
 - lib/cocoapods-spm/def/xcodeproj.rb
 - lib/cocoapods-spm/executables.rb
 - lib/cocoapods-spm/hooks/base.rb
-- lib/cocoapods-spm/hooks/post_integrate/add_spm_pkgs.rb
-- lib/cocoapods-spm/hooks/post_integrate/update_embed_frameworks_script.rb
-- lib/cocoapods-spm/hooks/post_integrate/update_settings.rb
-- lib/cocoapods-spm/installer/analyzer.rb
-- lib/cocoapods-spm/installer/validator.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/macro/fetcher.rb
 - lib/cocoapods-spm/macro/pod_installer.rb
 - lib/cocoapods-spm/macro/prebuilder.rb
@@ -56,6 +57,13 @@ files:
 - 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/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_plugin.rb
 homepage: https://github.com/trinhngocthuyen/cocoapods-spm
 licenses:

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

@@ -1,77 +0,0 @@
-require "cocoapods-spm/installer/validator"
-
-module Pod
-  class Installer
-    class SPMAnalyzer
-      attr_reader :spm_pkgs, :spm_dependencies_by_target
-
-      def initialize(podfile, aggregate_targets)
-        @podfile = podfile
-        @aggregate_targets = aggregate_targets
-        @spm_pkgs = []
-        @spm_dependencies_by_target = {}
-      end
-
-      def analyze
-        analyze_spm_pkgs
-        analyze_spm_dependencies_by_target
-        validate!
-      end
-
-      def spm_dependencies_for(target)
-        @spm_dependencies_by_target[target.to_s]
-      end
-
-      private
-
-      def analyze_spm_pkgs
-        @spm_pkgs = @podfile.target_definition_list.flat_map(&:spm_pkgs).uniq
-      end
-
-      def analyze_spm_dependencies_by_target
-        analyze_dependencies_for_targets
-        analyze_dependencies_for_aggregate_targets
-        @spm_dependencies_by_target.values.flatten.each { |d| d.pkg = spm_pkg_for(d.name) }
-      end
-
-      def analyze_dependencies_for_targets
-        specs = @aggregate_targets.flat_map(&:specs).uniq
-        specs.each do |spec|
-          @spm_dependencies_by_target[spec.name] = spec.spm_dependencies
-        end
-      end
-
-      def analyze_dependencies_for_aggregate_targets
-        @aggregate_targets.each do |target|
-          spm_dependencies = target.specs.flat_map(&:spm_dependencies)
-          @spm_dependencies_by_target[target.to_s] = merge_spm_dependencies(spm_dependencies)
-        end
-
-        @podfile.spm_pkgs_by_aggregate_target.each do |target, pkgs|
-          existing = @spm_dependencies_by_target[target].to_a
-          spm_dependencies = pkgs.flat_map(&:to_dependencies)
-          @spm_dependencies_by_target[target] = merge_spm_dependencies(existing + spm_dependencies)
-        end
-      end
-
-      def merge_spm_dependencies(deps)
-        deps_by_name = Hash.new { |h, k| h[k] = [] }
-        deps.each { |d| deps_by_name[d.name] << d }
-        deps_by_name.each do |name, ds|
-          deps_by_name[name] = ds.uniq { |d| [d.name, d.product] }
-        end
-        deps_by_name.values.flatten
-      end
-
-      def spm_pkg_for(name)
-        @_spm_pkgs_by_name ||= @spm_pkgs.to_h { |pkg| [pkg.name, pkg] }
-        @_spm_pkgs_by_name[name]
-      end
-
-      def validate!
-        validator = SPMValidator.new(@aggregate_targets, @spm_pkgs, @spm_dependencies_by_target)
-        validator.validate!
-      end
-    end
-  end
-end