cocoapods-spm2 0.1.10

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

@@ -0,0 +1,75 @@
+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
+
+    patch_method :resolve_dependencies do
+      origin_resolve_dependencies
+      resolve_spm_dependencies
+    end
+
+    patch_method :create_pod_installer do |pod_name|
+      if macro_pods.include?(pod_name)
+        macro_pod_installer = MacroPodInstaller.new(
+          sandbox,
+          podfile,
+          specs_for_pod(pod_name),
+          can_cache: installation_options.clean?
+        )
+        pod_installers << macro_pod_installer
+        macro_pod_installer
+      else
+        origin_create_pod_installer(pod_name)
+      end
+    end
+
+    patch_method :integrate do
+      run_spm_pre_integrate_hooks
+      origin_integrate
+      run_spm_post_integrate_hooks
+    end
+
+    patch_method :sandbox_state do
+      state = origin_sandbox_state
+      # NOTE: For macro pods, we force-trigger their source installers even in incremental installations.
+      # This is done by altering the `sandbox_state` & marking them as `added`
+      spm_config.all_macros.each do |name|
+        %i[unchanged changed deleted].each { |key| state.send(key).delete(name) }
+        state.added << (name)
+      end
+      state
+    end
+
+    private
+
+    def hook_options
+      {
+        :spm_resolver => @spm_resolver,
+        :analysis_result => @analysis_result,
+      }
+    end
+
+    def run_spm_pre_integrate_hooks
+      context = PreIntegrateHooksContext.generate(sandbox, pods_project, pod_target_subprojects, aggregate_targets)
+      SPM::Hook.run_hooks(:pre_integrate, context, hook_options)
+    end
+
+    def run_spm_post_integrate_hooks
+      context = PostIntegrateHooksContext.generate(sandbox, pods_project, pod_target_subprojects, aggregate_targets)
+      SPM::Hook.run_hooks(:post_integrate, context, hook_options)
+    end
+
+    def resolve_spm_dependencies
+      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
+end

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

@@ -0,0 +1,39 @@
+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.try(:use_default_xcode_linking?)
+
+            @podfile.platforms.each do |platform|
+              project_pkgs.resolve_recursive_targets_of(dep.pkg.name, dep.product, platform: platform)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+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
+          ATTRS.each_key { |x| attr_accessor x }
+
+          def to_read_only
+            Result.new(ATTRS.to_h { |x| [x, instance_variable_get("@#{x}")] })
+          end
+        end
+
+        ATTRS.each_key { |x| attr_reader x }
+
+        def initialize(options = {})
+          ATTRS.each do |k, v|
+            instance_variable_set("@#{k}", options[k] || v)
+          end
+        end
+
+        def spm_pkgs_for(target)
+          spm_dependencies_for(target).map(&:pkg).uniq(&:name)
+        end
+
+        def spm_dependencies_for(target)
+          filtered_dependencies = @spm_dependencies_by_target[spec_name_of(target)]&.reject do |dep|
+            dep.pkg&.should_exclude_from_target?(target.name)
+          end
+          filtered_dependencies.to_a
+        end
+
+        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, platform: target.platform.name)
+          end.uniq(&:name)
+          return targets.reject(&:use_default_xcode_linking?) if exclude_default_xcode_linking
+
+          targets
+        end
+
+        def linker_flags_for(target)
+          (
+            spm_targets_for(target).flat_map(&:linker_flags) +
+            spm_pkgs_for(target).flat_map(&:linker_flags)
+          ).uniq
+        end
+
+        private
+
+        def spec_name_of(target)
+          # In case of multi-platforms, the target name might contains the platform (ex. Logger-iOS, Logger-macOS)
+          # We need to strip the platform suffix out
+          return target.name if @spm_dependencies_by_target.key?(target.name)
+          return target.root_spec.name if target.is_a?(Pod::PodTarget)
+          return target.name if target.is_a?(Pod::AggregateTarget)
+
+          cmps = target.name.split("-")
+          return cmps[...-1].join("-") if ["iOS", "macOS", "watchOS", "tvOS"].include?(cmps[-1])
+
+          target.name
+        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(&:name)
+        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,72 @@
+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(&:name)
+      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
+        local_spm_pkgs = @spm_pkgs.select(&:local?)
+        symlinks = local_spm_pkgs.to_h { |p| [p.slug, p.absolute_path] }
+        local_spm_pkgs.each do |pkg|
+          pkg_desc = Swift::PackageDescription.from_dir(pkg.absolute_path)
+          pkg_desc.dependencies.select(&:local?).each { |d| symlinks[d.slug] = d.path }
+        end
+
+        symlinks.each do |slug, src_dir|
+          IOUtils.symlink(src_dir, spm_config.pkg_checkouts_dir / slug)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Pod
+  module SPM
+    class Validator
+      def initialize(aggregate_targets, result)
+        @aggregate_targets = aggregate_targets
+        @spm_pkgs = result.spm_pkgs
+        @spm_dependencies_by_target = result.spm_dependencies_by_target
+      end
+
+      def validate!
+        verify_no_missing_pkgs
+      end
+
+      private
+
+      def dependents_of_pkg(name)
+        @specs ||= @aggregate_targets.flat_map(&:specs).uniq
+        @specs.select { |s| s.spm_dependencies.any? { |d| d.name == name } }.map(&:name)
+      end
+
+      def verify_no_missing_pkgs
+        missing_pkgs = @spm_dependencies_by_target.values.flatten.select { |d| d.pkg.nil? }.map(&:name).uniq
+        return if missing_pkgs.empty?
+
+        messages = ["The following packages were not declared in Podfile:"]
+        messages += missing_pkgs.map { |pkg| "  • #{pkg}: used by #{dependents_of_pkg(pkg).join(', ')}" }
+        messages << "Use the `spm_pkg` method to declare those packages in Podfile."
+        raise Informative, messages.join("\n")
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/resolver.rb

@@ -0,0 +1,43 @@
+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/recursive_target_resolver"
+
+      def initialize(podfile, aggregate_targets)
+        @_result = Result::WritableResult.new
+        @podfile = podfile
+        @aggregate_targets = aggregate_targets
+        @umbrella_pkg = nil
+        @resolvers = [
+          TargetDependencyResolver.new(podfile, aggregate_targets, @_result),
+          RecursiveTargetResolver.new(podfile, @_result),
+        ]
+      end
+
+      def resolve
+        generate_umbrella_pkg
+        @resolvers.each(&:resolve)
+        validate!
+      end
+
+      def result
+        @result ||= @_result.to_read_only
+      end
+
+      private
+
+      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

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/dependency.rb

@@ -0,0 +1,27 @@
+require "cocoapods-spm/swift/package/base"
+
+module Pod
+  module Swift
+    class PackageDescription
+      class Dependency < PackageDescriptionBaseObject
+        def local?
+          raw.key?("fileSystem")
+        end
+
+        def slug
+          hash["identity"]
+        end
+
+        def path
+          hash["path"]
+        end
+
+        private
+
+        def hash
+          raw.values.flatten[0] || {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require "cocoapods-spm/swift/package/base"
+
+module Pod
+  module Swift
+    class PackageDescription < PackageDescriptionBaseObject
+      include SPM::Config::Mixin
+      autoload :Dependency, "cocoapods-spm/swift/package/dependency"
+      autoload :Target, "cocoapods-spm/swift/package/target"
+      autoload :Product, "cocoapods-spm/swift/package/product"
+
+      def self.from_dir(dir)
+        raw = `swift package dump-package --package-path #{dir.shellescape}`
+        from_s(raw)
+      end
+
+      def src_dir
+        @src_dir ||= begin
+          path = raw.fetch("packageKind", {}).fetch("root", [])[0]
+          Pathname.new(path) unless path.nil?
+        end
+      end
+
+      def checkouts_dir
+        src_dir.parent
+      end
+
+      def artifacts_dir
+        spm_config.pkg_artifacts_dir / slug
+      end
+
+      def slug
+        src_dir.nil? ? name : src_dir.basename.to_s
+      end
+
+      def dependencies
+        @dependencies ||= convert_field("dependencies", Dependency)
+      end
+
+      def targets
+        @targets ||= convert_field("targets", Target)
+      end
+
+      def products
+        @products ||= convert_field("products", Product)
+      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
+
+      private
+
+      def convert_field(name, type)
+        raw.fetch(name, []).flat_map { |h| type.new(h, parent: self) }
+      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,59 @@
+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, platform: nil)
+        @recursive_targets_cache ||= {}
+        @recursive_targets_cache[platform] ||= {}
+        return @recursive_targets_cache[platform][product_name] if @recursive_targets_cache[platform].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
+          # Exclude macros as they wont be linked to the project's binary
+          # https://github.com/trinhngocthuyen/cocoapods-spm/issues/107
+          to_visit += target.resolve_dependencies(@pkg_desc_cache, platform: platform).reject(&:macro?)
+        end
+        @recursive_targets_cache[platform][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?
+
+          pkg_desc = PackageDescription.from_dir(dir)
+          name = pkg_desc.name
+          slug = dir.basename.to_s
+          @pkg_desc_cache[name] = pkg_desc
+          @pkg_desc_cache[slug] = pkg_desc
+          next if @json_dir.nil?
+
+          json_path = @json_dir / "#{name}.json"
+          slug_json_path = @json_dir / "#{slug}.json"
+          json_path.write(pkg_desc.raw.to_json)
+          IOUtils.symlink(json_path, slug_json_path) unless name == 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