xcode-archive-cache 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 49b93ea668f7de9a3723feec1518e934f0b46755afaf941866cf028ed0cc7f0b
+  data.tar.gz: 16c0538e9665fe7f7c95c747d34f8ae48a3d8c2c5ed7adb1cc865dbbcbe0c43f
+SHA512:
+  metadata.gz: 07424e1f9f50852d8d3a2fb873454d6e441860d33d220a6b37aeb11bb5dd6e90a872bbd37f8c749bb3b0e6a0693fe9aab8fb6c344f7294127861f7ddd9321e8f
+  data.tar.gz: 670815a9f5e0bf971f5f0868e42bdeb0b2d0f12b745572688c0022914f57d6d0ba3016cddd54b5aca92203101df21c52b84d6c01de9c080bfa6eb3be1e9b0273

data/bin/xcode-archive-cache

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+if $PROGRAM_NAME == __FILE__
+  require 'pathname'
+  ROOT = Pathname.new(File.expand_path('../../', __FILE__))
+  $LOAD_PATH.unshift((ROOT + 'lib').to_s)
+end
+
+require 'xcode-archive-cache'
+
+XcodeArchiveCache::Command.run(ARGV)

data/lib/artifact_cache/abstract_storage.rb

@@ -0,0 +1,18 @@
+module XcodeArchiveCache
+  module ArtifactCache
+    class AbstractStorage
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # @return [String] cached artifact path, nil if no cached artifact found
+      #
+      def cached_artifact_path(node)
+        nil
+      end
+
+      def store(node, path)
+
+      end
+    end
+  end
+end

data/lib/artifact_cache/archiver.rb

@@ -0,0 +1,110 @@
+module XcodeArchiveCache
+  module ArtifactCache
+    class Archiver
+
+      include XcodeArchiveCache::Logs
+
+      # @param [String] path
+      # @param [String] destination
+      #
+      def archive(path, destination)
+        if File.exists?(destination)
+          raise ArgumentError.new, "Artifact cache path #{destination} is already taken"
+        end
+
+        if File.file?(path)
+          archive_single_file(path, destination)
+        elsif File.directory?(path)
+          archive_directory(path, destination)
+        else
+          raise ArgumentError.new, "No artifact found at path #{path}"
+        end
+      end
+
+      # @param [String] path
+      # @param [String] destination
+      #
+      def unarchive(path, destination)
+        unless File.file?(path)
+          raise ArgumentError.new, "Artifact archive not found: #{path}"
+        end
+
+        unless File.directory?(destination)
+          FileUtils.mkdir_p(destination)
+        end
+
+        Zip::File.open(path) do |archive|
+          archive.each do |archive_entry|
+            destination_file_path = File.join(destination, archive_entry.name)
+            destination_dir_path = File.dirname(destination_file_path)
+            unless File.exists?(destination_dir_path) && File.directory?(destination_dir_path)
+              FileUtils.mkdir_p(destination_dir_path)
+            end
+
+            archive_entry.extract(destination_file_path)
+          end
+        end
+      end
+
+      private
+
+      # @param [String] path
+      # @param [String] destination
+      #
+      def archive_single_file(path, destination)
+        info("archiving #{path}")
+
+        Zip::File.open(destination, Zip::File::CREATE) do |archive|
+          archive.add(File.basename(path), path)
+        end
+      end
+
+      # @param [String] path
+      # @param [String] destination
+      #
+      def archive_directory(path, destination)
+        info("archiving #{path}")
+
+        Zip::File.open(destination, Zip::File::CREATE) do |archive|
+          add_entries(list_entries_in_directory(path), path, archive)
+        end
+      end
+
+      # @param [Array<String>] entries
+      # @param [String] root_dir
+      # @param [Zip::File] archive
+      #
+      def add_entries(entries, root_dir, archive)
+        entries.each do |entry|
+          if File.directory?(entry)
+            add_entries(list_entries_in_directory(entry), root_dir, archive)
+          elsif File.file?(entry)
+            add_single_file_entry(entry, root_dir, archive)
+          else
+            raise ArgumentError.new, "No file found at path #{entry}"
+          end
+        end
+      end
+
+      # @param [String] path
+      #
+      def list_entries_in_directory(path)
+        (Dir.entries(path) - %w(. ..)).map {|entry| File.join(path, entry)}
+      end
+
+      # @param [String] path_on_disk
+      # @param [String] root_dir
+      # @param [Zip::File] archive
+      #
+      def add_single_file_entry(path_on_disk, root_dir, archive)
+        file_path = Pathname.new(path_on_disk)
+        root_dir_path = Pathname.new(root_dir)
+        path_in_archive = file_path.relative_path_from(root_dir_path).to_s
+
+        archive.get_output_stream(path_in_archive) do |stream|
+          stream.write(File.open(path_on_disk, 'rb').read)
+        end
+      end
+    end
+  end
+end

data/lib/artifact_cache/artifact_extractor.rb

@@ -0,0 +1,31 @@
+module XcodeArchiveCache
+  module ArtifactCache
+    class ArtifactExtractor
+
+      # @param [XcodeArchiveCache::ArtifactCache::AbstractStorage] storage
+      #
+      def initialize(storage)
+        @storage = storage
+        @archiver = Archiver.new
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      # @param [String] destination
+      #
+      def unpack(node, destination)
+        cached_artifact_path = storage.cached_artifact_path(node)
+        archiver.unarchive(cached_artifact_path, destination)
+      end
+
+      private
+
+      # @return [XcodeArchiveCache::ArtifactCache::AbstractStorage]
+      #
+      attr_reader :storage
+
+      # @return [XcodeArchiveCache::ArtifactCache::Archiver]
+      #
+      attr_reader :archiver
+    end
+  end
+end

data/lib/artifact_cache/local_storage.rb

@@ -0,0 +1,46 @@
+module XcodeArchiveCache
+  module ArtifactCache
+    class LocalStorage < AbstractStorage
+
+      # @param [String] cache_dir_path
+      #
+      def initialize(cache_dir_path)
+        @cache_dir_path = cache_dir_path
+        @archiver = Archiver.new
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # @return [String] cached artifact path, nil if no artifact found in cache dir
+      #
+      def cached_artifact_path(node)
+        path = path_inside_cache_dir(node)
+        File.exist?(path) ? path : nil
+      end
+
+      def store(node, path)
+        archive_path = path_inside_cache_dir(node)
+        archive_directory = File.expand_path("..", archive_path)
+        unless File.exist?(archive_directory)
+          FileUtils.mkdir_p(archive_directory)
+        end
+
+        archiver.archive(path, archive_path)
+      end
+
+      private
+
+      # @return [String]
+      #
+      attr_reader :cache_dir_path
+
+      # @return [XcodeArchiveCache::ArtifactCache::Archiver]
+      #
+      attr_reader :archiver
+
+      def path_inside_cache_dir(node)
+        File.join(cache_dir_path, node.name, node.sha)
+      end
+    end
+  end
+end

data/lib/build/performer.rb

@@ -0,0 +1,48 @@
+module XcodeArchiveCache
+  module Build
+    class Performer
+
+      include XcodeArchiveCache::Logs
+
+      # @param [String] derived_data_path
+      #
+      def initialize(xcodebuild_executor, derived_data_path)
+        @xcodebuild_executor = xcodebuild_executor
+        @derived_data_path = derived_data_path
+      end
+
+      # @param [String] configuration
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      #
+      def rebuild_missing(target, graph)
+        should_rebuild_anything = should_rebuild?(graph)
+        if should_rebuild_anything
+          rebuild_list = graph.nodes.select(&:rebuild).map(&:name).join(", ")
+          info("going to rebuild:\n#{rebuild_list}")
+
+          build_result = xcodebuild_executor.build(target.project.path, target.name, derived_data_path)
+          unless build_result
+            raise StandardError.new, "Failed to perform rebuild"
+          end
+        else
+          info("no need to rebuild anything")
+        end
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      #
+      def should_rebuild?(graph)
+        graph.nodes.reduce(false) {|rebuild, node| rebuild || node.rebuild}
+      end
+
+      private
+
+      # @return [String]
+      #
+      attr_reader :derived_data_path
+
+      attr_reader :xcodebuild_executor
+    end
+  end
+end

data/lib/build/product_extractor.rb

@@ -0,0 +1,129 @@
+module XcodeArchiveCache
+  module Build
+    class ProductExtractor
+
+      # @param [String] configuration
+      # @param [String] derived_data_path
+      #
+      def initialize(configuration, derived_data_path)
+        @configuration = configuration
+        @derived_data_path = derived_data_path
+        @shell_executor = XcodeArchiveCache::Shell::Executor.new
+      end
+
+      def list_product_contents(root_target_name, built_node)
+        file_paths = list_products(root_target_name, built_node)
+        file_paths.select {|path| File.exist?(path)}.map {|path| File.realpath(path) }
+      end
+
+      private
+
+      # @return [String]
+      # 
+      attr_reader :configuration
+
+      # @return [String]
+      #
+      attr_reader :derived_data_path
+
+      # @return [XcodeArchiveCache::Shell::Executor]
+      #
+      attr_reader :shell_executor
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      def list_products(root_target_name, built_node)
+        if built_node.has_framework_product?
+          list_framework_products(root_target_name, built_node)
+        elsif built_node.has_static_library_product?
+          list_static_lib_products(root_target_name, built_node)
+        end
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      # @return [Array<String>]
+      #
+      def list_framework_products(root_target_name, built_node)
+        framework_glob = get_main_product_glob(root_target_name, built_node)
+        framework_path = Dir.glob(framework_glob).first
+        unless framework_path
+          raise Informative, "Framework product not found for #{built_node.name}"
+        end
+
+        framework_dsym_glob = File.join(File.dirname(framework_glob), built_node.dsym_file_name)
+        framework_dsym_path = Dir.glob(framework_dsym_glob).first
+
+        bc_symbolmap_paths = list_framework_bc_symbolmaps(framework_path)
+
+        ([framework_path, framework_dsym_path] + bc_symbolmap_paths).flatten.compact
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      # @return [Array<String>]
+      #
+      def list_static_lib_products(root_target_name, built_node)
+        static_lib_glob = get_main_product_glob(root_target_name, built_node)
+        static_lib_path = Dir.glob(static_lib_glob).first
+        unless static_lib_path
+          raise Informative, "Static library product not found for #{built_node.name}"
+        end
+
+        [static_lib_path]
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      # @return [String]
+      #
+      def get_main_product_glob(root_target_name, built_node)
+        product_name = built_node.native_target.product_reference.name ?
+                           built_node.native_target.product_reference.name :
+                           built_node.native_target.product_reference.path
+        File.join(derived_data_path,
+                  "**",
+                  File.basename(product_name))
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] built_node
+      #
+      # @return [String]
+      #
+      def configuration_dir(built_node)
+        "#{configuration}-#{built_node.native_target.sdk}"
+      end
+
+      # @param [String] framework_path
+      #
+      # @return [Array<String>]
+      #
+      def list_framework_bc_symbolmaps(framework_path)
+        executable_name = File.basename(framework_path, File.extname(framework_path))
+        executable_path = File.join(framework_path, executable_name)
+        unless File.exist?(executable_path)
+          raise Informative, "Failed to find executable inside framework: #{framework_path}"
+        end
+
+        uuids = list_bc_symbolmap_uuids(executable_path)
+        uuids.map {|uuid| find_bc_symbolmap(uuid)}.flatten
+      end
+
+      # @param [String] executable_path
+      #
+      # @return [Array<String>]
+      #
+      def list_bc_symbolmap_uuids(executable_path)
+        shell_executor.execute_for_output("otool -l #{executable_path} | grep uuid | awk {'print $2'}").split("\n")
+      end
+
+      # @param [String] uuid
+      #
+      # @return [String]
+      #
+      def find_bc_symbolmap(uuid)
+        Dir.glob(File.join(derived_data_path, "**", "#{uuid}.bcsymbolmap")).first
+      end
+    end
+  end
+end

data/lib/build_graph/builder.rb

@@ -0,0 +1,154 @@
+module XcodeArchiveCache
+  module BuildGraph
+    class Builder
+
+      include XcodeArchiveCache::Logs
+
+      # @param [XcodeArchiveCache::Xcodebuild::Executor] xcodebuild_executor
+      #
+      def initialize(native_target_finder, xcodebuild_executor)
+        @build_settings_loader = XcodeArchiveCache::BuildSettings::Loader.new(xcodebuild_executor)
+        @native_target_finder = native_target_finder
+        @sha_calculator = NodeShaCalculator.new
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] dependency_target
+      #
+      # @return [Graph]
+      #
+      def build_graph(dependent_target, dependency_target)
+        native_target_finder.set_platform_name_filter(dependency_target.platform_name)
+
+        build_settings = load_setting_for_target(dependent_target)
+        graph = Graph.new(dependency_target.project, build_settings)
+
+        add_to_graph(dependency_target, graph, true)
+        load_settings(graph)
+        calculate_shas(graph)
+
+        graph
+      end
+
+      private
+
+      # @return [XcodeArchiveCache::BuildSettings::Loader]
+      #
+      attr_accessor :build_settings_loader
+
+      # @return [XcodeArchive::BuildGraph::NativeTargetFinder]
+      #
+      attr_accessor :native_target_finder
+
+      # @return [XcodeArchiveCache::BuildGraph::NodeShaCalculator]
+      #
+      attr_accessor :sha_calculator
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      # @param [Graph] graph
+      # @param [Boolean] is_root
+      # @param [Array<String>] target_stack
+      #        Stack of native target display names at this level of traverse
+      #
+      # @return [Node] new or existing node
+      #
+      def add_to_graph(target, graph, is_root, target_stack = [])
+        debug("traversing #{target.display_name}")
+
+        unless target
+          raise ArgumentError.new, "Target is required"
+        end
+
+        display_name = target.display_name
+        existing_node = graph.node_by_name(display_name)
+        if existing_node
+          debug("already added this one")
+          return existing_node
+        end
+
+        if target_stack.include?(display_name)
+          target_stack.push(display_name)
+          raise Informative, "Circular dependency detected: #{target_stack.join(" -> ")}"
+        end
+
+        node = graph.node_by_name(display_name)
+        if node
+          debug("already traversed this one")
+          return node
+        else
+          debug("adding new node")
+          node = Node.new(display_name, target, is_root)
+          graph.nodes.push(node)
+        end
+
+        dependencies = []
+        target_stack.push(display_name)
+
+        dependency_targets = target.dependencies.map {|dependency| native_target_finder.find_for_dependency(dependency)} +
+            target.frameworks_build_phase.files.map {|file| native_target_finder.find_for_file(file)}
+
+        # PBXNativeTarget has no custom equality check
+        deduplicated_targets = dependency_targets.compact.uniq {|dependency_target| dependency_target.uuid + dependency_target.display_name}
+        debug("dependency targets: #{deduplicated_targets.map(&:display_name)}")
+
+        deduplicated_targets.each do |dependency_target|
+          dependency_node = add_to_graph(dependency_target, graph, false, target_stack)
+
+          unless dependency_node.dependent.include?(node)
+            debug("adding #{node.name} as dependent to #{dependency_node.name}")
+            dependency_node.dependent.push(node)
+          end
+
+          unless dependencies.include?(dependency_node)
+            debug("adding #{dependency_node.name} as dependency to #{node.name}")
+            dependencies.push(dependency_node)
+          end
+        end
+
+        target_stack.pop
+        node.dependencies.push(*dependencies)
+
+        debug("done with #{target.display_name}")
+        node
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      #
+      def calculate_shas(graph)
+        graph.nodes.each do |node|
+          debug("calculating sha for #{node.name}")
+          sha_calculator.calculate(node)
+          debug("sha calculated for #{node.name}: #{node.sha}")
+        end
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      #
+      def load_settings(graph)
+        counter = 1
+
+        graph.nodes.each do |node|
+          node_settings = load_setting_for_target(node.native_target)
+          unless node_settings
+            raise Informative, "No build settings loaded for #{node.name}"
+          end
+
+          node.build_settings = node_settings
+
+          debug("settings loaded for #{node.name} (#{counter} / #{graph.nodes.length})")
+          counter += 1
+        end
+      end
+
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      #
+      def load_setting_for_target(target)
+        info("loading settings for #{target.display_name}")
+
+        project_path = target.project.path
+        build_settings_loader.load_settings(project_path)
+        build_settings_loader.get_settings(project_path, target.display_name)
+      end
+    end
+  end
+end