xcode-archive-cache 0.0.6

data/lib/build_graph/graph.rb

@@ -0,0 +1,37 @@
+module XcodeArchiveCache
+  module BuildGraph
+    class Graph
+      # @return [Array<Node>] graph nodes
+      #
+      attr_reader :nodes
+
+      # @return [Xcodeproj::Project] project
+      #
+      attr_reader :project
+
+      # @return [XcodeArchiveCache::BuildSettings::Container] root target build settings
+      #
+      attr_reader :dependent_build_settings
+
+      # @param [Xcodeproj::Project] project
+      # @param [XcodeArchiveCache::BuildSettings::Container] dependent_build_settings
+      #
+      def initialize(project, dependent_build_settings)
+        @nodes = []
+        @project = project
+        @dependent_build_settings = dependent_build_settings
+      end
+
+      # @param [String] name
+      #        Native target display name
+      #
+      def node_by_name(name)
+        nodes.select {|node| node.name == name}.first
+      end
+
+      def to_s
+        nodes.map(&:to_s).join("\n")
+      end
+    end
+  end
+end

data/lib/build_graph/native_target_finder.rb

@@ -0,0 +1,101 @@
+module XcodeArchiveCache
+  module BuildGraph
+    class NativeTargetFinder
+
+      # @param [Array<Xcodeproj::Project>] projects
+      #
+      def initialize(projects)
+        @all_targets = projects
+                           .map {|project| unnest(project)}
+                           .flatten
+                           .uniq
+                           .map(&:native_targets)
+                           .flatten
+                           .select {|target| !target.test_target_type? }
+      end
+
+      # @param [String] platform_name
+      #
+      def set_platform_name_filter(platform_name)
+        @platform_name = platform_name
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXTargetDependency] dependency
+      #
+      # @return [Xcodeproj::Project::Object::PBXNativeTarget]
+      #
+      def find_for_dependency(dependency)
+        # targets from embedded projects are proxied
+        target = dependency.target ? dependency.target : dependency.target_proxy.proxied_object
+        target.is_a?(Xcodeproj::Project::Object::PBXNativeTarget) ? target : nil
+      end
+
+      # @param [Xcodeproj::Project::Object::PBXBuildFile] file
+      #
+      # @return [Xcodeproj::Project::Object::PBXNativeTarget]
+      #
+      def find_for_file(file)
+        if file.file_ref.is_a?(Xcodeproj::Project::Object::PBXReferenceProxy)
+          project = file.file_ref.remote_ref.container_portal_object
+          product_reference_uuid = file.file_ref.remote_ref.remote_global_id_string
+          find_with_product_ref_uuid(project, product_reference_uuid)
+        elsif file.file_ref.is_a?(Xcodeproj::Project::Object::PBXFileReference)
+          # products of sibling project targets are added as PBXFileReferences
+          targets = find_with_product_path(file.file_ref.path)
+          if targets.length > 1
+            raise Informative, "Found more than one target with product #{File.basename(file.file_ref.path)} in:\n#{targets.map(&:project)}"
+          end
+
+          targets.first
+        end
+      end
+
+      # @param [String] product_name
+      #
+      def find_for_product_name(product_name)
+        all_targets.select {|native_target| native_target.name == product_name || native_target.product_reference.display_name == product_name}
+                    .first
+      end
+
+      private
+
+      # @return [Array<Xcodeproj::Project::Object::PBXNativeTarget>]
+      #
+      attr_accessor :all_targets
+
+      # @return [String]
+      #
+      attr_accessor :platform_name
+
+      # @param [Xcodeproj::Project] project
+      #
+      # @return [Array<Xcodeproj::Project>]
+      #
+      #         Project + subprojects at all levels of nesting
+      #
+      def unnest(project)
+        nested_projects = project.files
+                              .select {|file_ref| File.extname(file_ref.path) == ".xcodeproj" && File.exist?(file_ref.real_path)}
+                              .map {|file_ref| Xcodeproj::Project.open(file_ref.real_path)}
+        subnested_projects = nested_projects.map {|nested_project| unnest(nested_project)}.flatten
+        [project] + nested_projects + subnested_projects
+      end
+
+      # @param [String] uuid
+      #
+      # @return [Xcodeproj::Project::Object::PBXNativeTarget]
+      #
+      def find_with_product_ref_uuid(project, uuid)
+        project.native_targets.select {|target| target.product_reference.uuid == uuid}.first
+      end
+
+      # @param [String] path
+      #
+      # @return [Array<Xcodeproj::Project::Object::PBXNativeTarget>]
+      #
+      def find_with_product_path(path)
+        all_targets.select {|target| target.platform_name == platform_name && target.product_reference.path == path}
+      end
+    end
+  end
+end

data/lib/build_graph/node.rb

@@ -0,0 +1,104 @@
+module XcodeArchiveCache
+  module BuildGraph
+    class Node
+
+      # @return [String] native target display name
+      #
+      attr_reader :name
+
+      # @return [Boolean]
+      #
+      attr_reader :is_root
+
+      # @return [Bool] should target be rebuilt
+      #
+      attr_accessor :rebuild
+
+      # @return [String] sha256 of (input files + build settings + dependency shas)
+      #
+      attr_accessor :sha
+
+      # @return [Array<XcodeArchiveCache::BuildGraph::Node>] dependent nodes
+      #
+      attr_reader :dependent
+
+      # @return [Array<XcodeArchiveCache::BuildGraph::Node>] dependency nodes
+      #
+      attr_reader :dependencies
+
+      # @return [Xcodeproj::Project::Object::PBXNativeTarget] corresponding native target
+      #
+      attr_reader :native_target
+
+      # @return [XcodeArchiveCache::BuildSettings::Container]
+      #
+      attr_accessor :build_settings
+
+      # @param [String] name
+      # @param [Xcodeproj::Project::Object::PBXNativeTarget] native_target
+      # @param [Boolean] is_root
+      #
+      def initialize(name, native_target, is_root = false)
+        @name = name
+        @native_target = native_target
+        @is_root = is_root
+        @dependent = []
+        @dependencies = []
+      end
+
+      def has_framework_product?
+        native_target.product_type == Xcodeproj::Constants::PRODUCT_TYPE_UTI[:framework]
+      end
+
+      def has_static_library_product?
+        native_target.product_type == Xcodeproj::Constants::PRODUCT_TYPE_UTI[:static_library]
+      end
+
+      # @return [String]
+      #
+      def product_file_name
+        return nil unless build_settings
+
+        product_name = build_settings[XcodeArchiveCache::BuildSettings::FULL_PRODUCT_NAME_KEY]
+        return product_name if product_name
+
+        product_name = native_target.product_reference.name
+        if has_framework_product? && product_name
+          product_file_name = product_name
+        end
+
+        unless product_file_name
+          product_file_name = File.basename(native_target.product_reference.real_path)
+        end
+
+        product_file_name
+      end
+
+      # @return [String]
+      #
+      def dsym_file_name
+        return nil unless build_settings
+
+        build_settings[XcodeArchiveCache::BuildSettings::DWARF_DSYM_FILE_NAME_KEY]
+      end
+
+      # @return [Array<Node>]
+      #         Direct + transitive dependents
+      #
+      def all_dependent_nodes
+        (dependent + dependent.map(&:all_dependent_nodes)).flatten.uniq
+      end
+
+      def ==(other_node)
+        other_node && native_target.uuid == other_node.native_target.uuid && native_target.project == other_node.native_target.project
+      end
+
+      def to_s
+        sha_string = sha ? sha : "<none>"
+        dependent_names = dependent.length > 0 ? dependent.map(&:name).join(", ") : "<none>"
+        dependency_names = dependencies.length > 0 ? dependencies.map(&:name).join(", ") : "<none>"
+        "#{name}\n\troot: #{is_root}\n\tproduct: #{product_file_name}\n\tsha: #{sha_string}\n\trebuild: #{rebuild}\n\tdependent: #{dependent_names}\n\tdependencies: #{dependency_names}"
+      end
+    end
+  end
+end

data/lib/build_graph/rebuild_evaluator.rb

@@ -0,0 +1,30 @@
+module XcodeArchiveCache
+  module BuildGraph
+    class RebuildEvaluator
+
+      # @param [XcodeArchiveCache::ArtifactCache::AbstractStorage] cache_storage
+      #
+      def initialize(cache_storage)
+        @cache_storage = cache_storage
+      end
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      def evaluate(node)
+        return if node.rebuild != nil
+
+        # we include dependency shas in every node sha calculation,
+        # so if some dependency changes, that change propagates
+        # all the way to the top level
+        #
+        node.rebuild = cache_storage.cached_artifact_path(node) == nil
+      end
+
+      private
+
+      # @return [XcodeArchiveCache::ArtifactCache::AbstractStorage]
+      #
+      attr_reader :cache_storage
+    end
+  end
+end

data/lib/build_graph/sha_calculator.rb

@@ -0,0 +1,102 @@
+module XcodeArchiveCache
+  module BuildGraph
+    class NodeShaCalculator
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      def calculate(node)
+        return if node.sha
+
+        dependency_shas = []
+        node.dependencies.each do |dependency_node|
+          calculate(dependency_node)
+          dependency_shas.push(dependency_node.sha)
+        end
+
+        auxiliary_file = Tempfile.new(node.name)
+        build_settings = settings_hash_to_string(node.build_settings.filtered)
+        save_auxiliary_data(build_settings, dependency_shas, auxiliary_file)
+
+        input_paths = list_input_paths(node)
+        node.sha = calculate_sha(input_paths + [auxiliary_file.path])
+        auxiliary_file.close(true)
+      end
+
+      private
+
+      # @param [XcodeArchiveCache::BuildGraph::Node] node
+      #
+      # @return [Array<String>]
+      #         List of input file paths for native target
+      #
+      def list_input_paths(node)
+        inputs = []
+
+        node.native_target.build_phases.each do |build_phase|
+          inputs << list_build_phase_inputs(build_phase)
+        end
+
+        # file path order should not affect evaluation result
+        inputs.flatten.compact.sort
+      end
+
+      # @param [Xcodeproj::Project::Object::AbstractBuildPhase] build_phase
+      #
+      # @return [Array<String>]
+      #         List of input file paths for build phase
+      #
+      def list_build_phase_inputs(build_phase)
+        build_phase.files_references.map do |file_ref|
+          next unless file_ref.is_a?(Xcodeproj::Project::Object::PBXFileReference)
+
+          begin
+            path = file_ref.real_path.to_s
+          rescue
+            next
+          end
+
+          if File.file?(path)
+            next path
+          elsif File.directory?(path)
+            # NOTE: find doesn't follow symlinks, shouldn't we follow them?
+            next Find.find(path).select {|found| File.file?(found)}
+          end
+
+          []
+        end
+      end
+
+      # @param [Hash{String => String}] hash
+      #
+      # @return [String]
+      #
+      def settings_hash_to_string(hash)
+        hash.map {|name, value| "#{name} = #{value}"}.join("\n")
+      end
+
+      # @param [Tempfile] tempfile
+      # @param [String] build_settings
+      # @param [Array<String>] dependency_shas
+      #
+      def save_auxiliary_data(build_settings, dependency_shas, tempfile)
+        file_contents = build_settings + dependency_shas.join("\n")
+        tempfile << file_contents
+        tempfile.flush
+      end
+
+      # @param [Array<String>] file_paths
+      #        File paths to include in resulting sha
+      #
+      # @return [String] sha256 over specified files
+      #
+      def calculate_sha(file_paths)
+        hash = Digest::SHA256.new
+        file_paths.map do |path|
+          hash << Digest::SHA256.file(path).hexdigest
+        end
+
+        hash.to_s
+      end
+    end
+  end
+end

data/lib/build_settings/extractor.rb

@@ -0,0 +1,80 @@
+module XcodeArchiveCache
+  module BuildSettings
+    class Extractor
+
+      def initialize
+        @parser = Parser.new
+        @filter = Filter.new
+      end
+
+      # @param [String] build_settings
+      #        Raw `xcodebuild -alltargets -showBuildSettings` output
+      #
+      # @return [Hash{String => Container}]
+      #         Target build settings keyed by target name
+      #
+      def extract_per_target(build_settings)
+        per_target_settings = build_settings.split("Build settings for action")
+        result = Hash.new
+
+        per_target_settings.each do |target_settings|
+          parsed_settings = parse(target_settings)
+          target_name = get_target_name(parsed_settings)
+          next unless target_name
+
+          filtered_settings = filter.filter(parsed_settings)
+          result[target_name] = Container.new(parsed_settings, filtered_settings)
+        end
+
+        result
+      end
+
+      private
+
+      # @return [Filter]
+      #
+      attr_reader :filter
+
+      # @return [Parser]
+      #
+      attr_reader :parser
+
+      # @param [String] settings
+      #
+      # @return [Hash{String => String}]
+      #         Setting values keyed by setting names
+      #
+      def parse(settings)
+        # remove leading spaces in each line, then split to lines
+        lines = settings.strip.gsub(/\n\s{2,}/, "\n").split("\n")
+        # drop "Build settings for action ..."
+        lines.drop(1)
+
+        result = Hash.new
+
+        lines.each do |line|
+          name = parser.parse_name(line)
+          next unless name
+
+          value = parser.parse_value(line)
+          next unless value
+
+          result[name] = value
+        end
+
+        result
+      end
+
+      TARGET_NAME_KEY = "TARGETNAME".freeze
+
+      # @param [Hash{String => String}] parsed_settings
+      #
+      # @return [String]
+      #         Name of target that settings apply to
+      #
+      def get_target_name(parsed_settings)
+        parsed_settings[TARGET_NAME_KEY]
+      end
+    end
+  end
+end