cocoapods-spm 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88926a40ad19c2ccc3b9ceccefe301a6f939ec7460c719b914a13eba5c1d3739
-  data.tar.gz: 190363f1092af74595af470f7bdc617e8ffaca00314894b136298a9c31e9d979
+  metadata.gz: 4a5eda6a0153888c9f65ee3e325c3dfc4c09aa2de0d8021556da54b3f1ea0d43
+  data.tar.gz: 3d37731a7d09ddc7cfb4064d47a0fa82ad7bc83fd30b7175a66485a8f7f35db0
 SHA512:
-  metadata.gz: '06209d7e15bdbccf151db058e53dc27dfb9179d75ed76c6341518f5f56f02d62629ae2f0a369cdace8e719725a040aee2a24d626b709f280c15b18277f2ca636'
-  data.tar.gz: c40d20e4560c12625ac7a4a52c6bbcee54407582039ac59f829f75978c29581379f24514e489fa6f393ef8872a131ce7608969b193927cabca7dfc2f06a0db35
+  metadata.gz: 3cfb06f8423f4bfe9ff580aebb49a0417d7d2bd0cc3146114f4b3f40c11c8ed2ced93469d7482a6442f0acd396083256018ca6a8b8b9c0cbb8ffa657e01ad586
+  data.tar.gz: 0111ab82c0ce14ff7a17831450d1710bbd583738a73f037ed09c9b822160a521c1d7f4d05a1587ffe3550836d165595f4c5bbe6372aa1c80ce6eda8e759aa245

data/lib/cocoapods-spm/command/fetch.rb

@@ -0,0 +1,31 @@
+require "cocoapods-spm/macro/fetcher"
+
+module Pod
+  class Command
+    class Spm < Command
+      class Fetch < Spm
+        self.summary = "Fetch macros"
+        def self.options
+          [
+            ["--all", "Prebuild all macros"],
+            ["--macros=foo", "Macros to prebuild, separated by comma (,)"],
+          ].concat(super)
+        end
+
+        def initialize(argv)
+          super
+          update_cli_config(
+            all: argv.flag?("all"),
+            macros: argv.option("macros", "").split(",")
+          )
+        end
+
+        def run
+          spm_config.macros.each do |name|
+            SPM::MacroFetcher.new(name: name, can_cache: true).run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/command/prebuild.rb

@@ -0,0 +1,35 @@
+require "cocoapods-spm/macro/prebuilder"
+
+module Pod
+  class Command
+    class Spm < Command
+      class Prebuild < Spm
+        self.summary = "Prebuild macros"
+        def self.options
+          [
+            ["--all", "Prebuild all macros"],
+            ["--macros=foo", "Macros to prebuild, separated by comma (,)"],
+            ["--config=foo", "Config (debug/release) to prebuild macros"],
+          ].concat(super)
+        end
+
+        def initialize(argv)
+          super
+          update_cli_config(
+            all: argv.flag?("all"),
+            macros: argv.option("macros", "").split(","),
+            config: argv.option("config"),
+            dont_prebuild_macros: false,
+            dont_prebuild_macros_if_exist: false
+          )
+        end
+
+        def run
+          spm_config.macros.each do |name|
+            SPM::MacroPrebuilder.new(name: name).run
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require "cocoapods-spm/command/prebuild"
+require "cocoapods-spm/command/fetch"
+
+module Pod
+  class Command
+    class Spm < Command
+      include SPM::Config::Mixin
+
+      self.summary = "Working with SPM"
+      self.abstract_command = true
+
+      def update_cli_config(options)
+        spm_config.cli_config.merge!(options)
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/config.rb

@@ -1,15 +1,65 @@
 module Pod
   module SPM
     class Config
-      attr_accessor :dsl_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 = {}
+        @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)
+      end
     end
   end
 end

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

@@ -0,0 +1,55 @@
+require "cocoapods-spm/config"
+
+module Pod
+  class Podfile
+    module DSL
+      alias origin_pod pod
+      def config_cocoapods_spm(options)
+        SPM::Config.instance.dsl_config = options
+      end
+
+      def macro_pods
+        @macro_pods ||= {}
+      end
+
+      def pod(name = nil, *requirements)
+        macro = requirements[0].delete(:macro) if requirements.first.is_a?(Hash)
+        macro ||= {}
+        unless macro.empty?
+          requirements[0][:path] = prepare_macro_pod_dir(name, macro)
+          macro_pods[name] = macro
+        end
+        origin_pod(name, *requirements)
+      end
+
+      def spm_pkg(name, options)
+        current_target_definition.store_spm_pkg(name, options)
+      end
+
+      private
+
+      def prepare_macro_pod_dir(name, requirement)
+        link = requirement[:git]
+        podspec_content = <<~HEREDOC
+          Pod::Spec.new do |s|
+            s.name = "#{name}"
+            s.version = "0.0.1"
+            s.summary = "#{name}"
+            s.description = "#{name}"
+            s.homepage = "#{link}"
+            s.license = "MIT"
+            s.authors = "dummy@gmail.com"
+            s.source = #{requirement}
+            s.source_files = "Sources/**/*"
+          end
+        HEREDOC
+
+        path = Pathname(".spm.pods/#{name}")
+        (path / ".prebuilt").mkpath
+        (path / "Sources").mkpath
+        (path / "#{name}.podspec").write(podspec_content)
+        path
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "cocoapods-spm/config"
+require "cocoapods-spm/def/spm_dependency"
+
+module Pod
+  class Specification
+    def spm_dependencies
+      @spm_dependencies ||= []
+    end
+
+    def spm_dependency(name, options = {})
+      spm_dependencies << SPM::Dependency.new(name, options)
+    end
+
+    def with
+      spec = Pod::Spec.new(
+        parent,
+        name,
+        test_specification,
+        app_specification: app_specification
+      )
+      spec.attributes_hash = attributes_hash.dup
+      yield spec if block_given?
+      spec
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Pod
+  module SPM
+    class Dependency
+      attr_reader :name, :product
+      attr_accessor :pkg
+
+      def initialize(name, options = {}, product: nil, pkg: nil)
+        cmps = name.split("/")
+        raise "Invalid dependency `#{name}`" if cmps.count > 2
+
+        @name = cmps.first
+        @product = product || cmps.last
+        @options = options
+        @pkg = pkg
+      end
+
+      def inspect
+        "#<#{self.class} name=#{name} product=#{product} pkg=#{pkg}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require "cocoapods-spm/def/xcodeproj"
+require "cocoapods-spm/def/spm_dependency"
+
+module Pod
+  module SPM
+    class Package
+      attr_reader :name, :requirement, :url, :relative_path
+
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+        @requirement = requirement_from(options)
+        @url = options[:url]
+        @relative_path = options[:relative_path]
+      end
+
+      def inspect
+        "#<#{self.class} name=#{name}>"
+      end
+
+      def local?
+        @relative_path != nil
+      end
+
+      def to_dependencies
+        if (products = @options[:products])
+          products.map { |product| Dependency.new(@name, product: product, pkg: self) }
+        else
+          [Dependency.new(@name, pkg: self)]
+        end
+      end
+
+      def create_pkg_ref(project)
+        cls = local? ? Object::XCLocalSwiftPackageReference : Object::XCRemoteSwiftPackageReference
+        ref = project.new(cls)
+        ref.name = name
+        if local?
+          ref.relative_path = relative_path
+        else
+          ref.repositoryURL = url
+          ref.requirement = requirement
+        end
+        ref
+      end
+
+      private
+
+      def requirement_from(options)
+        if options[:requirement]
+          options[:requirement]
+        elsif (version = options.delete(:version))
+          { :kind => "exactVersion", :version => version }
+        elsif (branch = options.delete(:branch))
+          { :kind => "branch", :branch => branch }
+        elsif (revision = options.delete(:commit))
+          { :kind => "revision", :revision => revision }
+        elsif options[:relative_path]
+          nil
+        else
+          raise "Missing requirement for SPM package: #{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require "cocoapods-spm/def/spm_package"
+
+module Pod
+  class Podfile
+    class TargetDefinition
+      def store_spm_pkg(name, options)
+        spm_pkgs << SPM::Package.new(name, options)
+      end
+
+      def spm_pkgs
+        @spm_pkgs ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "xcodeproj"
+
+module Pod
+  module SPM
+    module Object
+      module PackageReferenceMixin
+        attr_accessor :name
+
+        def create_pkg_product_dependency_ref(product)
+          ref = project.new(BaseObject::XCSwiftPackageProductDependency)
+          ref.package = self
+          ref.product_name = product
+          ref
+        end
+      end
+
+      BaseObject = Xcodeproj::Project::Object
+
+      class XCRemoteSwiftPackageReference < BaseObject::XCRemoteSwiftPackageReference
+        include PackageReferenceMixin
+      end
+
+      class XCLocalSwiftPackageReference < BaseObject::XCLocalSwiftPackageReference
+        include PackageReferenceMixin
+      end
+
+      class XCSwiftPackageProductDependency < BaseObject::XCSwiftPackageProductDependency
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+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_analyzer = options[:spm_analyzer]
+        @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 user_build_configurations
+        @user_build_configurations ||= (pod_targets + aggregate_targets)[0].user_build_configurations
+      end
+
+      def config
+        Config.instance
+      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, ".*")
+          cls_name = "Pod::SPM::Hook::#{id.camelize}"
+          UI.message "Running hook: #{cls_name}"
+          cls_name.constantize.new(context, options).run
+        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)
+        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/post_integrate/add_spm_pkgs.rb

@@ -0,0 +1,50 @@
+require "cocoapods-spm/hooks/base"
+require "cocoapods-spm/installer/analyzer"
+
+module Pod
+  module SPM
+    class Hook
+      class AddSpmPkgs < Hook
+        def run
+          return unless @spm_analyzer.spm_pkgs
+
+          add_spm_pkg_refs_to_project
+          add_spm_products_to_targets
+          pods_project.save
+        end
+
+        private
+
+        def spm_pkg_refs
+          @spm_pkg_refs ||= {}
+        end
+
+        def add_spm_pkg_refs_to_project
+          @spm_pkg_refs = @spm_analyzer.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]
+          end
+        end
+
+        def spm_pkgs_by_target
+          @spm_pkgs_by_target ||= {}
+        end
+
+        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|
+              pkg_ref = spm_pkg_refs[dep.pkg.name]
+              product_ref = pkg_ref.create_pkg_product_dependency_ref(dep.product)
+              target.package_product_dependencies << product_ref
+            end
+          end
+        end
+
+        def podfile
+          Pod::Config.instance.podfile
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/hooks/pre_integrate/update_settings.rb

@@ -0,0 +1,71 @@
+require "cocoapods-spm/hooks/base"
+require "cocoapods-spm/metadata"
+
+module Pod
+  module SPM
+    class Hook
+      class UpdateSettings < Hook
+        def run
+          update_other_swift_flags
+          update_swift_include_paths
+          update_linker_flags
+        end
+
+        private
+
+        def other_swift_flags_by_config
+          @other_swift_flags_by_config ||= begin
+            hash = user_build_configurations.keys.to_h do |config|
+              flags = macro_pods.keys.map do |name|
+                metadata = Metadata.for_pod(name)
+                impl_module_name = metadata.macro_impl_name
+                plugin_executable_path =
+                  "${PODS_ROOT}/../.spm.pods/#{name}/.prebuilt/#{config.to_s.downcase}/" \
+                  "#{impl_module_name}##{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_other_swift_flags
+          return unless spm_config.macros
+
+          # For prebuilt macros
+          perform_settings_update(
+            update_targets: lambda do |_, _, config|
+              { "OTHER_SWIFT_FLAGS" => other_swift_flags_by_config[config] }
+            end
+          )
+        end
+
+        def update_linker_flags
+          return unless @spm_analyzer.spm_pkgs
+
+          # For packages to work in the main target
+          perform_settings_update(
+            update_aggregate_targets: lambda do |target, _, _|
+              spm_deps = @spm_analyzer.spm_dependencies_by_target[target.to_s].to_a
+              flags = spm_deps.map { |d| "-l\"#{d.product}.o\"" }
+              { "OTHER_LDFLAGS" => flags }
+            end
+          )
+        end
+
+        def update_swift_include_paths
+          return unless @spm_analyzer.spm_pkgs
+
+          # For macro packages
+          perform_settings_update(
+            update_targets: lambda do |_, _, _|
+              { "SWIFT_INCLUDE_PATHS" => "${SYMROOT}/${CONFIGURATION}${EFFECTIVE_PLATFORM_NAME}" }
+            end
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Pod
+  class Installer
+    class SPMAnalyzer
+      attr_reader :spm_pkgs, :spm_dependencies_by_target
+
+      def initialize(podfile, umbrella_targets)
+        @podfile = podfile
+        @umbrella_targets = umbrella_targets
+        @spm_pkgs = []
+        @spm_dependencies_by_target = {}
+      end
+
+      def analyze
+        analyze_spm_pkgs
+        analyze_spm_dependencies_by_target
+      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_umbrella_targets
+        @spm_dependencies_by_target.values.flatten.each { |d| d.pkg = spm_pkg_for(d.name) }
+      end
+
+      def analyze_dependencies_for_targets
+        specs = @umbrella_targets.flat_map(&:specs).uniq
+        specs.each do |spec|
+          @spm_dependencies_by_target[spec.name] = spec.spm_dependencies
+        end
+      end
+
+      def analyze_dependencies_for_umbrella_targets
+        @umbrella_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
+
+        common_spm_pkgs = @podfile.root_target_definitions.flat_map(&:spm_pkgs)
+        @podfile.target_definition_list.reject(&:abstract?).each do |target|
+          existing = @spm_dependencies_by_target[target.label].to_a
+          spm_dependencies = (common_spm_pkgs + target.spm_pkgs).flat_map(&:to_dependencies)
+          @spm_dependencies_by_target[target.label] = 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
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Pod
+  module SPM
+    class MacroFetcher
+      include Config::Mixin
+
+      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
+        download_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
+        )
+      end
+
+      def download_macro_source
+        @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/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
+        prebuilder.run
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require "cocoapods-spm/metadata"
+
+module Pod
+  module SPM
+    class MacroPrebuilder
+      include Config::Mixin
+
+      attr_reader :name
+
+      def initialize(options = {})
+        @name = options[:name]
+      end
+
+      def run
+        generate_metadata
+        prebuild_macro_impl
+      end
+
+      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
+        macro_dir / ".prebuilt"
+      end
+
+      def metadata_path
+        macro_dir / "metadata.json"
+      end
+
+      def generate_metadata
+        raise "Package.swift not exist in #{macro_downloaded_dir}" \
+          unless (macro_downloaded_dir / "Package.swift").exist?
+
+        cmd =
+          "cd #{macro_downloaded_dir} " \
+          "&& swift package dump-package " \
+          "> #{metadata_path.relative_path_from(macro_downloaded_dir)}"
+        `#{cmd}`
+        @metadata = Metadata.from_file(metadata_path)
+      end
+
+      def prebuild_macro_impl
+        return if spm_config.dont_prebuild_macros?
+
+        config = spm_config.macro_config
+        impl_module_name = @metadata.macro_impl_name
+        return if spm_config.dont_prebuild_macros_if_exist? && (macro_prebuilt_dir / config / impl_module_name).exist?
+
+        UI.puts "Building macro implementation: #{impl_module_name} (#{config})...".green
+        `cd #{macro_downloaded_dir} && swift build -c #{config}`
+        (macro_prebuilt_dir / config).mkpath
+        FileUtils.copy_entry(
+          macro_downloaded_dir / ".build" / config / impl_module_name,
+          macro_prebuilt_dir / config / impl_module_name
+        )
+      end
+    end
+  end
+end

data/lib/cocoapods-spm/main.rb

@@ -1,78 +1,5 @@
-require "cocoapods-spm/config"
-require "cocoapods-spm/dsl"
-require "cocoapods-spm/specification"
-
-module Pod
-  module SPM
-    class Hook
-      def initialize(context)
-        @context = context
-      end
-
-      def sandbox
-        @context.sandbox
-      end
-
-      def pods_project
-        @context.pods_project
-      end
-
-      def config
-        Config.instance
-      end
-
-      def all_specs
-        @all_specs ||= @context.umbrella_targets.flat_map(&:specs).uniq
-      end
-
-      def run
-        all_specs.each do |spec|
-          if spec.spm_dependencies
-            target = pods_project.targets.find { |t| t.name == spec.name }
-            add_spm_dependencies(target, spec.spm_dependencies)
-          end
-        end
-        update_import_paths
-        pods_project.save
-      end
-
-      private
-
-      def add_spm_dependencies(target, dependencies)
-        dependencies.each do |data|
-          pkg = pkg_from_data(data)
-          data[:products].each do |product|
-            ref = pods_project.new(Xcodeproj::Project::Object::XCSwiftPackageProductDependency)
-            ref.package = pkg
-            ref.product_name = product
-            target.package_product_dependencies << ref
-          end
-          pods_project.root_object.package_references << pkg
-        end
-      end
-
-      def update_import_paths
-        # Workaround: Currently, update the swift import paths of the base/Pods project
-        # to make it effective across all pod targets
-        pods_project.build_configurations.each do |config|
-          to_add = '${SYMROOT}/${CONFIGURATION}${EFFECTIVE_PLATFORM_NAME}'
-          import_paths = config.build_settings['SWIFT_INCLUDE_PATHS'] || ['$(inherited)']
-          import_paths << to_add unless import_paths.include?(to_add)
-          config.build_settings['SWIFT_INCLUDE_PATHS'] = import_paths
-        end
-      end
-
-      def pkg_from_data(data)
-        if data[:requirement]
-          pkg = pods_project.new(Xcodeproj::Project::Object::XCRemoteSwiftPackageReference)
-          pkg.repositoryURL = data[:url]
-          pkg.requirement = data[:requirement]
-        else
-          pkg = pods_project.new(Xcodeproj::Project::Object::XCLocalSwiftPackageReference)
-          pkg.relative_path = data[:relative_path]
-        end
-        pkg
-      end
-    end
-  end
-end
+require "cocoapods-spm/def/target_definition"
+require "cocoapods-spm/def/podfile"
+require "cocoapods-spm/def/spec"
+require "cocoapods-spm/patch/installer"
+require "cocoapods-spm/command/spm"

data/lib/cocoapods-spm/metadata.rb

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

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

@@ -0,0 +1,63 @@
+require "cocoapods-spm/installer/analyzer"
+require "cocoapods-spm/macro/pod_installer"
+require "cocoapods-spm/hooks/base"
+
+module Pod
+  class Installer
+    include SPM::Config::Mixin
+
+    alias origin_resolve_dependencies resolve_dependencies
+    def resolve_dependencies
+      origin_resolve_dependencies
+      resolve_spm_dependencies
+    end
+
+    alias origin_create_pod_installer create_pod_installer
+    def create_pod_installer(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
+
+    alias origin_integrate integrate
+    def integrate
+      run_spm_pre_integrate_hooks
+      origin_integrate
+      run_spm_post_integrate_hooks
+    end
+
+    private
+
+    def hook_options
+      {
+        :spm_analyzer => @spm_analyzer,
+        :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
+      # TODO: convert aggregate_targets to umbrella_targets?
+      @spm_analyzer ||= Pod::Installer::SPMAnalyzer.new(podfile, aggregate_targets)
+      @spm_analyzer.analyze
+    end
+  end
+end

data/lib/cocoapods_plugin.rb

@@ -1,5 +1 @@
 require "cocoapods-spm/main"
-
-Pod::HooksManager.register("cocoapods-spm", :post_install) do |context|
-  Pod::SPM::Hook.new(context).run
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-spm
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Thuyen Trinh
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-28 00:00:00.000000000 Z
+date: 2023-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -60,16 +60,32 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cocoapods-spm.rb
+- lib/cocoapods-spm/command/fetch.rb
+- lib/cocoapods-spm/command/prebuild.rb
+- lib/cocoapods-spm/command/spm.rb
 - lib/cocoapods-spm/config.rb
-- lib/cocoapods-spm/dsl.rb
+- lib/cocoapods-spm/def/podfile.rb
+- lib/cocoapods-spm/def/spec.rb
+- lib/cocoapods-spm/def/spm_dependency.rb
+- lib/cocoapods-spm/def/spm_package.rb
+- lib/cocoapods-spm/def/target_definition.rb
+- lib/cocoapods-spm/def/xcodeproj.rb
+- lib/cocoapods-spm/hooks/base.rb
+- lib/cocoapods-spm/hooks/post_integrate/add_spm_pkgs.rb
+- lib/cocoapods-spm/hooks/pre_integrate/update_settings.rb
+- lib/cocoapods-spm/installer/analyzer.rb
+- lib/cocoapods-spm/macro/fetcher.rb
+- lib/cocoapods-spm/macro/pod_installer.rb
+- lib/cocoapods-spm/macro/prebuilder.rb
 - lib/cocoapods-spm/main.rb
-- lib/cocoapods-spm/specification.rb
+- lib/cocoapods-spm/metadata.rb
+- lib/cocoapods-spm/patch/installer.rb
 - lib/cocoapods_plugin.rb
 homepage: https://github.com/trinhngocthuyen/cocoapods-spm
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -84,8 +100,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: CocoaPods plugin to add SPM dependencies to CocoaPods targets
 test_files: []

data/lib/cocoapods-spm/dsl.rb

@@ -1,11 +0,0 @@
-require "cocoapods-spm/config"
-
-module Pod
-  class Podfile
-    module DSL
-      def config_xcconfig_hooks(options)
-        Pod::SPM::Config.instance.dsl_config = options
-      end
-    end
-  end
-end

data/lib/cocoapods-spm/specification.rb

@@ -1,10 +0,0 @@
-module Pod
-  class Specification
-    attr_reader :spm_dependencies
-
-    def spm_dependency(options)
-      @spm_dependencies ||= []
-      @spm_dependencies << options
-    end
-  end
-end