cocoapods-spm2 0.1.10

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

@@ -0,0 +1,14 @@
+module Pod
+  module IOUtils
+    def self.symlink(src, dst)
+      # NOTE: File operations are case-insensitive (foo.json and Foo.json are identical)
+      return if File.identical?(src, dst)
+
+      src = Pathname.new(src) unless src.is_a?(Pathname)
+      dst = Pathname.new(dst) unless dst.is_a?(Pathname)
+      dst.dirname.mkpath unless dst.dirname.exist?
+      dst.delete if dst.exist?
+      File.symlink(src.absolute? ? src : src.realpath, dst)
+    end
+  end
+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/base.rb

@@ -0,0 +1,99 @@
+require "cocoapods-spm/config"
+require "cocoapods-spm/def/podfile"
+require "cocoapods-spm/def/spec"
+
+module Pod
+  module SPM
+    class Hook
+      include Config::Mixin
+
+      def initialize(context, options = {})
+        @context = context
+        @options = options
+        @spm_resolver = options[:spm_resolver]
+        @analysis_result = options[:analysis_result]
+      end
+
+      def sandbox
+        @context.sandbox
+      end
+
+      def pods_project
+        @context.pods_project
+      end
+
+      def pod_targets
+        @analysis_result.pod_targets
+      end
+
+      def aggregate_targets
+        @analysis_result.targets
+      end
+
+      def pod_target_subprojects
+        @context.pod_target_subprojects
+      end
+
+      def projects_to_integrate
+        [pods_project] + pod_target_subprojects
+      end
+
+      def user_build_configurations
+        @user_build_configurations ||= (pod_targets + aggregate_targets)[0].user_build_configurations
+      end
+
+      def config
+        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, ".*").split(".").last
+          cls_name = "Pod::SPM::Hook::#{id.camelize}"
+          UI.message "- Running hook: #{cls_name}" do
+            cls_name.constantize.new(context, options).run
+          end
+        end
+      end
+
+      def perform_settings_update(
+        update_targets: nil,
+        update_pod_targets: nil,
+        update_aggregate_targets: nil
+      )
+        proc = lambda do |update, target, setting, config|
+          return if update.nil?
+
+          hash = update.call(target, setting, config)
+          setting.xcconfig.merge!(hash)
+          setting.generate.merge!(hash)
+          Installer::Xcode::PodsProjectGenerator::TargetInstallerHelper.update_changed_file(
+            setting, target.xcconfig_path(config)
+          )
+        end
+
+        pod_targets.each do |target|
+          target.build_settings.each do |config, setting|
+            proc.call(update_targets, target, setting, config)
+            proc.call(update_pod_targets, target, setting, config)
+          end
+        end
+
+        aggregate_targets.each do |target|
+          target.user_build_configurations.each_key do |config|
+            setting = target.build_settings(config)
+            proc.call(update_targets, target, setting, config)
+            proc.call(update_aggregate_targets, target, setting, config)
+          end
+        end
+      end
+    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/1.add_spm_pkgs.rb

@@ -0,0 +1,31 @@
+require "cocoapods-spm/hooks/base"
+require "cocoapods-spm/resolver"
+
+module Pod
+  module SPM
+    class Hook
+      class AddSpmPkgs < Hook
+        def run
+          return if @spm_resolver.result.spm_pkgs.empty?
+
+          projects_to_integrate.compact.each do |project|
+            spm_pkg_refs = {}
+            project.targets.each do |target|
+              @spm_resolver.result.spm_dependencies_for(target).each do |dep|
+                pkg_ref = dep.pkg.create_pkg_ref(project)
+                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?
+                spm_pkg_refs.store(dep.pkg.name, pkg_ref)
+              end
+            end
+            spm_pkg_refs.each_value do |pkg_ref|
+              project.root_object.package_references << pkg_ref
+            end
+            project.save
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require "cocoapods-spm/hooks/base"
+require "cocoapods-spm/macro/metadata"
+
+module Pod
+  module SPM
+    class Hook
+      class UpdateSettings < Hook
+        def run
+          update_macro_plugin_flags
+          update_packages_flags
+        end
+
+        private
+
+        def macro_plugin_flag_by_config
+          path_prefix = "${PODS_ROOT}/../#{spm_config.macro_prebuilt_root_dir}"
+          @macro_plugin_flag_by_config ||= begin
+            hash = user_build_configurations.keys.to_h do |config|
+              flags = macro_pods.keys.map do |name|
+                metadata = MacroMetadata.for_pod(name)
+                impl_module_name = metadata.macro_impl_name
+                plugin_executable_path =
+                  "#{path_prefix}/#{name}/" \
+                  "#{impl_module_name}-#{config.to_s.downcase}##{impl_module_name}"
+                "-load-plugin-executable \"#{plugin_executable_path}\""
+              end.join(" ")
+              [config, flags]
+            end
+            user_build_configurations.each { |config, symbol| hash[symbol] = hash[config] }
+            hash
+          end
+        end
+
+        def update_macro_plugin_flags
+          return if spm_config.all_macros.empty?
+
+          perform_settings_update(
+            update_targets: lambda do |_, _, config|
+              { "OTHER_SWIFT_FLAGS" => macro_plugin_flag_by_config[config] }
+            end
+          )
+        end
+
+        def update_packages_flags
+          return if @spm_resolver.result.spm_pkgs.empty?
+
+          perform_settings_update(
+            update_targets: lambda do |target, _, _|
+              {
+                "SOURCE_PACKAGES_CHECKOUTS_DIR" => "${BUILD_ROOT}/../../SourcePackages/checkouts",
+                "FRAMEWORK_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}/PackageFrameworks\"",
+                "LIBRARY_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}\"",
+                "SWIFT_INCLUDE_PATHS" => "$(PODS_CONFIGURATION_BUILD_DIR)",
+                "OTHER_SWIFT_FLAGS" => modulemap_args_for_target(target, prefix: "-Xcc"),
+                "OTHER_CFLAGS" => modulemap_args_for_target(target),
+                "HEADER_SEARCH_PATHS" => header_search_paths_for(target),
+                "OTHER_LDFLAGS" => linker_flags_for(target),
+              }
+            end
+          )
+        end
+
+        def linker_flags_for(target)
+          return [] if !target.is_a?(Pod::AggregateTarget) && target.build_as_static?
+
+          @spm_resolver.result.linker_flags_for(target)
+        end
+
+        def modulemap_args_for_target(target, prefix: nil)
+          @spm_resolver
+            .result
+            .spm_targets_for(target)
+            .filter_map(&:clang_modulemap_arg)
+            .map { |v| prefix.nil? ? v : "#{prefix} #{v}" }
+            .join(" ")
+        end
+
+        def header_search_paths_for(target)
+          @spm_resolver
+            .result
+            .spm_targets_for(target)
+            .filter_map(&:header_search_path_arg)
+            .join(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "cocoapods-spm/hooks/base"
+require "cocoapods-spm/hooks/helpers/update_script"
+
+module Pod
+  module SPM
+    class Hook
+      class UpdateEmbedFrameworksScript < Hook
+        include UpdateScript::Mixin
+
+        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
+
+        private
+
+        def framework_paths_for(target)
+          @spm_resolver.result.spm_targets_for(target).select(&:dynamic?).map(&:built_framework_path).uniq
+        end
+      end
+    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/config.rb

@@ -0,0 +1,27 @@
+module Pod
+  module SPM
+    module MacroConfigMixin
+      include Config::Mixin
+
+      def macro_downloaded_dir
+        spm_config.macro_downloaded_root_dir / name
+      end
+
+      def macro_dir
+        @macro_dir ||= spm_config.macro_root_dir / name
+      end
+
+      def macro_prebuilt_dir
+        spm_config.macro_prebuilt_root_dir / name
+      end
+
+      def metadata_path
+        macro_dir / "metadata.json"
+      end
+
+      def metadata
+        @metadata ||= MacroMetadata.for_pod(name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require "cocoapods-spm/helpers/io"
+require "cocoapods-spm/macro/metadata"
+require_relative "config"
+
+module Pod
+  module SPM
+    class MacroFetcher
+      include MacroConfigMixin
+
+      attr_reader :name
+
+      def initialize(options = {})
+        @name = options[:name]
+        @specs_by_platform = options[:specs_by_platform]
+        @can_cache = options[:can_cache]
+        @podfile = Pod::Config.instance.podfile
+      end
+
+      def run
+        prepare_macro_source
+        macro_dir = spm_config.macro_root_dir / name
+        macro_downloaded_dir = spm_config.macro_downloaded_root_dir / name
+        FileUtils.copy_entry(
+          macro_downloaded_dir / "Sources" / name,
+          macro_dir / "Sources" / name
+        )
+        generate_metadata
+      end
+
+      private
+
+      def local?
+        local_macro_pod?(name)
+      end
+
+      def generate_metadata
+        raise "Package.swift not exist in #{macro_downloaded_dir}" \
+          unless (macro_downloaded_dir / "Package.swift").exist?
+
+        raw = Dir.chdir(macro_downloaded_dir) { `swift package dump-package` }
+        metadata_path.write(raw)
+      end
+
+      def prepare_macro_source
+        if local?
+          symlink_local_macro_source
+        else
+          download_macro_source
+        end
+      end
+
+      def symlink_local_macro_source
+        UI.message "Creating symlink to local macro source: #{name}..."
+        # For local macro pod, just need to copy local pod dir to downloaded sandbox,
+        # or create a symlink .spm.pods/macros/.downloaded/FOO -> LocalPods/FOO
+        IOUtils.symlink(local_macro_pod_dir(name), macro_downloaded_dir)
+      end
+
+      def download_macro_source
+        UI.puts "Downloading source for macro: #{name}...".magenta
+        @specs_by_platform ||= @podfile.root_target_definitions.to_h do |definition|
+          spec = Pod::Spec.from_file(spm_config.macro_root_dir / name / "#{name}.podspec")
+          [definition.platform, [spec]]
+        end
+
+        # When `can_cache` is true, PodSourceDownloader only keeps the contents
+        # according to its `source_files` declared in the podspec.
+        # However, we wish to keep all contents (including Package.swift...).
+        # --> We alter the spec when downloading the source.
+        altered_specs_by_platform = @specs_by_platform.to_h do |platform, specs|
+          altered_specs = specs.map do |spec|
+            spec.with { |s| s.source_files = "**/*" }
+          end
+          [platform, altered_specs]
+        end
+        downloader = Pod::Installer::PodSourceDownloader.new(
+          spm_config.macro_downloaded_sandbox,
+          @podfile,
+          altered_specs_by_platform,
+          can_cache: @can_cache
+        )
+        downloader.download!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require "cocoapods-spm/swift/package/description"
+
+module Pod
+  module SPM
+    class MacroMetadata < Swift::PackageDescription
+      def self.for_pod(name)
+        path = Config.instance.macro_root_dir / name / "metadata.json"
+        unless path.exist?
+          UI.message "Will fetch macro #{name} because its metadata does not exist at #{path}"
+          require "cocoapods-spm/macro/fetcher"
+          MacroFetcher.new(name: name, can_cache: true).run
+        end
+        from_file(path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "cocoapods-spm/def/spec"
+require "cocoapods-spm/macro/fetcher"
+require "cocoapods-spm/macro/prebuilder"
+
+module Pod
+  class Installer
+    class MacroPodInstaller < PodSourceInstaller
+      include SPM::Config::Mixin
+
+      def install!
+        install_macro_pod!
+        super
+      end
+
+      private
+
+      def fetcher
+        @fetcher ||= SPM::MacroFetcher.new(
+          name: name,
+          specs_by_platform: specs_by_platform,
+          can_cache: can_cache?
+        )
+      end
+
+      def prebuilder
+        @prebuilder ||= SPM::MacroPrebuilder.new(name: name)
+      end
+
+      def install_macro_pod!
+        fetcher.run if local_macro_pod?(name) || !fetcher.metadata_path.exist?
+        prebuilder.run
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require "cocoapods-spm/macro/metadata"
+require_relative "config"
+
+module Pod
+  module SPM
+    class MacroPrebuilder
+      include MacroConfigMixin
+      include Executables
+
+      attr_reader :name
+
+      def initialize(options = {})
+        @name = options[:name]
+      end
+
+      def run
+        prebuild_macro_impl
+      end
+
+      def prebuild_macro_impl
+        return if spm_config.dont_prebuild_macros?
+
+        config = spm_config.macro_config
+        impl_module_name = metadata.macro_impl_name
+        prebuilt_binary = macro_prebuilt_dir / "#{impl_module_name}-#{config}"
+        if spm_config.dont_prebuild_macros_if_exist? && prebuilt_binary.exist?
+          return UI.message "Macro binary exists at #{prebuilt_binary} -> Skip prebuilding macro"
+        end
+
+        UI.section "Building macro implementation: #{impl_module_name} (#{config})...".green do
+          Dir.chdir(macro_downloaded_dir) do
+            swift! ["--version"]
+            swift! ["build", "-c", config, "--product", impl_module_name]
+          end
+        end
+
+        prebuilt_binary.parent.mkpath
+        macro_downloaded_build_config_dir = macro_downloaded_dir / ".build" / config
+        macro_build_binary_file_path = macro_downloaded_build_config_dir / impl_module_name
+        unless macro_build_binary_file_path.exist?
+          macro_build_binary_file_path = macro_downloaded_build_config_dir / "#{impl_module_name}-tool"
+        end
+        FileUtils.copy_entry(
+          macro_build_binary_file_path,
+          prebuilt_binary
+        )
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/main.rb

@@ -0,0 +1,13 @@
+require "pry" if ENV["COCOAPODS_IMPORT_PRY"] == "true"
+require "cocoapods-spm/compatibility/all"
+require "cocoapods-spm/helpers/io"
+require "cocoapods-spm/helpers/patch"
+require "cocoapods-spm/config"
+require "cocoapods-spm/executables"
+require "cocoapods-spm/def/installer"
+require "cocoapods-spm/def/target_definition"
+require "cocoapods-spm/def/podfile"
+require "cocoapods-spm/def/spec"
+require "cocoapods-spm/patch/aggregate_target"
+require "cocoapods-spm/patch/installer"
+require "cocoapods-spm/command/spm"

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

@@ -0,0 +1,25 @@
+require "cocoapods-spm/helpers/patch"
+
+module Pod
+  class AggregateTarget
+    include Mixin::PatchingBehavior
+
+    private
+
+    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_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