xcode-archive-cache 0.0.6

data/lib/injection/pods_script_fixer.rb

@@ -0,0 +1,52 @@
+module XcodeArchiveCache
+  module Injection
+    class PodsScriptFixer
+
+      include XcodeArchiveCache::Logs
+
+      def initialize
+        @build_settings_interpolator = XcodeArchiveCache::BuildSettings::StringInterpolator.new
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+      # @param [String] products_dir
+      #
+      def fix_embed_frameworks_script(target, graph, products_dir)
+        build_settings = graph.dependent_build_settings
+        file_path = find_embed_frameworks_script(target, build_settings)
+        return unless file_path
+
+        info("fixing #{file_path}")
+        script = File.read(file_path)
+        graph.nodes.each do |node|
+          relative_product_path = "#{node.native_target.display_name}/#{node.product_file_name}"
+          script = script.gsub("${BUILT_PRODUCTS_DIR}/#{relative_product_path}", File.join(products_dir, relative_product_path))
+        end
+
+        File.open(file_path, "w") {|file| file.puts(script)}
+      end
+
+      private
+
+      # @return [XcodeArchiveCache::BuildSettings::StringInterpolator]
+      #
+      attr_reader :build_settings_interpolator
+
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+      # @param [XcodeArchiveCache::BuildSettings::Container] build_settings
+      #
+      # @return [String]
+      #
+      def find_embed_frameworks_script(target, build_settings)
+        target.shell_script_build_phases.each do |phase|
+          if phase.display_name == "[CP] Embed Pods Frameworks"
+            return build_settings_interpolator.interpolate(phase.shell_script, build_settings)
+                       .gsub(/^"|"$/, "")
+                       .strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/injection/storage.rb

@@ -0,0 +1,122 @@
+module XcodeArchiveCache
+  module Injection
+    class Storage
+
+      # @return [String]
+      #
+      attr_reader :container_dir_path
+
+      # @return [Hash{XcodeArchiveCache::BuildGraph::Node => String}]
+      #
+      attr_reader :headers_storage_dir_paths
+
+      # @param [String] path
+      #
+      def initialize(path)
+        @container_dir_path = path
+        @headers_storage_dir_paths = Hash.new
+
+        prepare_container_dir
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      # @param [String] path
+      # @param [Array<String>] file_paths
+      #
+      def store_headers(node, path, file_paths)
+        storage_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)))
+        end
+
+        save_header_storage_path(storage_path, node)
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      # @param [Array<String>] file_paths
+      #
+      def store_products(node, file_paths)
+        storage_path = prepare_storage(node)
+
+        file_paths.each do |path|
+          FileUtils.cp_r(path, storage_path)
+        end
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      def prepare_storage(node)
+        path = get_storage_path(node)
+        if File.exist?(path)
+          raise StandardError.new, "Injection storage path is already busy"
+        end
+
+        FileUtils.mkdir_p(path)
+        path
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # @return [String]
+      #
+      def get_storage_path(node)
+        File.join(container_dir_path, node.name)
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # @return [Array<String>]
+      #
+      def get_headers_storage_paths(node)
+        headers_storage_dir_paths[node.name]
+      end
+
+      def get_all_headers_storage_paths
+        headers_storage_dir_paths
+            .map {|_, path| path}
+            .flatten
+            .uniq
+      end
+
+      private
+
+      def prepare_container_dir
+        if File.exist?(container_dir_path)
+          FileUtils.rm_rf(container_dir_path)
+        end
+      end
+
+      # @param [String] path
+      #
+      # @return [String]
+      #
+      def get_full_header_storage_path(path)
+        File.absolute_path(path, container_dir_path)
+      end
+
+      # @param [String] path
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      def save_header_storage_path(path, node)
+        paths = get_headers_storage_paths(node) || []
+        containing_directory = File.dirname(path)
+        unless paths.include?(containing_directory)
+          paths.push(containing_directory)
+          set_all_headers_storage_paths(paths, node)
+        end
+      end
+
+      # @param [String] paths
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      def set_all_headers_storage_paths(paths, node)
+        headers_storage_dir_paths[node.name] = paths
+      end
+    end
+  end
+end

data/lib/logs/logs.rb

@@ -0,0 +1,47 @@
+module XcodeArchiveCache
+  module Logs
+
+    private
+
+    COMMON_LOGGER = Logger.new(STDOUT)
+    COMMON_LOGGER.formatter = proc do |_, _, _, msg|
+      "#{msg}\n"
+    end
+
+    ERROR_LOGGER = Logger.new(STDERR)
+    ERROR_LOGGER.formatter = COMMON_LOGGER.formatter
+
+    public
+
+    def set_log_level(level)
+      case level
+      when "info"
+        COMMON_LOGGER.level = Logger::Severity::INFO
+      when "verbose"
+        COMMON_LOGGER.level = Logger::Severity::DEBUG
+      when "nothing"
+        COMMON_LOGGER.level = Logger::Severity::ERROR
+      else
+        COMMON_LOGGER.level = Logger::Severity::ERROR
+      end
+    end
+
+    # @param [String] message
+    #
+    def debug(message)
+      COMMON_LOGGER.debug(message)
+    end
+
+    # @param [String] message
+    #
+    def info(message)
+      COMMON_LOGGER.info(message)
+    end
+
+    # @param [String] message
+    #
+    def error(message)
+      ERROR_LOGGER.fatal(message)
+    end
+  end
+end

data/lib/runner/runner.rb

@@ -0,0 +1,139 @@
+module XcodeArchiveCache
+  class Runner
+
+    include XcodeArchiveCache::Logs
+
+    # @param [XcodeArchiveCache::Config::Entry] config
+    #
+    def initialize(config)
+      @config = config
+
+      projects = list_projects
+      @native_target_finder = XcodeArchiveCache::BuildGraph::NativeTargetFinder.new(projects)
+
+      storage_path = File.absolute_path(config.storage.path)
+      @cache_storage = XcodeArchiveCache::ArtifactCache::LocalStorage.new(storage_path)
+      @rebuild_evaluator = XcodeArchiveCache::BuildGraph::RebuildEvaluator.new(@cache_storage)
+
+      @artifact_extractor = XcodeArchiveCache::ArtifactCache::ArtifactExtractor.new(@cache_storage)
+
+      derived_data_path = File.absolute_path(config.settings.derived_data_path)
+      @product_extractor = XcodeArchiveCache::Build::ProductExtractor.new(config.active_configuration.build_configuration, derived_data_path)
+
+      unpacked_artifacts_dir = File.absolute_path(File.join(derived_data_path, "cached"))
+      @injection_storage = XcodeArchiveCache::Injection::Storage.new(unpacked_artifacts_dir)
+      @injector = XcodeArchiveCache::Injection::Injector.new(config.active_configuration.build_configuration, @injection_storage)
+    end
+
+    def list_projects
+      file_path = File.absolute_path(config.file_path)
+
+      if config.is_a?(XcodeArchiveCache::Config::Project)
+        return [Xcodeproj::Project.new(file_path)]
+      elsif config.is_a?(XcodeArchiveCache::Config::Workspace)
+        workspace = Xcodeproj::Workspace.new_from_xcworkspace(file_path)
+        workspace_dir = File.expand_path("..", file_path)
+
+        return workspace.file_references.map {|file_reference| Xcodeproj::Project.open(file_reference.absolute_path(workspace_dir))}
+      end
+
+      raise Informative, "Configuration misses no entry point -- must have either a project or a workspace"
+    end
+
+    def run
+      perform_cleanup
+
+      config.targets.each do |target_config|
+        handle_target(target_config)
+      end
+    end
+
+    def perform_cleanup
+      if File.exist?(config.settings.derived_data_path)
+        FileUtils.rm_rf(config.settings.derived_data_path)
+      end
+    end
+
+    private
+
+    # @return [XcodeArchiveCache::Config::Entry]
+    #
+    attr_reader :config
+
+    # @param [XcodeArchiveCache::Config::Target] target_config
+    #
+    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}"
+      end
+
+      target_config.dependencies.each do |dependency_name|
+        handle_dependency(target, dependency_name)
+      end
+    end
+
+    # @param [Xcodeproj::Project::Object::PBXNativeTarget] target
+    # @param [String] dependency_name
+    #
+    def handle_dependency(target, dependency_name)
+      info("checking #{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)
+
+      evaluate_for_rebuild(graph)
+      extract_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
+    end
+
+    # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+    #
+    def extract_cached_artifacts(graph)
+      graph.nodes.each do |node|
+        next if node.rebuild
+
+        destination = @injection_storage.prepare_storage(node)
+        @artifact_extractor.unpack(node, destination)
+      end
+    end
+
+    # @param [Xcodeproj::Project::Object::PBXNativeTarget] root_target
+    # @param [XcodeArchiveCache::BuildGraph::Graph] graph
+    #
+    def rebuild_if_needed(xcodebuild_executor, root_target, graph)
+      rebuild_performer = XcodeArchiveCache::Build::Performer.new(xcodebuild_executor, config.settings.derived_data_path)
+      return unless rebuild_performer.should_rebuild?(graph)
+
+      @injector.perform_internal_injection(graph)
+      rebuild_performer.rebuild_missing(root_target, graph)
+
+      graph.nodes.each do |node|
+        next unless node.rebuild
+
+        file_paths = @product_extractor.list_product_contents(root_target.name, node)
+        @injection_storage.store_products(node, file_paths)
+        @cache_storage.store(node, @injection_storage.get_storage_path(node))
+      end
+    end
+  end
+end

data/lib/shell/executor.rb

@@ -0,0 +1,69 @@
+module XcodeArchiveCache
+  module Shell
+    class Executor
+
+      # @param [String] command
+      # @param [Boolean] print_command
+      #
+      # @return [String]
+      #
+      def execute_for_output(command, print_command = false)
+        actual_command = extend_for_pipefail(command, print_command)
+        output, status = Open3.capture2e(actual_command)
+
+        if status.exitstatus != 0
+          raise Informative, "#{command}\nexecution failed\n#{output}"
+        end
+
+        output
+      end
+
+      # @param [String] command
+      # @param [Boolean] print_command
+      #
+      # @return [Boolean] true if command succeeded and returned 0, false otherwise
+      #
+      def execute(command, print_command = false)
+        actual_command = extend_for_pipefail(command, print_command)
+        result = system actual_command
+
+        return false if result == nil
+        result
+      end
+
+      private
+
+      # @param [String] command
+      # @param [Boolean] print_command
+      #
+      # @return [String]
+      #
+      def extend_for_pipefail(command, print_command)
+        return command unless contains_pipes?(command)
+
+        "set #{pipefail_flags(print_command: print_command)} && #{command}"
+      end
+
+      # @param [String] command
+      #
+      # @return [Boolean]
+      #
+      def contains_pipes?(command)
+        command.include?("|")
+      end
+
+      # @param [Boolean] print_command
+      #
+      # @return [String]
+      #
+      def pipefail_flags(print_command)
+        flags = %w(e o)
+        if print_command
+          flags.insert(1, "x")
+        end
+
+        "-" + flags.join("")
+      end
+    end
+  end
+end

data/lib/xcode-archive-cache.rb

@@ -0,0 +1,59 @@
+require 'zip'
+require 'pathname'
+require 'fileutils'
+require 'logger'
+require 'tempfile'
+require 'find'
+require 'digest'
+require 'xcodeproj'
+require 'open3'
+require 'claide'
+
+require 'logs/logs'
+
+require 'command/command'
+require 'command/inject'
+
+require 'config/dsl'
+require 'config/config'
+
+require 'build_graph/graph'
+require 'build_graph/node'
+require 'build_graph/builder'
+require 'build_graph/native_target_finder'
+require 'build_graph/sha_calculator'
+require 'build_graph/rebuild_evaluator'
+
+require 'artifact_cache/abstract_storage'
+require 'artifact_cache/local_storage'
+require 'artifact_cache/artifact_extractor'
+require 'artifact_cache/archiver'
+
+require 'build/performer'
+require 'build/product_extractor'
+
+require 'build_settings/filter'
+require 'build_settings/loader'
+require 'build_settings/extractor'
+require 'build_settings/string_interpolator'
+require 'build_settings/parser'
+
+require 'injection/injector'
+require 'injection/pods_script_fixer'
+require 'injection/build_flags_changer'
+require 'injection/dependency_remover'
+require 'injection/headers_mover'
+require 'injection/storage'
+require 'injection/framework_embedder'
+
+require 'runner/runner'
+
+require 'shell/executor'
+
+require 'xcodebuild/executor'
+
+module XcodeArchiveCache
+  class Informative < StandardError
+    include CLAide::InformativeError
+  end
+end