cocoapods-spm 0.1.3 → 0.1.5

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

@@ -56,10 +56,15 @@ module Pod
       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)
+        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

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/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,58 @@
+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
+          # 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).reject(&:macro?)
+        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?
+
+          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

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

@@ -0,0 +1,154 @@
+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 sources_path
+          @sources_path ||= begin
+            path = raw["path"] || "Sources/#{name}"
+            root.src_dir / path
+          end
+        end
+
+        def header_search_path_arg
+          return nil if public_headers_path.nil?
+
+          path = public_headers_path.to_s.sub(root.checkouts_dir.to_s, "${SOURCE_PACKAGES_CHECKOUTS_DIR}")
+          "\"#{path}\""
+        end
+
+        def public_headers_path
+          res = sources_path / raw["publicHeadersPath"] if raw.key?("publicHeadersPath")
+          res = implicit_public_headers if res.nil?
+          res
+        end
+
+        def implicit_public_headers
+          path = sources_path / "include"
+          path unless path.glob("**/*.h*").empty?
+        end
+
+        def use_generated_modulemap?
+          return false if public_headers_path.nil?
+
+          # If there exists module.modulemap, it'll be auto picked up during compilation
+          true if public_headers_path.glob("module.modulemap").empty?
+        end
+
+        def clang_modulemap_arg
+          return nil unless use_generated_modulemap?
+
+          "-fmodule-map-file=\"${GENERATED_MODULEMAP_DIR}/#{name}.modulemap\""
+        end
+
+        def resources
+          res = raw.fetch("resources", []).flat_map { |h| Resources.new(h, parent: self) }
+          res = implicit_resources if res.empty?
+          res
+        end
+
+        def implicit_resources
+          target_sources_path = raw["path"] || "Sources/#{name}"
+          target_sources_path = root.src_dir / target_sources_path
+
+          # Refer to the following link for the implicit resources
+          # https://developer.apple.com/documentation/xcode/bundling-resources-with-a-swift-package#Add-resource-files
+          patterns = [
+            "*.xcassets",
+            "*.xib",
+            "*.storyboard",
+            "*.xcdatamodeld",
+            "*.lproj",
+          ]
+          return [] if patterns.all? { |p| target_sources_path.glob(p).empty? }
+
+          [Resources.new({}, 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|dylib)/ then ["-l\"#{$1}\""]
+          when /(\S+\.(a|dylib))/ 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 xcframework
+          @xcframework ||= begin
+            path = (root.artifacts_dir / name).glob("*.xcframework")[0]
+            Xcode::XCFramework.new(name, path.realpath) unless path.nil?
+          end
+        end
+
+        def binary_basename
+          return nil unless binary?
+
+          @binary_basename ||= begin
+            xcframework_dir ||= (root.artifacts_dir / name).glob("*.xcframework")[0]
+            xcframework_dir ||= root.src_dir / raw["path"] if raw.key?("path")
+            paths = xcframework_dir.glob("*/*.{a,framework}")
+            UI.warn "Cannot detect binary_basename for #{name}" if paths.empty?
+            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