xcode-archive-cache 0.0.6

data/lib/injection/dependency_remover.rb

@@ -0,0 +1,146 @@
+module XcodeArchiveCache
+  module Injection
+    class DependencyRemover
+
+      include XcodeArchiveCache::Logs
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] prebuilt_node
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
+      #
+      def remove_dependency(prebuilt_node, dependent_target)
+        prebuilt_target = prebuilt_node.native_target
+        debug("removing #{prebuilt_target.name} from #{dependent_target.display_name}")
+
+        remove_from_dependencies(prebuilt_target, dependent_target)
+        remove_from_schemes(prebuilt_target, dependent_target)
+
+        debug("finished removing #{prebuilt_target.name} from #{dependent_target.display_name}")
+      end
+
+      private
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] prebuilt_target
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
+      #
+      def remove_from_dependencies(prebuilt_target, dependent_target)
+        count_before = dependent_target.dependencies.length
+
+        dependent_target.dependencies.delete_if do |dependency|
+          if dependency.target
+            dependency.target.uuid == prebuilt_target.uuid
+          elsif dependency.target_proxy
+            dependency.target_proxy.remote_global_id_string == prebuilt_target.uuid
+          end
+        end
+
+        count_after = dependent_target.dependencies.length
+        if count_after == count_before
+          debug("found nothing in dependencies")
+        else
+          debug("removed #{count_before - count_after} dependencies")
+        end
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
+      # @param [XcodeArchiveCache::BuildGraph::Node] prebuilt_node
+      #
+      def remove_from_linking(prebuilt_node, dependent_target)
+        debug("product name is #{prebuilt_node.product_file_name}")
+        frameworks = dependent_target.frameworks_build_phase.files.select {|file| file.display_name == prebuilt_node.product_file_name}
+        debug("found #{frameworks.length} linked products")
+
+        frameworks.each do |framework|
+          dependent_target.frameworks_build_phase.remove_file_reference(framework.file_ref)
+        end
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] prebuilt_target
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
+      #
+      def remove_from_schemes(prebuilt_target, dependent_target)
+        schemes = find_schemes(dependent_target)
+        schemes.each do |scheme|
+          debug("fixing scheme")
+          remove_target_from_scheme(prebuilt_target, scheme)
+          scheme.save!
+          debug("finished fixing scheme")
+        end
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      # @return [Array<Xcodeproj::XCScheme>]
+      #
+      def find_schemes(target)
+        scheme_names = Xcodeproj::Project.schemes(target.project.path)
+        scheme_names
+            .map {|scheme_name| find_scheme_by_name(target, scheme_name)}
+            .compact
+            .select {|scheme| scheme_contains_target?(scheme, target)}
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      # @param [Xcodeproj::XCScheme] scheme
+      #
+      def remove_target_from_scheme(target, scheme)
+        target_entries = scheme.build_action.entries.select {|entry| scheme_entry_contains_target?(entry, target)}
+        return if target_entries.length == 0
+
+        target_entries.each do |entry|
+          entry.buildable_references.each do |reference|
+            if reference_contains_target?(reference, target)
+              debug("removing buildable reference")
+              entry.xml_element.delete_element(reference.xml_element)
+            end
+          end
+
+          if entry.buildable_references.empty?
+            debug("removing entry")
+            scheme.build_action.xml_element.elements['BuildActionEntries'].delete_element(entry.xml_element)
+          end
+        end
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      # @param [Xcodeproj::XCScheme] scheme_name
+      #
+      def find_scheme_by_name(target, scheme_name)
+        scheme_path = File.join(Xcodeproj::XCScheme.shared_data_dir(target.project.path),
+                                "#{scheme_name}.xcscheme")
+        if File.exist?(scheme_path)
+          Xcodeproj::XCScheme.new(scheme_path)
+        end
+      end
+
+      # @param [Xcodeproj::XCScheme] scheme
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def scheme_contains_target?(scheme, target)
+        scheme.build_action.entries.each do |entry|
+          if scheme_entry_contains_target?(entry, target)
+            return true
+          end
+        end
+      end
+
+      # @param [Xcodeproj::XCScheme::BuildAction::Entry] entry
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def scheme_entry_contains_target?(entry, target)
+        entry.buildable_references.each do |reference|
+          if reference_contains_target?(reference, target)
+            return true
+          end
+        end
+      end
+
+      # @param [Xcodeproj::XCScheme::BuildableReference] reference
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def reference_contains_target?(reference, target)
+        reference.target_uuid == target.uuid
+      end
+    end
+  end
+end

data/lib/injection/framework_embedder.rb

@@ -0,0 +1,47 @@
+module XcodeArchiveCache
+  module Injection
+    class FrameworkEmbedder
+
+      include XcodeArchiveCache::Logs
+
+      def initialize
+        @shell_executor = XcodeArchiveCache::Shell::Executor.new
+      end
+
+      # @param [Array<String>] framework_file_paths
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def embed(framework_file_paths, target)
+        dynamic_framework_file_paths = framework_file_paths.select do |path|
+          binary_name = File.basename(path, ".framework")
+          binary_path = File.join(path, binary_name)
+          shell_executor.execute("file #{binary_path} | grep dynamic")
+        end
+
+        return if dynamic_framework_file_paths.length == 0
+
+        debug("Embedding frameworks:\n\t#{dynamic_framework_file_paths.join("\n\t")}")
+
+        frameworks_group = target.project.main_group.new_group("XcodeArchiveCache Frameworks")
+        file_references = dynamic_framework_file_paths.map {|file_path| frameworks_group.new_reference(file_path)}
+        embed_frameworks_phase = target.new_copy_files_build_phase("Embed XcodeArchiveCache Frameworks")
+        embed_frameworks_phase.symbol_dst_subfolder_spec = :frameworks
+        embed_frameworks_phase.run_only_for_deployment_postprocessing = false
+
+        file_references.each do |file_reference|
+          build_file = target.project.new(Xcodeproj::Project::Object::PBXBuildFile)
+          build_file.file_ref = file_reference
+          build_file.settings = {"ATTRIBUTES" => %w(CodeSignOnCopy RemoveHeadersOnCopy)}
+          build_file.add_referrer(frameworks_group)
+          embed_frameworks_phase.files.push(build_file)
+        end
+      end
+
+      private
+
+      # @return [XcodeArchiveCache::Shell::Executor]
+      #
+      attr_reader :shell_executor
+    end
+  end
+end

data/lib/injection/headers_mover.rb

@@ -0,0 +1,65 @@
+module XcodeArchiveCache
+  module Injection
+    class HeadersMover
+
+      include XcodeArchiveCache::Logs
+
+      # @param [Storage] storage
+      #
+      def initialize(storage)
+        @storage = storage
+        @build_settings_interpolator = XcodeArchiveCache::BuildSettings::StringInterpolator.new
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      def prepare_headers_for_injection(node)
+        debug("checking #{node.name} headers")
+        header_count = 0
+
+        node.native_target.copy_files_build_phases.each do |build_phase|
+          file_paths = build_phase.files
+                           .map {|build_file| get_real_path(build_file)}
+                           .compact
+                           .uniq
+                           .select {|path| File.extname(path) == ".h"}
+          destination_path = get_destination_dir_path(node, build_phase)
+          storage.store_headers(node, destination_path, file_paths)
+
+          header_count += file_paths.length
+        end
+
+        debug("found #{header_count} headers")
+      end
+
+      private
+
+      # @return [Storage]
+      #
+      attr_reader :storage
+
+      # @return [XcodeArchiveCache::BuildSettings::StringInterpolator]
+      #
+      attr_reader :build_settings_interpolator
+
+      # @param [Xcodeproj::Project::Object::PBXBuildFile] build_file
+      #
+      # @return [String]
+      #
+      def get_real_path(build_file)
+        if build_file.file_ref.is_a?(Xcodeproj::Project::Object::PBXFileReference)
+          build_file.file_ref.real_path.to_s
+        end
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      # @param [Xcodeproj::Project::Object::PBXCopyFilesBuildPhase] build_phase
+      #
+      # @return [String]
+      #
+      def get_destination_dir_path(node, build_phase)
+        build_settings_interpolator.interpolate(build_phase.dst_path, node.build_settings)
+      end
+    end
+  end
+end

data/lib/injection/injector.rb

@@ -0,0 +1,220 @@
+module XcodeArchiveCache
+  module Injection
+    class Injector
+
+      include XcodeArchiveCache::Logs
+
+      # @param [String] configuration_name
+      # @param [XcodeArchiveCache::Injection::Storage] storage
+      #
+      def initialize(configuration_name, storage)
+        @configuration_name = configuration_name
+        @storage = storage
+        @headers_mover = HeadersMover.new(storage)
+        @dependency_remover = DependencyRemover.new
+        @build_flags_changer = BuildFlagsChanger.new
+        @pods_fixer = PodsScriptFixer.new
+        @framework_embedder = FrameworkEmbedder.new
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      #
+      def perform_internal_injection(graph)
+        inject_cached(graph.nodes)
+        add_header_paths(graph.nodes)
+        save_graph_projects(graph)
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def perform_outgoing_injection(graph, target)
+        graph.nodes.each do |node|
+          headers_mover.prepare_headers_for_injection(node)
+          add_as_prebuilt_dependency(node, target, node.is_root)
+          remove_native_target_from_project(node)
+        end
+
+        add_header_paths_to_target(target, storage.get_all_headers_storage_paths)
+
+        # pretty dummy but should work in most cases;
+        # here we assume that if graph has a pods target
+        # then all graph nodes are built as pods and therefore
+        # are covered by "Embed Pods Frameworks" script
+        #
+        if graph.node_by_name(get_pods_target_name(target))
+          pods_fixer.fix_embed_frameworks_script(target, graph, storage.container_dir_path)
+        else
+          framework_nodes = graph.nodes.select {|node| node.has_framework_product?}
+          framework_file_paths = framework_nodes.map {|node| File.join(storage.get_storage_path(node), node.product_file_name)}
+          framework_embedder.embed(framework_file_paths, target)
+        end
+
+        save_graph_projects(graph)
+        target.project.save
+      end
+
+      private
+
+      # @return [String]
+      #
+      attr_reader :configuration_name
+
+      # @return [Storage]
+      # 
+      attr_reader :storage
+
+      # @return [HeadersMover]
+      #
+      attr_reader :headers_mover
+
+      # @return [DependencyRemover]
+      #
+      attr_reader :dependency_remover
+
+      # @return [BuildFlagsChanger]
+      #
+      attr_reader :build_flags_changer
+
+      # @return [PodsScriptFixer]
+      #
+      attr_reader :pods_fixer
+
+      # @return [FrameworkEmbedder]
+      #
+      attr_reader :framework_embedder
+
+      # @param [Array<XcodeArchiveCache::BuildGraph::Node>] nodes
+      #
+      def inject_cached(nodes)
+        cached_nodes = nodes.select {|node| !node.rebuild}
+        cached_nodes.each do |node|
+          headers_mover.prepare_headers_for_injection(node)
+          add_as_prebuilt_to_dependents(node)
+        end
+      end
+
+      # @param [Array<XcodeArchiveCache::BuildGraph::Node>] nodes
+      #
+      def add_header_paths(nodes)
+        header_storage_paths = storage.get_all_headers_storage_paths
+
+        nodes
+            .select {|node| node.rebuild}
+            .each { |node|  add_header_paths_to_target(node.native_target, header_storage_paths) }
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      # @param [Array<String>] paths
+      #
+      def add_header_paths_to_target(target, paths)
+        debug("adding #{paths} to #{target.display_name}")
+
+        return if paths == nil
+
+        build_configuration = find_build_configuration(target)
+        paths.each do |path|
+          build_flags_changer.add_headers_search_path(build_configuration, path)
+          build_flags_changer.add_iquote_path(build_configuration, path)
+          build_flags_changer.add_capital_i_path(build_configuration, path)
+        end
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] prebuilt_node
+      #
+      def add_as_prebuilt_to_dependents(prebuilt_node)
+        dependent_to_rebuild = prebuilt_node
+                                   .all_dependent_nodes
+                                   .select {|node| node.rebuild}
+        dependent_to_rebuild.each do |dependent_node|
+          should_link = prebuilt_node.dependent.include?(dependent_node)
+          add_as_prebuilt_dependency(prebuilt_node, dependent_node.native_target, should_link)
+        end
+
+        remove_native_target_from_project(prebuilt_node)
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      #
+      def save_graph_projects(graph)
+        projects = graph.nodes.map(&:native_target).map(&:project).uniq
+        debug("updating #{projects.length} projects")
+        projects.each {|project| project.save}
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] prebuilt_node
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
+      #
+      def add_as_prebuilt_dependency(prebuilt_node, dependent_target, should_link)
+        debug("adding #{prebuilt_node.name} as prebuilt to #{dependent_target.display_name}")
+
+        if prebuilt_node.has_framework_product?
+          add_as_prebuilt_framework(prebuilt_node, dependent_target)
+        elsif prebuilt_node.has_static_library_product?
+          add_as_prebuilt_static_lib(prebuilt_node, dependent_target, should_link)
+        else
+          raise ArgumentError.new, "#{prebuilt_node.name} has unsupported product type: #{prebuilt_node.native_target.product_type}"
+        end
+
+        debug("done with #{prebuilt_node.name} for #{dependent_target.display_name}")
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] prebuilt_node
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
+      #
+      def add_as_prebuilt_framework(prebuilt_node, dependent_target)
+        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.add_framework_headers_iquote(build_configuration, artifact_location, prebuilt_node)
+
+        dependency_remover.remove_dependency(prebuilt_node, dependent_target)
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] prebuilt_node
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependent_target
+      # @param [Boolean] should_link
+      #
+      def add_as_prebuilt_static_lib(prebuilt_node, dependent_target, should_link)
+        build_configuration = find_build_configuration(dependent_target)
+
+        if should_link
+          artifact_location = storage.get_storage_path(prebuilt_node)
+          build_flags_changer.add_library_search_path(build_configuration, artifact_location)
+        end
+
+        dependency_remover.remove_dependency(prebuilt_node, dependent_target)
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def find_build_configuration(target)
+        build_configuration = target.build_configurations.select {|configuration| configuration.name == configuration_name}.first
+        unless build_configuration
+          raise ArgumentError.new, "#{configuration_name} build configuration not found on target #{node.name}"
+        end
+
+        build_configuration
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def get_pods_target_name(target)
+        "Pods-#{target.display_name}"
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # since 10.2 Xcode looks for implicit dependencies
+      # in -l and -framework linker flags, so we need to delete
+      # dependency target to make sure Xcode has no way to build it
+      # as implicit dependency
+      #
+      def remove_native_target_from_project(node)
+        debug("deleting #{node.name} target")
+        node.native_target.project.targets.delete(node.native_target)
+      end
+    end
+  end
+end