xcode-archive-cache 0.0.10.pre.1 → 0.0.12

data/lib/injection/pods_script_fixer.rb

@@ -4,36 +4,41 @@ module XcodeArchiveCache
 
       include XcodeArchiveCache::Logs
 
-      def initialize
+      # @param [XcodeArchiveCache::Injection::Storage] storage
+      #
+      def initialize(storage)
+        @storage = storage
         @build_settings_interpolator = XcodeArchiveCache::BuildSettings::StringInterpolator.new
       end
 
       # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
       # @param [XcodeArchiveCache::BuildGraph::Graph] graph
-      # @param [String] products_dir
       #
-      def fix_embed_frameworks_script(target, graph, products_dir)
+      def fix_embed_frameworks_script(target, graph)
         build_settings = graph.dependent_build_settings
         file_path = find_embed_frameworks_script(target, build_settings)
         return unless file_path
 
-        fix_script(file_path, graph, products_dir)
+        fix_script(file_path, graph)
       end
 
       # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
       # @param [XcodeArchiveCache::BuildGraph::Graph] graph
-      # @param [String] products_dir
       #
-      def fix_copy_resources_script(target, graph, products_dir)
+      def fix_copy_resources_script(target, graph)
         build_settings = graph.dependent_build_settings
         file_path = find_copy_resources_script(target, build_settings)
         return unless file_path
 
-        fix_script(file_path, graph, products_dir)
+        fix_script(file_path, graph)
       end
 
       private
 
+      # @return [XcodeArchiveCache::Injection::Storage]
+      #
+      attr_reader :storage
+
       # @return [XcodeArchiveCache::BuildSettings::StringInterpolator]
       #
       attr_reader :build_settings_interpolator
@@ -44,7 +49,7 @@ module XcodeArchiveCache
       # @return [String]
       #
       def find_embed_frameworks_script(target, build_settings)
-        find_script(target, build_settings, "[CP] Embed Pods Frameworks")
+        target.find_script(build_settings_interpolator, build_settings, "[CP] Embed Pods Frameworks")
       end
 
       # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
@@ -53,38 +58,18 @@ module XcodeArchiveCache
       # @return [String]
       #
       def find_copy_resources_script(target, build_settings)
-        find_script(target, build_settings, "[CP] Copy Pods Resources")
-      end
-
-      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
-      # @param [XcodeArchiveCache::BuildSettings::Container] build_settings
-      # @param [String] script_name
-      #
-      # @return [String]
-      #
-      def find_script(target, build_settings, script_name)
-        target.shell_script_build_phases.each do |phase|
-          if phase.display_name == script_name
-            return build_settings_interpolator.interpolate(phase.shell_script, build_settings)
-                       .gsub(/^"|"$/, "")
-                       .strip
-          end
-        end
-
-        nil
+        target.find_script(build_settings_interpolator, build_settings, "[CP] Copy Pods Resources")
       end
 
       # @param [String] file_path
-      # @param [XcodeArchiveCache::BuildGraph::Node] graph
-      # @param [String] products_dir
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
       #
-      def fix_script(file_path, graph, products_dir)
+      def fix_script(file_path, graph)
         info("fixing #{file_path}")
         script = File.read(file_path)
         graph.nodes.each do |node|
-          relative_product_path = "#{node.native_target.display_name}/#{node.product_file_name}"
-          absolute_product_path = File.join(products_dir, relative_product_path)
-          script = script.gsub(Regexp.new("\"[^\"]+\/#{node.product_file_name}\""), "\"#{absolute_product_path}\"")
+          product_path = File.join(storage.get_storage_path(node), node.product_file_name)
+          script = script.gsub(Regexp.new("\"[^\"]+\/#{node.product_file_name}\""), "\"#{product_path}\"")
         end
 
         File.open(file_path, "w") {|file| file.puts(script)}

data/lib/injection/pods_xcframework_fixer.rb

@@ -0,0 +1,126 @@
+module XcodeArchiveCache
+  module Injection
+    class PodsXCFrameworkFixer
+
+      include XcodeArchiveCache::Logs
+
+      # @param [XcodeArchiveCache::Injection::Storage] storage
+      # @param [XcodeArchive::BuildGraph::NativeTargetFinder] native_target_finder
+      # @param [String] configuration_name
+      #
+      def initialize(storage, native_target_finder, configuration_name)
+        @storage = storage
+        @native_target_finder = native_target_finder
+        @configuration_name = configuration_name
+        @shell_executor = XcodeArchiveCache::Shell::Executor.new
+        @build_settings_interpolator = XcodeArchiveCache::BuildSettings::StringInterpolator.new
+        @checked_targets = []
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXAbstractTarget] target
+      # @param [XcodeArchiveCache::BuildSettings::Loader] build_settings_loader
+      #
+      def fix(target, build_settings_loader)
+        checked_targets.push(target.equatable_identifier)
+        build_settings = build_settings_loader.get_settings(target.project.path, target.display_name)
+
+        debug("fixing #{target.display_name}")
+        script_path = find_copy_xcframeworks_script(target, build_settings)
+        if script_path != nil
+          fix_file(script_path)
+          
+          unless shell_executor.execute_with_env(script_path, build_settings.all)
+            raise XcodeArchiveCache::Informative, "Failed to execute Pods XCFramework script #{script_path}"
+          end
+        end
+
+        embed_frameworks_script_path = find_embed_frameworks_script(target, build_settings)
+        if embed_frameworks_script_path != nil
+          fix_file(embed_frameworks_script_path)
+        end
+
+        build_configuration = target.find_build_configuration(configuration_name)
+        if build_configuration.has_xcconfig?
+          fix_xcconfig_recursively(build_configuration.get_xcconfig_path, build_configuration.get_project_dir)
+        end
+
+        dependencies = native_target_finder.find_all_dependencies(target)
+        dependencies.each do |dependency_target|
+          if checked_targets.include?(dependency_target.equatable_identifier)
+            next
+          end
+
+          fix(dependency_target, build_settings_loader)
+        end
+      end
+
+      private
+
+      # @return [XcodeArchive::Injection::InjectionStorage]
+      #
+      attr_reader :storage
+
+      # @return [XcodeArchive::BuildGraph::NativeTargetFinder]
+      #
+      attr_reader :native_target_finder
+
+      # @return [String]
+      #
+      attr_reader :configuration_name
+
+      # @return [XcodeArchiveCache::Shell::Executor]
+      #
+      attr_reader :shell_executor
+
+      # @return [XcodeArchiveCache::BuildSettings::StringInterpolator]
+      #
+      attr_reader :build_settings_interpolator
+
+      # @return [Array<String>]
+      #
+      attr_accessor :checked_targets
+
+      # @param [String] path
+      # @param [String] project_dir
+      #
+      def fix_xcconfig_recursively(path, project_dir)
+        fix_file(path)
+        xcconfig = Xcodeproj::Config.new(path)
+
+        xcconfig.includes.each do |included_xcconfig|
+          included_xcconfig_path = File.join(project_dir, included_xcconfig)
+          fix_xcconfig_recursively(included_xcconfig_path, project_dir)
+        end
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXAbstractTarget] target
+      # @param [XcodeArchiveCache::BuildSettings::Container] build_settings
+      #
+      # @return [String]
+      #
+      def find_copy_xcframeworks_script(target, build_settings)
+        target.find_script(build_settings_interpolator, build_settings, "[CP] Copy XCFrameworks")
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXAbstractTarget] target
+      # @param [XcodeArchiveCache::BuildSettings::Container] build_settings
+      #
+      # @return [String]
+      #
+      def find_embed_frameworks_script(target, build_settings)
+        target.find_script(build_settings_interpolator, build_settings, "[CP] Embed Pods Frameworks")
+      end
+
+      # @param [String] file_path
+      #
+      def fix_file(file_path)
+        debug("fixing #{file_path}")
+        contents = File
+          .read(file_path)
+          .gsub("${PODS_XCFRAMEWORKS_BUILD_DIR}", storage.container_dir_path)
+
+        File.open(file_path, "w") {|file| file.puts(contents)}
+      end
+    end
+  end
+end

data/lib/injection/storage.rb

@@ -23,8 +23,8 @@ module XcodeArchiveCache
       # @param [String] path
       # @param [Array<String>] file_paths
       #
-      def store_headers(node, path, file_paths)
-        storage_path = get_full_header_storage_path(path)
+      def store_headers(node, path, file_paths, save_path = true)
+        storage_path = Pathname.new(path).absolute? ? path : get_full_header_storage_path(path)
 
         unless File.exist?(storage_path)
           FileUtils.mkdir_p(storage_path)
@@ -34,7 +34,7 @@ module XcodeArchiveCache
           FileUtils.cp(file_path, get_stored_file_path(storage_path, file_path))
         end
 
-        save_header_storage_path(storage_path, node)
+        save_header_storage_path(storage_path, node) if save_path
       end
 
       # @param [XcodeArchiveCache::BuildGraph::Node] node
@@ -44,13 +44,8 @@ module XcodeArchiveCache
         store_headers(node, get_default_headers_storage_path(node), file_paths)
       end
 
-      # @param [XcodeArchiveCache::BuildGraph::Node] node
-      #
-      def store_modulemap(node)
-        modulemap_file_path = node.modulemap_file_path
-        if modulemap_file_path && File.exist?(modulemap_file_path)
-          store_headers(node, get_default_headers_storage_path(node), [modulemap_file_path])
-        end
+      def store_modulemap_headers(node, file_paths)
+        store_headers(node, get_storage_path(node), file_paths, false)
       end
 
       # @param [XcodeArchiveCache::BuildGraph::Node] node
@@ -58,11 +53,11 @@ module XcodeArchiveCache
       # @return [String]
       #
       def get_modulemap_path(node)
-        modulemap_file_path = node.modulemap_file_path
-        return if modulemap_file_path == nil
+        modulemap_file_name = node.resulting_modulemap_file_name
+        return if modulemap_file_name == nil
 
-        storage_path = get_full_header_storage_path(get_default_headers_storage_path(node))
-        stored_modulemap_file_path = get_stored_file_path(storage_path, modulemap_file_path)
+        storage_path = get_storage_path(node)
+        stored_modulemap_file_path = get_stored_file_path(storage_path, modulemap_file_name)
         File.exist?(stored_modulemap_file_path) ? stored_modulemap_file_path : nil
       end
 
@@ -82,7 +77,7 @@ module XcodeArchiveCache
       def prepare_storage(node)
         path = get_storage_path(node)
         if File.exist?(path)
-          raise StandardError.new, "Injection storage path is already busy"
+          raise StandardError.new, "Injection storage path is already busy: #{path}"
         end
 
         FileUtils.mkdir_p(path)
@@ -94,7 +89,12 @@ module XcodeArchiveCache
       # @return [String]
       #
       def get_storage_path(node)
-        File.join(container_dir_path, node.name)
+        path = File.join(container_dir_path, node.name)
+        if node.native_target
+          path += "-#{node.native_target.uuid}"
+        end
+
+        path
       end
 
       # @param [XcodeArchiveCache::BuildGraph::Node] node

data/lib/modulemap/file_handler.rb

@@ -0,0 +1,20 @@
+module XcodeArchiveCache
+  module Modulemap
+    class FileHandler
+      # @param [String] modulemap_path
+      #
+      # @return [Array<String>]
+      #
+      def read_modulemap_lines(modulemap_path)
+        File.read(modulemap_path).split("\n")
+      end
+
+      # @param [Array<String>] lines
+      # @param [String] modulemap_path
+      #
+      def write_modulemap_lines(lines, modulemap_path)
+        File.open(modulemap_path, "w") { |file| file.puts lines.join("\n") }
+      end
+    end
+  end
+end

data/lib/modulemap/header_path_extractor.rb

@@ -0,0 +1,67 @@
+module XcodeArchiveCache
+  module Modulemap
+    class HeaderPathDeclaration
+      # @return [String]
+      #
+      attr_reader :type
+
+      # @return [String]
+      #
+      attr_reader :path
+
+      # @param [String] type
+      # @param [String] path
+      #
+      def initialize(type, path)
+        @type = type
+        @path = path
+      end
+    end
+
+    class HeaderPathExtractor
+
+      include XcodeArchiveCache::Logs
+
+      # @param [String] modulemap_path
+      #
+      # @return [Array<String>]
+      #
+      def extract_all_paths(modulemap_path)
+        modulemap_dir = File.dirname(modulemap_path)
+        modulemap_lines = FileHandler.new.read_modulemap_lines(modulemap_path)
+        header_paths = []
+
+        modulemap_lines.each do |line|
+          header_declaration = extract_header_declaration(line)
+          if header_declaration
+            header_paths << get_full_header_path(modulemap_dir, header_declaration.path)
+          end
+        end
+
+        debug("modulemap header paths: #{header_paths}")
+
+        header_paths
+      end
+
+      # @param [String] modulemap_dir
+      # @param [String] path
+      #
+      # @return [String]
+      #
+      def get_full_header_path(modulemap_dir, path)
+        Pathname.new(path).absolute? ? path : File.join(modulemap_dir, path)
+      end
+
+      # @param [String] line
+      #
+      # @return [XcodeArchiveCache::Modulemap::HeaderPathDeclaration]
+      #
+      def extract_header_declaration(line)
+        if line.include?("header") && !line.include?("exclude")
+          components = line.split("\"")
+          HeaderPathDeclaration.new(components[0], components[1])
+        end
+      end
+    end
+  end
+end

data/lib/modulemap/header_path_fixer.rb

@@ -0,0 +1,65 @@
+module XcodeArchiveCache
+  module Modulemap
+    class HeaderPathFixer
+
+      include XcodeArchiveCache::Logs
+
+      # @param [Storage] storage
+      #
+      def initialize(storage)
+        @storage = storage
+        @header_path_extractor = HeaderPathExtractor.new
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      def fix_modulemap(node)
+        return unless node.has_static_library_product?
+
+        injected_modulemap_file_path = storage.get_modulemap_path(node)
+        return if injected_modulemap_file_path == nil
+
+        file_handler = FileHandler.new
+
+        modulemap_dir = File.dirname(injected_modulemap_file_path)
+        modulemap_lines = file_handler.read_modulemap_lines(injected_modulemap_file_path)
+
+        updated_lines = modulemap_lines.map do |line|
+          declaration = header_path_extractor.extract_header_declaration(line)
+          next line unless declaration
+
+          # absolute paths depend on machine and derived data dir
+          #
+          full_header_path = header_path_extractor.get_full_header_path(modulemap_dir, declaration.path)
+          should_replace = Pathname.new(declaration.path).absolute? || !File.exist?(full_header_path)
+          next line unless should_replace
+
+          header_file_name = File.basename(declaration.path)
+          injected_header_path = File.join(modulemap_dir, header_file_name)
+          next line if injected_header_path == declaration.path
+
+          if File.exist?(injected_header_path)
+            debug("substituting #{declaration.path} with #{injected_header_path} in #{File.basename(injected_modulemap_file_path)}")
+            "#{declaration.type}\"#{injected_header_path}\""
+          else
+            error("failed to substitute missing header #{declaration.path} with another missing header in #{File.basename(injected_modulemap_file_path)}")
+            error("leaving the path as it is")
+            line
+          end
+        end
+
+        file_handler.write_modulemap_lines(updated_lines, injected_modulemap_file_path)
+      end
+
+      private
+
+      # @return [Storage]
+      #
+      attr_accessor :storage
+
+      # @return [XcodeArchiveCache::Modulemap::HeaderPathExtractor]
+      #
+      attr_accessor :header_path_extractor
+    end
+  end
+end

data/lib/runner/runner.rb

@@ -9,7 +9,7 @@ module XcodeArchiveCache
       @config = config
 
       projects = list_projects
-      @native_target_finder = XcodeArchiveCache::BuildGraph::NativeTargetFinder.new(projects)
+      @native_target_finder = XcodeArchiveCache::BuildGraph::NativeTargetFinder.new(projects, config.active_configuration.build_configuration)
 
       storage_path = File.absolute_path(config.storage.path)
       @cache_storage = XcodeArchiveCache::ArtifactCache::LocalStorage.new(storage_path)
@@ -37,7 +37,7 @@ module XcodeArchiveCache
         return workspace.file_references.map {|file_reference| Xcodeproj::Project.open(file_reference.absolute_path(workspace_dir))}
       end
 
-      raise Informative, "Configuration misses entry point -- must have either a project or a workspace"
+      raise XcodeArchiveCache::Informative, "Configuration misses entry point -- must have either a project or a workspace"
     end
 
     def run
@@ -65,37 +65,56 @@ module XcodeArchiveCache
     def handle_target(target_config)
       target = @native_target_finder.find_for_product_name(target_config.name)
       unless target
-        raise Informative, "Target not found for #{target_config.name}"
+        raise XcodeArchiveCache::Informative, "Target not found for #{target_config.name}"
       end
 
+      xcodebuild_executor = XcodeArchiveCache::Xcodebuild::Executor.new(config.active_configuration.build_configuration,
+                                                                        target.platform_name,
+                                                                        config.settings.destination,
+                                                                        config.active_configuration.action,
+                                                                        config.active_configuration.xcodebuild_args)
+      build_settings_loader = XcodeArchiveCache::BuildSettings::Loader.new(xcodebuild_executor)
+      graph_builder = XcodeArchiveCache::BuildGraph::Builder.new(@native_target_finder, build_settings_loader)
+
+      dependency_targets = Hash.new
+      build_graphs = Hash.new
+
+      target_config.dependencies.each do |dependency_name|
+        info("creating build graph for #{dependency_name}")
+
+        dependency_target = find_dependency_target(target, dependency_name)
+        dependency_targets[dependency_name] = dependency_target
+        build_graphs[dependency_name] = graph_builder.build_graph(target, dependency_target)
+      end
+
+      pods_xcframeworks_fixer = XcodeArchiveCache::Injection::PodsXCFrameworkFixer.new(@injection_storage, @native_target_finder, config.active_configuration.build_configuration)
+      pods_xcframeworks_fixer.fix(target, build_settings_loader)
+
       target_config.dependencies.each do |dependency_name|
-        handle_dependency(target, dependency_name)
+        info("processing #{dependency_name}")
+
+        dependency_target = dependency_targets[dependency_name]
+        build_graph = build_graphs[dependency_name]
+        
+        @rebuild_evaluator.evaluate_build_graph(build_graph)
+        unpack_cached_artifacts(build_graph)
+        rebuild_if_needed(xcodebuild_executor, dependency_target, build_graph)
+        @injector.perform_outgoing_injection(build_graph, target)
       end
     end
 
     # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
     # @param [String] dependency_name
     #
-    def handle_dependency(target, dependency_name)
-      info("checking #{dependency_name}")
-
+    # @return [Xcodeproj::Project::Object::PBXNativeTarget]
+    #
+    def find_dependency_target(target, dependency_name)
       dependency_target = @native_target_finder.find_for_product_name(dependency_name)
       unless dependency_target
-        raise Informative, "Target not found for #{dependency_name} of #{target.display_name}"
+        raise XcodeArchiveCache::Informative, "Target not found for #{dependency_name} of #{target.display_name}"
       end
 
-      xcodebuild_executor = XcodeArchiveCache::Xcodebuild::Executor.new(config.active_configuration.build_configuration,
-                                                                        dependency_target.platform_name,
-                                                                        config.settings.destination,
-                                                                        config.active_configuration.action,
-                                                                        config.active_configuration.xcodebuild_args)
-      graph_builder = XcodeArchiveCache::BuildGraph::Builder.new(@native_target_finder, xcodebuild_executor)
-      graph = graph_builder.build_graph(target, dependency_target)
-
-      @rebuild_evaluator.evaluate_build_graph(graph)
-      unpack_cached_artifacts(graph)
-      rebuild_if_needed(xcodebuild_executor, dependency_target, graph)
-      @injector.perform_outgoing_injection(graph, target)
+      dependency_target
     end
 
     # @param [XcodeArchiveCache::BuildGraph::Graph] graph

data/lib/shell/executor.rb

@@ -12,7 +12,7 @@ module XcodeArchiveCache
         output, status = Open3.capture2e(actual_command)
 
         if status.exitstatus != 0
-          raise Informative, "#{command}\nexecution failed\n#{output}"
+          raise XcodeArchiveCache::Informative, "#{command}\nexecution failed\n#{output}"
         end
 
         output
@@ -31,6 +31,18 @@ module XcodeArchiveCache
         result
       end
 
+      # @param [String] command
+      # @param [Hash] env
+      #
+      # @return [Boolean] true if command succeeded and returned 0, false otherwise
+      #
+      def execute_with_env(command, env)
+        result = system(env, "set -x && '#{command}'")
+
+        return false if result == nil
+        result
+      end
+
       private
 
       # @param [String] command

data/lib/xcode-archive-cache.rb

@@ -40,12 +40,16 @@ require 'build_settings/parser'
 
 require 'injection/injector'
 require 'injection/pods_script_fixer'
-require 'injection/modulemap_fixer'
 require 'injection/build_flags_changer'
 require 'injection/dependency_remover'
 require 'injection/headers_mover'
 require 'injection/storage'
 require 'injection/framework_embedder'
+require 'injection/pods_xcframework_fixer'
+
+require 'modulemap/file_handler'
+require 'modulemap/header_path_extractor'
+require 'modulemap/header_path_fixer'
 
 require 'runner/runner'
 
@@ -53,6 +57,9 @@ require 'shell/executor'
 
 require 'xcodebuild/executor'
 
+require 'extensions/target'
+require 'extensions/build_configuration'
+
 module XcodeArchiveCache
   class Informative < StandardError
     include CLAide::InformativeError

data/lib/xcodebuild/executor.rb

@@ -117,7 +117,7 @@ module XcodeArchiveCache
         #
         inferred_destination = action == ARCHIVE_ACTION ? GENERIC_DESTINATION : destination_by_platform
         if inferred_destination == nil
-          raise Informative, "Destination not set for #{platform} platform"
+          raise XcodeArchiveCache::Informative, "Destination not set for #{platform} platform"
         end
 
         destination_specifier = inferred_destination == GENERIC_DESTINATION ? "generic/platform=#{platform}" : inferred_destination