xcode-archive-cache 0.0.10.pre.2 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de08375420b8d97642ead0ec3ebc63a78f9f2c372347038054f3b66927d7cad4
-  data.tar.gz: 3712950c9e6038a5193a0db108127a5e89cb29edea098929e527346db24d838c
+  metadata.gz: ff86c853bc7b50f265964695cd55edd14821c821f5d27a1f916dcc23ccc1c4b4
+  data.tar.gz: a11e6dd9c98f59526f6f5329aab00acdcc58b5d7e2b65d83b6a1348d647a2323
 SHA512:
-  metadata.gz: 8e6f791d1a84b4835981617e9092e5a24db3beaa6ee3119b351c47ff99cbed1a222c0168659e5b2bc89c3bc999fb57fd47611c0eb6daf601ef50985ef4959469
-  data.tar.gz: 588243bf92bf878d5020296f69252a83bc99eb58da5150237b62881a9e023539f6365e630e191b1f39bfc6681dbfeda87d321ce915459b1f624280e65c6ce3af
+  metadata.gz: a71f194f4af63d93ee4f256977eb98525065599a36f270215c5c0f3a18cb8742957bb8f2e407497a7629f05ba18b9532d093d02b1dec305fcf4f82f815473431
+  data.tar.gz: ba25058d81d37e12594422d9a765d07fb8af192b53fe980ca3b4da3e1eac61f5a0bc69454f406be92094742e7809dbe8f4887d33e48b305c869733e5c581a4d8

data/lib/build/product_extractor.rb

@@ -2,6 +2,8 @@ module XcodeArchiveCache
   module Build
     class ProductExtractor
 
+      include XcodeArchiveCache::Logs
+
       # @param [String] configuration
       # @param [String] derived_data_path
       #
@@ -17,7 +19,9 @@ module XcodeArchiveCache
       #
       def list_product_contents(built_node)
         file_paths = list_products(built_node)
-        file_paths.select { |path| File.exist?(path) }.map { |path| File.realpath(path) }
+        file_paths
+          .select { |path| File.exist?(path) }
+          .map { |path| File.realpath(path) }
       end
 
       private
@@ -83,8 +87,32 @@ module XcodeArchiveCache
         # this one is generated during Swift compilation
         # so we need to cache it as well
         #
-        swift_objc_interface_header_path = built_node.swift_objc_interface_header_path
-        paths << swift_objc_interface_header_path if swift_objc_interface_header_path
+        swift_objc_interface_header_glob = get_swift_objc_interface_header_glob(built_node)
+        swift_objc_interface_header_path = Dir.glob(swift_objc_interface_header_glob).first
+        if swift_objc_interface_header_path
+          debug("using Swift-ObjC interface header #{swift_objc_interface_header_path}")
+          paths << swift_objc_interface_header_path
+        end
+
+        swiftmodule_glob = get_swiftmodule_glob(built_node)
+        if swiftmodule_glob
+          swiftmodule_path = Dir.glob(swiftmodule_glob).first
+          
+          if swiftmodule_path
+            debug("using swiftmodule #{swiftmodule_path}")
+            paths << swiftmodule_path
+          end
+        end
+
+        modulemap_glob = get_modulemap_glob(built_node)
+        if modulemap_glob
+          modulemap_path = Dir.glob(modulemap_glob).first
+
+          if modulemap_path
+            debug("using modulemap #{modulemap_path}")
+            paths << modulemap_path
+          end
+        end
 
         paths
       end
@@ -97,9 +125,52 @@ module XcodeArchiveCache
         product_name = built_node.native_target.product_reference.name ?
                            built_node.native_target.product_reference.name :
                            built_node.native_target.product_reference.path
+        get_product_glob(File.basename(product_name))
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      # @return [String]
+      #
+      def get_swift_objc_interface_header_glob(built_node)
+        get_product_glob(File.basename(built_node.swift_objc_interface_header_file))
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      # @return [String]
+      #
+      def get_swiftmodule_glob(built_node)
+        if built_node.module_name
+          get_product_glob(built_node.module_name + ".swiftmodule")
+        end
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      # @return [String]
+      #
+      def get_modulemap_glob(built_node)
+        resulting_modulemap_file_name = built_node.resulting_modulemap_file_name
+        if resulting_modulemap_file_name
+          get_product_glob(resulting_modulemap_file_name)
+        else
+          modulemap_file_path = built_node.original_modulemap_file_path
+          if modulemap_file_path && File.exist?(modulemap_file_path)
+            modulemap_file_name = File.basename(modulemap_file_path)
+            get_product_glob(modulemap_file_name)
+          end
+        end
+      end
+
+      # @param [String] file_name
+      #
+      # @return [String]
+      #
+      def get_product_glob(file_name)
         File.join(derived_data_path,
                   "**",
-                  File.basename(product_name))
+                  file_name)
       end
 
       # @param [String] framework_path

data/lib/build_graph/builder.rb

@@ -67,7 +67,11 @@ module XcodeArchiveCache
         node = ALL_NODES.select {|node| node.native_target.uuid == target.uuid && node.native_target.project == target.project}.first
         if node
           debug("already traversed this one")
-          graph.add_multiple_nodes(node.subgraph) unless graph.nodes.include?(node)
+          unless graph.nodes.include?(node)
+            nodes_to_add = node.subgraph.select {|subgraph_node| !graph.nodes.include?(subgraph_node)}
+            graph.add_multiple_nodes(nodes_to_add)
+          end
+
           return node
         else
           debug("adding new node")

data/lib/build_graph/native_target_finder.rb

@@ -14,12 +14,13 @@ module XcodeArchiveCache
       #
       def extract_targets(projects)
         projects
-            .map {|project| unnest(project)}
-            .flatten
-            .uniq
-            .map(&:native_targets)
-            .flatten
-            .select {|target| !target.test_target_type?}
+          .map {|project| unnest(project)}
+          .flatten
+          .sort_by(&:path)
+          .inject([]) {|unique, current| unique.last && unique.last.path == current.path ? unique : unique + [current]}
+          .map(&:native_targets)
+          .flatten
+          .select {|target| !target.test_target_type?}
       end
 
       # @param [String] platform_name

data/lib/build_graph/node.rb

@@ -34,6 +34,10 @@ module XcodeArchiveCache
       #
       attr_accessor :build_settings
 
+      # @return [Array<Xcodeproj::Project::Object::PBXNativeTarget>]
+      #
+      attr_reader :targets_injected_to
+
       # @param [String] name
       # @param [Xcodeproj::Project::Object::PBXNativeTarget] native_target
       # @param [Boolean] is_root
@@ -44,6 +48,7 @@ module XcodeArchiveCache
         @is_root = is_root
         @dependent = []
         @dependencies = []
+        @targets_injected_to = []
         @state = :unknown
       end
 
@@ -91,8 +96,8 @@ module XcodeArchiveCache
 
       # @return [String]
       #
-      def modulemap_file_path
-        modulemap_file = build_settings[XcodeArchiveCache::BuildSettings::MODULEMAP_FILE_KEY]
+      def original_modulemap_file_path
+        modulemap_file = modulemap_file_name
         return unless modulemap_file
 
         Pathname.new(modulemap_file).absolute? ? modulemap_file : File.join(File.dirname(native_target.project.path), modulemap_file)
@@ -100,11 +105,12 @@ module XcodeArchiveCache
 
       # @return [String]
       #
-      def swift_objc_interface_header_path
-        header_file = swift_objc_interface_header_file
-        return if header_file == nil
-
-        File.join(build_settings[XcodeArchiveCache::BuildSettings::DERIVED_SOURCES_DIR_KEY], header_file)
+      def resulting_modulemap_file_name
+        if module_name
+          module_name + ".modulemap"
+        else
+          File.basename(modulemap_file_name)
+        end
       end
 
       # @return [String]
@@ -127,6 +133,12 @@ module XcodeArchiveCache
         build_settings[XcodeArchiveCache::BuildSettings::PRODUCT_MODULE_NAME_KEY]
       end
 
+      # @return [String]
+      #
+      def modulemap_file_name
+        build_settings[XcodeArchiveCache::BuildSettings::MODULEMAP_FILE_KEY]
+      end
+
       # @return [Array<Node>]
       #         Direct + transitive dependents
       #

data/lib/build_graph/sha_calculator.rb

@@ -2,6 +2,10 @@ module XcodeArchiveCache
   module BuildGraph
     class NodeShaCalculator
 
+      def initialize
+        @own_sha = calculate_own_sources_sha
+      end
+
       # @param [XcodeArchiveCache::BuildGraph::Node] node
       #
       def calculate(node)
@@ -24,6 +28,20 @@ module XcodeArchiveCache
 
       private
 
+      # @return [String]
+      #
+      attr_reader :own_sha
+
+      # @return [String]
+      #
+      def calculate_own_sources_sha
+        root = Pathname.new(File.expand_path('../', File.dirname(__FILE__)))
+        source_file_glob = File.join(root.realpath.to_s, "**", "*.rb")
+        source_file_paths = Dir.glob(source_file_glob)
+
+        calculate_sha(source_file_paths)
+      end
+
       # @param [XcodeArchiveCache::BuildGraph::Node] node
       #
       # @return [Array<String>]
@@ -36,7 +54,7 @@ module XcodeArchiveCache
           inputs << list_build_phase_inputs(build_phase)
         end
 
-        modulemap_file_path = node.modulemap_file_path
+        modulemap_file_path = node.original_modulemap_file_path
         inputs << modulemap_file_path if modulemap_file_path
 
         # file path order should not affect evaluation result
@@ -74,7 +92,7 @@ module XcodeArchiveCache
       # @param [Array<String>] dependency_shas
       #
       def save_auxiliary_data(build_settings, dependency_shas, tempfile)
-        file_contents = build_settings + dependency_shas.join("\n")
+        file_contents = build_settings + dependency_shas.join("\n") + "\nXCODE-ARCHIVE-CACHE: #{own_sha}\n"
         tempfile << file_contents
         tempfile.flush
       end

data/lib/injection/build_flags_changer.rb

@@ -7,9 +7,9 @@ module XcodeArchiveCache
       # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
       # @param [String] path
       #
-      def add_framework_search_path(build_configuration, path)
+      def replace_or_add_framework_search_path(build_configuration, target_name, path)
         debug("using framework search path #{path}")
-        add_flag_to_configuration(build_configuration, FRAMEWORK_SEARCH_PATHS_KEY, path_to_search_path(path))
+        replace_or_add_flag(build_configuration, [FRAMEWORK_SEARCH_PATHS_KEY], nil, [target_name], path_to_search_path(path), true)
       end
 
       # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
@@ -44,8 +44,17 @@ module XcodeArchiveCache
           add_libtool_flag(build_configuration, flag)
         end
       end
+      
+      # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
+      # @param [String] path
+      #
+      def add_swift_include_path(build_configuration, path)
+        debug("adding #{path} to SWIFT_INCLUDE_PATHS")
+        add_flag_to_configuration(build_configuration, SWIFT_INCLUDE_PATHS_KEY, path_to_search_path(path))
+      end
 
       # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
+      # @param [String] artifact_location
       # @param [XcodeArchiveCache::BuildGraph::Node] node
       #
       def add_framework_headers_iquote(build_configuration, artifact_location, node)
@@ -57,9 +66,9 @@ module XcodeArchiveCache
       # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
       # @param [String] path
       #
-      def add_library_search_path(build_configuration, path)
+      def replace_or_add_library_search_path(build_configuration, target_name, path)
         debug("using library search path #{path}")
-        add_flag_to_configuration(build_configuration, LIBRARY_SEARCH_PATHS_KEY, path_to_search_path(path))
+        replace_or_add_flag(build_configuration, [LIBRARY_SEARCH_PATHS_KEY], nil, [target_name], path_to_search_path(path), true)
       end
 
       # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
@@ -87,24 +96,14 @@ module XcodeArchiveCache
       end
 
       # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
+      # @param [Array<String>] old_modulemap_names
       # @param [String] path
       #
       def fix_module_map_path(build_configuration, old_modulemap_names, path)
-        replace_module_map_flag(build_configuration.build_settings, OTHER_CFLAGS_KEY, old_modulemap_names, path)
-        replace_module_map_flag(build_configuration.build_settings, OTHER_CPLUSPLUSFLAGS_KEY, old_modulemap_names, path)
-        replace_module_map_flag(build_configuration.build_settings, OTHER_SWIFT_FLAGS_KEY, old_modulemap_names, path)
+        debug("using #{path}")
 
-        if build_configuration.base_configuration_reference
-          xcconfig_path = build_configuration.base_configuration_reference.real_path
-          return unless File.exist?(xcconfig_path)
-          xcconfig = Xcodeproj::Config.new(xcconfig_path)
-
-          replace_module_map_flag(xcconfig.attributes, OTHER_CFLAGS_KEY, old_modulemap_names, path)
-          replace_module_map_flag(xcconfig.attributes, OTHER_CPLUSPLUSFLAGS_KEY, old_modulemap_names, path)
-          replace_module_map_flag(xcconfig.attributes, OTHER_SWIFT_FLAGS_KEY, old_modulemap_names, path)
-
-          xcconfig.save_as(Pathname.new(xcconfig_path))
-        end
+        settings_with_modulemaps = [OTHER_CFLAGS_KEY, OTHER_CPLUSPLUSFLAGS_KEY, OTHER_SWIFT_FLAGS_KEY]
+        replace_or_add_flag(build_configuration, settings_with_modulemaps, MODULE_MAP_FLAG, old_modulemap_names, path_to_search_path(path), false)
       end
 
       private
@@ -117,8 +116,11 @@ module XcodeArchiveCache
       OTHER_LDFLAGS_KEY = "OTHER_LDFLAGS"
       OTHER_LIBTOOLFLAGS_KEY = "OTHER_LIBTOOLFLAGS"
       OTHER_SWIFT_FLAGS_KEY = "OTHER_SWIFT_FLAGS"
+      SWIFT_INCLUDE_PATHS_KEY = "SWIFT_INCLUDE_PATHS"
       INHERITED_SETTINGS_VALUE = "$(inherited)"
 
+      MODULE_MAP_FLAG = "-fmodule-map-file="
+
       # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
       # @param [String] flag
       #
@@ -233,50 +235,106 @@ module XcodeArchiveCache
         node.product_file_name.gsub(/^lib/, "-l").gsub(/\.a$/, "")
       end
 
-      # @param [Hash] build_settings
-      # @param [String] flags_key
-      # @param [Array<String>] old_modulemap_names
-      # @param [String] path
+      # @param [Xcodeproj::Project::Object::XCBuildConfiguration] build_configuration
+      # @param [Array<String>] setting_keys
+      # @param [String] flag_name
+      # @param [Array<String>] possible_old_values
+      # @param [String] new_value
       #
-      def replace_module_map_flag(build_settings, flags_key, old_modulemap_names, path)
-        flags = build_settings[flags_key]
-        if flags
-          build_settings[flags_key] = replace_module_map_path(flags, old_modulemap_names, path)
+      def replace_or_add_flag(build_configuration, setting_keys, flag_name, possible_old_values, new_value, add_if_missing)
+        replaced = false
+
+        setting_keys.each do |setting|
+          replaced = replace_flag_value(build_configuration.build_settings, setting, flag_name, possible_old_values, new_value) || replaced
         end
-      end
 
-      MODULE_MAP_FLAG = "-fmodule-map-file="
+        if build_configuration.base_configuration_reference
+          xcconfig_path = build_configuration.base_configuration_reference.real_path
+          project_dir = File.dirname(build_configuration.project.path)
 
-      # @param [String] flags
-      # @param [Array<String>] old_modulemap_names
-      # @param [String] path
+          replaced = replace_flag_value_in_xcconfig_recursively(xcconfig_path, project_dir, setting_keys, flag_name, possible_old_values, new_value) || replaced
+        end
+
+        if !replaced && add_if_missing
+          full_value = get_full_flag_value(flag_name, new_value)
+
+          setting_keys.each do |setting|
+            add_flag_to_configuration(build_configuration, setting, full_value)
+          end
+        end
+      end
+
+      # @param [String] xcconfig_path
+      # @param [String] project_dir
+      # @param [Array<String>] setting_keys
+      # @param [String] flag_name
+      # @param [Array<String>] possible_old_values
+      # @param [String] new_value
       #
-      # @return [String]
+      def replace_flag_value_in_xcconfig_recursively(xcconfig_path, project_dir, setting_keys, flag_name, possible_old_values, new_value)
+        debug("changing #{possible_old_values} to #{new_value} in #{File.basename(xcconfig_path)}")
+        return unless File.exist?(xcconfig_path)
+
+        replaced = false
+        xcconfig = Xcodeproj::Config.new(xcconfig_path)
+
+        setting_keys.each do |key|
+          replaced = replace_flag_value(xcconfig.attributes, key, flag_name, possible_old_values, new_value) || replaced
+        end
+
+        xcconfig.save_as(Pathname.new(xcconfig_path))
+
+        xcconfig.includes.each do |included_xcconfig|
+          included_xcconfig_path = File.join(project_dir, included_xcconfig)
+          replaced = replace_flag_value_in_xcconfig_recursively(included_xcconfig_path, project_dir, setting_keys, flag_name, possible_old_values, new_value) || replaced
+        end
+
+        replaced
+      end
+
+      # @param [Hash] attributes
+      # @param [String] setting_key
+      # @param [String] flag_name
+      # @param [Array<String>] possible_old_values
+      # @param [String] new_value
       #
-      def replace_module_map_path(flags, old_modulemap_names, path)
-        return if flags == nil
+      def replace_flag_value(attributes, setting_key, flag_name, possible_old_values, new_value)
+        build_settings = attributes[setting_key]
+        return unless build_settings
 
-        is_flags_string = flags.is_a?(String)
-        flags = flags.split(" ") if is_flags_string
-        updated_flags = flags
-                            .map { |flags_line| flags_line.split(" ") }
+        replaced = false
+        is_string = build_settings.is_a?(String)
+        build_settings = build_settings.split(" ") if is_string
+        full_value = get_full_flag_value(flag_name, new_value)
+        old_value_regexps = possible_old_values.map { |value| Regexp.new("#{value}\"*$") }
+
+        updated_settings = build_settings
+                            .map { |line| line.split(" ") }
                             .flatten
                             .map do |line|
+          if flag_name
+            next line unless line.include?(flag_name)
+          end
+
           updated_line = line
 
-          if line.include?(MODULE_MAP_FLAG)
-            old_modulemap_names.each do |name|
-              if line.include?(name)
-                updated_line = "#{MODULE_MAP_FLAG}\"#{path}\""
-                break
-              end
+          old_value_regexps.each do |regexp|
+            if regexp.match?(line)
+              replaced = true
+              updated_line = full_value
+              break
             end
           end
 
           updated_line
         end
 
-        is_flags_string ? updated_flags.join(" ") : updated_flags
+        attributes[setting_key] = is_string ? updated_settings.join(" ") : updated_settings
+        replaced
+      end
+
+      def get_full_flag_value(flag_name, value)
+        "#{flag_name}#{value}"
       end
     end
   end

data/lib/injection/headers_mover.rb

@@ -9,6 +9,7 @@ module XcodeArchiveCache
       def initialize(storage)
         @storage = storage
         @build_settings_interpolator = XcodeArchiveCache::BuildSettings::StringInterpolator.new
+        @modulemap_header_path_extractor = XcodeArchiveCache::Modulemap::HeaderPathExtractor.new
       end
 
       # @param [XcodeArchiveCache::BuildGraph::Node] node
@@ -33,16 +34,22 @@ module XcodeArchiveCache
           headers_file_paths = node.native_target
                                    .headers_build_phase
                                    .files
+                                   .select { |file| file.settings && file.settings["ATTRIBUTES"].include?("Public") }
                                    .map { |header| get_real_path(header) }
                                    .uniq
           storage.store_default_headers(node, headers_file_paths)
 
           header_count += headers_file_paths.length
+        end
 
-          storage.store_modulemap(node)
+        modulemap_file_path = node.original_modulemap_file_path
+        if modulemap_file_path && File.exist?(modulemap_file_path)
+          header_file_paths = modulemap_header_path_extractor.extract_all_paths(modulemap_file_path)
+          storage.store_modulemap_headers(node, header_file_paths)
+          header_count += header_file_paths.length
         end
 
-        debug("found #{header_count} headers")
+        debug("found #{header_count} header(s)")
       end
 
       private
@@ -55,6 +62,10 @@ module XcodeArchiveCache
       #
       attr_reader :build_settings_interpolator
 
+      # @return [XcodeArchiveCache::Modulemap::HeaderPathExtractor]
+      #
+      attr_reader :modulemap_header_path_extractor
+
       # @param [Xcodeproj::Project::Object::PBXBuildFile] build_file
       #
       # @return [String]

data/lib/injection/injector.rb

@@ -14,14 +14,14 @@ module XcodeArchiveCache
         @dependency_remover = DependencyRemover.new
         @build_flags_changer = BuildFlagsChanger.new
         @pods_fixer = PodsScriptFixer.new
-        @modulemap_fixer = ModulemapFixer.new(storage)
+        @modulemap_fixer = XcodeArchiveCache::Modulemap::HeaderPathFixer.new(storage)
         @framework_embedder = FrameworkEmbedder.new
       end
 
       # @param [XcodeArchiveCache::BuildGraph::Graph] graph
       #
       def perform_internal_injection(graph)
-        inject_unpacked(graph.nodes)
+        inject_unpacked_and_rebuilt(graph.nodes)
         add_header_paths(graph.nodes)
         save_graph_projects(graph)
       end
@@ -103,13 +103,18 @@ module XcodeArchiveCache
 
       # @param [Array<XcodeArchiveCache::BuildGraph::Node>] nodes
       #
-      def inject_unpacked(nodes)
+      def inject_unpacked_and_rebuilt(nodes)
         cached_nodes = nodes.select { |node| node.state == :unpacked }
         cached_nodes.each do |node|
           headers_mover.prepare_headers_for_injection(node)
           modulemap_fixer.fix_modulemap(node)
           add_as_prebuilt_to_dependents(node)
         end
+
+        built_nodes = nodes.select { |node| node.state == :rebuilt_and_cached }
+        built_nodes.each do |node|
+          add_as_prebuilt_to_dependents(node)
+        end
       end
 
       # @param [Array<XcodeArchiveCache::BuildGraph::Node>] nodes
@@ -164,6 +169,9 @@ module XcodeArchiveCache
       # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
       #
       def add_as_prebuilt_dependency(prebuilt_node, dependent_target)
+        target_identifier = get_target_identifier(dependent_target)
+        return if prebuilt_node.targets_injected_to.include?(target_identifier)
+
         debug("adding #{prebuilt_node.name} as prebuilt to #{dependent_target.display_name}")
 
         unless prebuilt_node.has_acceptable_product?
@@ -176,6 +184,8 @@ module XcodeArchiveCache
           add_as_prebuilt_static_lib(prebuilt_node, dependent_target)
         end
 
+        prebuilt_node.targets_injected_to.push(target_identifier)
+
         debug("done with #{prebuilt_node.name} for #{dependent_target.display_name}")
       end
 
@@ -186,7 +196,7 @@ module XcodeArchiveCache
         build_configuration = find_build_configuration(dependent_target)
 
         artifact_location = storage.get_storage_path(prebuilt_node)
-        build_flags_changer.add_framework_search_path(build_configuration, artifact_location)
+        build_flags_changer.replace_or_add_framework_search_path(build_configuration, prebuilt_node.native_target.name, artifact_location)
         build_flags_changer.add_framework_headers_iquote(build_configuration, artifact_location, prebuilt_node)
 
         if dependency_remover.is_linked(prebuilt_node, dependent_target)
@@ -204,12 +214,16 @@ module XcodeArchiveCache
 
         injected_modulemap_file_path = storage.get_modulemap_path(prebuilt_node)
         if injected_modulemap_file_path
-          modulemap_file_names = ["#{prebuilt_node.module_name}.modulemap", File.basename(prebuilt_node.modulemap_file_path)]
+          modulemap_file_names = [prebuilt_node.resulting_modulemap_file_name]
           build_flags_changer.fix_module_map_path(build_configuration, modulemap_file_names, injected_modulemap_file_path)
+
+          original_modulemap_path = prebuilt_node.original_modulemap_file_path
+          add_header_paths_to_target(dependent_target, [File.dirname(original_modulemap_path)])
         end
 
         artifact_location = storage.get_storage_path(prebuilt_node)
-        build_flags_changer.add_library_search_path(build_configuration, artifact_location)
+        build_flags_changer.replace_or_add_library_search_path(build_configuration, prebuilt_node.native_target.name, artifact_location)
+        build_flags_changer.add_swift_include_path(build_configuration, artifact_location)
 
         if dependency_remover.is_linked(prebuilt_node, dependent_target)
           if dependent_target.product_type == Xcodeproj::Constants::PRODUCT_TYPE_UTI[:static_library]
@@ -250,6 +264,14 @@ module XcodeArchiveCache
         debug("deleting #{node.name} target")
         node.native_target.project.targets.delete(node.native_target)
       end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      # @return [String]
+      #
+      def get_target_identifier(target)
+        target.uuid + target.project.path.realpath.to_s
+      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
 

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

@@ -68,34 +68,49 @@ module XcodeArchiveCache
         raise 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)
+      graph_builder = XcodeArchiveCache::BuildGraph::Builder.new(@native_target_finder, xcodebuild_executor)
+
+      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
+
+      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}"
       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/xcode-archive-cache.rb

@@ -40,13 +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 'modulemap/file_handler'
+require 'modulemap/header_path_extractor'
+require 'modulemap/header_path_fixer'
+
 require 'runner/runner'
 
 require 'shell/executor'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcode-archive-cache
 version: !ruby/object:Gem::Version
-  version: 0.0.10.pre.2
+  version: 0.0.10
 platform: ruby
 authors:
 - Ilya Dyakonov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-21 00:00:00.000000000 Z
+date: 2020-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xcodeproj
@@ -78,8 +78,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: 
-email: 
+description:
+email:
 executables:
 - xcode-archive-cache
 extensions: []
@@ -112,10 +112,12 @@ files:
 - lib/injection/framework_embedder.rb
 - lib/injection/headers_mover.rb
 - lib/injection/injector.rb
-- lib/injection/modulemap_fixer.rb
 - lib/injection/pods_script_fixer.rb
 - lib/injection/storage.rb
 - lib/logs/logs.rb
+- lib/modulemap/file_handler.rb
+- lib/modulemap/header_path_extractor.rb
+- lib/modulemap/header_path_fixer.rb
 - lib/runner/runner.rb
 - lib/shell/executor.rb
 - lib/xcode-archive-cache.rb
@@ -124,7 +126,7 @@ homepage: https://github.com/sweatco/xcode-archive-cache
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -135,12 +137,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.4
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Native targets cache for Xcode archive builds.
 test_files: []

data/lib/injection/modulemap_fixer.rb

@@ -1,47 +0,0 @@
-module XcodeArchiveCache
-  module Injection
-
-    class ModulemapFixer
-
-      # @param [Storage] storage
-      #
-      def initialize(storage)
-        @storage = storage
-      end
-
-      # @param [XcodeArchiveCache::BuildGraph::Node] node
-      #
-      def fix_modulemap(node)
-        return unless node.has_static_library_product?
-
-        modulemap_file_path = node.modulemap_file_path
-        return if modulemap_file_path == nil
-
-        injected_modulemap_file_path = storage.get_modulemap_path(node)
-        return if injected_modulemap_file_path == nil
-
-        swift_objc_interface_header_file_name = node.swift_objc_interface_header_file
-        return if swift_objc_interface_header_file_name == nil
-
-        # add generated header to modulemap to make Swift stuff available module users
-        #
-        storage_path = storage.get_storage_path(node)
-        header_path = File.join(storage_path, swift_objc_interface_header_file_name)
-        return unless File.exist?(header_path)
-
-        File.open(injected_modulemap_file_path, "a") do |modulemap_file|
-          modulemap_file.puts "\nmodule #{node.module_name}.Swift {\n"
-          modulemap_file.puts "  header \"#{header_path}\"\n"
-          modulemap_file.puts "  requires objc\n"
-          modulemap_file.puts "}\n"
-        end
-      end
-
-      private
-
-      # @return [Storage]
-      #
-      attr_accessor :storage
-    end
-  end
-end