xcode-archive-cache 0.0.9 → 0.0.11

data/lib/injection/pods_script_fixer.rb

@@ -44,7 +44,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,25 +53,7 @@ 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

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::Container] build_settings
+      #
+      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,18 +23,42 @@ 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)
         end
 
         file_paths.each do |file_path|
-          FileUtils.cp(file_path, File.join(storage_path, File.basename(file_path)))
+          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
+      # @param [Array<String>] file_paths
+      #
+      def store_default_headers(node, file_paths)
+        store_headers(node, get_default_headers_storage_path(node), file_paths)
+      end
+
+      def store_modulemap_headers(node, file_paths)
+        store_headers(node, get_storage_path(node), file_paths, false)
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # @return [String]
+      #
+      def get_modulemap_path(node)
+        modulemap_file_name = node.resulting_modulemap_file_name
+        return if modulemap_file_name == nil
+
+        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
 
       # @param [XcodeArchiveCache::BuildGraph::Node] node
@@ -70,7 +94,7 @@ module XcodeArchiveCache
 
       # @param [XcodeArchiveCache::BuildGraph::Node] node
       #
-      # @return [Array<String>]
+      # @return [String]
       #
       def get_headers_storage_paths(node)
         headers_storage_dir_paths[node.name]
@@ -78,11 +102,19 @@ module XcodeArchiveCache
 
       def get_all_headers_storage_paths
         headers_storage_dir_paths
-            .map {|_, path| path}
+            .map { |_, path| path }
             .flatten
             .uniq
       end
 
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # @return [String]
+      #
+      def get_default_headers_storage_path(node)
+        "include/#{node.name}"
+      end
+
       private
 
       def prepare_container_dir
@@ -99,6 +131,15 @@ module XcodeArchiveCache
         File.absolute_path(path, container_dir_path)
       end
 
+      # @param [String] storage_path
+      # @param [String] file_path
+      #
+      # @return [String]
+      #
+      def get_stored_file_path(storage_path, file_path)
+        File.join(storage_path, File.basename(file_path))
+      end
+
       # @param [String] path
       # @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,45 +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|
-        handle_dependency(target, 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|
+        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)
-
-      evaluate_for_rebuild(graph)
-      unpack_cached_artifacts(graph)
-      rebuild_if_needed(xcodebuild_executor, dependency_target, graph)
-      @injector.perform_outgoing_injection(graph, target)
-    end
-
-    # @param [XcodeArchiveCache::BuildGraph::Graph] graph
-    #
-    def evaluate_for_rebuild(graph)
-      graph.nodes.each do |node|
-        @rebuild_evaluator.evaluate(node)
-      end
+      dependency_target
     end
 
     # @param [XcodeArchiveCache::BuildGraph::Graph] graph