refinement 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eccee9a8f8fbbb164e975298ee97e5072b62b0404030ffec5f42438228c9a397
-  data.tar.gz: 174eb0ae0854f951902364a437e2ba2c1681c3607d09398156911cc53880d31c
+  metadata.gz: 695104530dba26775514c23cdf0e7802eb5cc2d83c421855c1a063b064a86a2e
+  data.tar.gz: 46d8e6cdb5774196354a4e13ca91f2bc5db969f572116856db0bf8498102a245
 SHA512:
-  metadata.gz: ec616c4a30c44be7e927dd5fe289ee1ec8ebb412e26ca3af37e168f0f2c0a48d3d042a672c897b377c97ef0932885210173f66ffc52005c7f6f30f408e8868ba
-  data.tar.gz: 20a704ef85107e0417bbaa0e163d6a65061ff520ca9ba7872112553807705a84aadd5d3fd83374ed939ae5bd6c5d533bfd3287a66e76b74637db5a8d3e95fd41
+  metadata.gz: 8e5c9694afb88668f2224a50863f37a2624dbcc0a7cdc5e32e4ad4e91f718a66658475a5b4fa3bbb33f7601dc63f5950982794a51d94e2654d90f0655b474b97
+  data.tar.gz: c2a655bf067bedd777d7dc2a5b2a0a4beede3250fb8708219884e63bfff4e66f7dd260ba7e4b6a47ba1a9538f2d819e4b4e763bef7084a12386b77e4a5a1fbc0

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Refinement Changes
+
+## 0.1.0 (2019-02-19)
+
+##### Enhancements
+
+* Initial implementation.  

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/exe/refine

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'refinement'
+require 'refinement/cli'
+
+Refinement::CLI.run(ARGV)

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,19 @@
+require 'cocoapods'
+
+Pod::Installer
+  .prepend(Module.new do
+             def perform_post_install_actions
+               super
+
+               return unless plugins.key?('refinement')
+
+               unless Gem::Version.create(Pod::VERSION) >= Gem::Version.create('1.6.0')
+                 raise Pod::Informative, 'Refinement requires a CocoaPods version >= 1.6.0'
+               end
+
+               require 'refinement/cocoapods_post_install_writer'
+               Pod::UI.message 'Writing refinement file' do
+                 Refinement::CocoaPodsPostInstallWriter.new(aggregate_targets, config, plugins['refinement']).write!
+               end
+             end
+           end)

data/lib/refinement/analyzer.rb

@@ -0,0 +1,348 @@
+module Refinement
+  # Analyzes changes in a repository
+  # and determines how those changes impact the targets in Xcode projects in the workspace.
+  class Analyzer
+    attr_reader :changeset, :workspace_path, :augmenting_paths_yaml_files
+    private :changeset, :workspace_path, :augmenting_paths_yaml_files
+
+    # Initializes an analyzer with a changeset, projects, and augmenting paths.
+    # @param changeset [Changeset]
+    # @param workspace_path [Pathname] path to a root workspace or project,
+    #   must be `nil` if `projects` are specified explicitly
+    # @param projects [Array<Xcodeproj::Project>] projects to find targets in,
+    #   must not be specified if `workspace_path` is not `nil`
+    # @param augmenting_paths_yaml_files [Array<Pathname>] paths to YAML files that provide augmenting paths by target,
+    #   must be `nil` if `augmenting_paths_by_target` are specified explicitly
+    # @param augmenting_paths_by_target [Hash<String, Array>] arrays of hashes keyed by target name
+    #  (or '*' for all targets)
+    #  describing paths or globs that each target should be considered to be using,
+    #  must not be specified if `augmenting_paths_yaml_files` is not `nil`
+    #
+    # @raise [ArgumentError] when conflicting arguments are given
+    #
+    def initialize(changeset:, workspace_path:, projects: nil,
+                   augmenting_paths_yaml_files:, augmenting_paths_by_target: nil)
+
+      @changeset = changeset
+
+      raise ArgumentError, 'Can only specify one of workspace_path and projects' if workspace_path && projects
+      @workspace_path = workspace_path
+      @projects = projects
+
+      if augmenting_paths_yaml_files && augmenting_paths_by_target
+        raise ArgumentError, 'Can only specify one of augmenting_paths_yaml_files and augmenting_paths_by_target'
+      end
+      @augmenting_paths_yaml_files = augmenting_paths_yaml_files
+      @augmenting_paths_by_target = augmenting_paths_by_target
+    end
+
+    # @return [Array<AnnotatedTarget>] targets from the projects annotated with their changes, based upon
+    #   the changeset
+    def annotate_targets!
+      @annotate_targets ||= annotated_targets
+    end
+
+    # @param scheme_path [Pathname] the absolute path to the scheme to be filtered
+    # @param change_level [Symbol] the change level at which a target must have changed in order
+    #  to remain in the scheme. defaults to `:full_transitive`
+    # @param filter_when_scheme_has_changed [Boolean] whether the scheme should be filtered
+    #   even when the changeset includes the scheme's path as changed.
+    #   Defaults to `false`
+    # @param log_changes [Boolean] whether modifications to the scheme are logged.
+    #   Defaults to `false`
+    # @return [Xcodeproj::XCScheme] a scheme whose unchanged targets have been removed
+    def filtered_scheme(scheme_path:, change_level: :full_transitive, filter_when_scheme_has_changed: false, log_changes: false)
+      scheme = Xcodeproj::XCScheme.new(scheme_path)
+
+      if filter_when_scheme_has_changed ||
+         !UsedPath.new(path: Pathname(scheme_path), inclusion_reason: 'scheme').find_in_changeset(changeset)
+
+        changes_by_suite_name = Hash[annotate_targets!
+                                .map { |at| [at.xcode_target.name, at.change_reason(level: change_level)] }]
+
+        doc = scheme.doc
+
+        xpaths = %w[
+          //*/TestableReference/BuildableReference
+          //*/BuildActionEntry/BuildableReference
+        ]
+        xpaths.each do |xpath|
+          doc.get_elements(xpath).to_a.each do |buildable_reference|
+            suite_name = buildable_reference.attributes['BlueprintName']
+            if (change_reason = changes_by_suite_name[suite_name])
+              puts "#{suite_name} changed because #{change_reason}" if log_changes
+              next
+            end
+            puts "#{suite_name} did not change, removing from scheme" if log_changes
+            buildable_reference.parent.remove
+          end
+        end
+      end
+
+      scheme
+    end
+
+    # @return [String] a string suitable for user display that explains target changes
+    # @param include_unchanged_targets [Boolean] whether targets that have not changed should also be displayed
+    # @param change_level [Symbol] the change level used for computing whether a target has changed
+    def format_changes(include_unchanged_targets: false, change_level: :full_transitive)
+      annotate_targets!.group_by { |target| target.xcode_target.project.path.to_s }.sort_by(&:first)
+                       .map do |project, annotated_targets|
+        changes = annotated_targets.sort_by { |annotated_target| annotated_target.xcode_target.name }
+                                   .map do |annotated_target|
+          change_reason = annotated_target.change_reason(level: change_level)
+          next if !include_unchanged_targets && !change_reason
+          change_reason ||= 'did not change'
+          "\t#{annotated_target.xcode_target}: #{change_reason}"
+        end.compact
+        "#{project}:\n#{changes.join("\n")}" unless changes.empty?
+      end.compact.join("\n")
+    end
+
+    private
+
+    # @return [Array<Xcodeproj::Project>]
+    def projects
+      @projects ||= find_projects(workspace_path)
+    end
+
+    # @return [Hash<String,Array<Hash>>]
+    def augmenting_paths_by_target
+      @augmenting_paths_by_target ||= begin
+        require 'yaml'
+        augmenting_paths_yaml_files.reduce({}) do |augmenting_paths_by_target, yaml_file|
+          yaml_file = Pathname(yaml_file).expand_path(changeset.repository)
+          yaml = YAML.safe_load(yaml_file.read)
+          augmenting_paths_by_target.merge(yaml) do |_target_name, prior_paths, new_paths|
+            prior_paths + new_paths
+          end
+        end
+      end
+    end
+
+    # @return [Array<AnnotatedTarget>] targets in the given list of Xcode projects,
+    #   annotated according to the given changeset
+    def annotated_targets
+      workspace_modification = find_workspace_modification_in_changeset
+      project_changes = Hash[projects.map do |project|
+        [project, find_project_modification_in_changeset(project: project) || workspace_modification]
+      end]
+
+      require 'tsort'
+      targets = projects.flat_map(&:targets)
+      targets_by_uuid = Hash[targets.map { |t| [t.uuid, t] }]
+      targets_by_name = Hash[targets.map { |t| [t.name, t] }]
+      targets_by_product_name = Hash[targets.map do |t|
+        next unless t.respond_to?(:product_reference)
+        [File.basename(t.product_reference.path), t]
+      end.compact]
+
+      find_dep = ->(td) { targets_by_uuid[td.native_target_uuid] || targets_by_name[td.name] }
+      target_deps = lambda do |target|
+        target_dependencies = []
+        target.dependencies.each do |td|
+          target_dependencies << find_dep[td]
+        end
+
+        # TODO: also resolve OTHER_LDFLAGS?
+        # yay auto-linking
+        if (phase = target.frameworks_build_phases)
+          phase.files_references.each do |fr|
+            if (dt = fr && fr.path && targets_by_product_name[File.basename(fr.path)])
+              target_dependencies << dt
+            end
+          end
+        end
+
+        target_dependencies
+      end
+
+      targets = TSort.tsort(
+        ->(&b) { targets.each(&b) },
+        ->(target, &b) { target_deps[target].each(&b) }
+      )
+
+      targets.each_with_object({}) do |target, h|
+        change_reason = project_changes[target.project] || find_target_modification_in_changeset(target: target)
+
+        h[target] = AnnotatedTarget.new(
+          target: target,
+          dependencies: target_deps[target].map { |td| h.fetch(td) },
+          change_reason: change_reason
+        )
+      end.values
+    end
+
+    # @return [Array<Xcodeproj::Project>] the projects found by walking the
+    #  project/workspace at the given path
+    # @param  path [Pathname] path to a `.xcodeproj` or `.xcworkspace` on disk
+    def find_projects(path)
+      seen = {}
+      find_projects_cached = lambda do |project_path|
+        return if seen.key?(project_path)
+
+        case File.extname(project_path)
+        when '.xcodeproj'
+          project = Xcodeproj::Project.open(project_path)
+          seen[project_path] = project
+          project.files.each do |file_reference|
+            next unless File.extname(file_reference.path) == '.xcodeproj'
+
+            find_projects_cached[file_reference.real_path]
+          end
+        when '.xcworkspace'
+          workspace = Xcodeproj::Workspace.new_from_xcworkspace(project_path)
+          workspace.file_references.each do |file_reference|
+            next unless File.extname(file_reference.path) == '.xcodeproj'
+
+            find_projects_cached[file_reference.absolute_path(File.dirname(project_path))]
+          end
+        else
+          raise ArgumentError, "Unknown path #{project_path.inspect}"
+        end
+      end
+      find_projects_cached[path]
+
+      seen.values
+    end
+
+    # @yieldparam used_path [UsedPath] an absolute path that belongs to the given target
+    # @return [Void]
+    # @param target [Xcodeproj::Project::AbstractTarget]
+    def target_each_file_path(target:)
+      return enum_for(__method__, target: target) unless block_given?
+
+      expand_build_settings = lambda do |s|
+        return [s] unless s =~ /\$(?:\{([_a-zA-Z0-0]+?)\}|\(([_a-zA-Z0-0]+?)\))/
+        match, key = Regexp.last_match.values_at(0, 1, 2).compact
+        substitutions = target.resolved_build_setting(key, true).values.compact.uniq
+        substitutions.flat_map do |sub|
+          expand_build_settings[s.gsub(match, sub)]
+        end
+      end
+
+      target.build_configuration_list.build_configurations.each do |build_configuration|
+        ref = build_configuration.base_configuration_reference
+        next unless ref
+        yield UsedPath.new(path: ref.real_path,
+                           inclusion_reason: "base configuration reference for #{build_configuration}")
+      end
+
+      target.build_phases.each do |build_phase|
+        build_phase.files_references.each do |fr|
+          next unless fr
+          yield UsedPath.new(path: fr.real_path,
+                             inclusion_reason: "#{build_phase.display_name.downcase.chomp('s')} file")
+        end
+      end
+
+      target.shell_script_build_phases.each do |shell_script_build_phase|
+        %w[input_file_list_paths output_file_list_paths input_paths output_paths].each do |method|
+          next unless (paths = shell_script_build_phase.public_send(method))
+          file_type = method.tr('_', ' ').chomp('s')
+          paths.each do |config_path|
+            next unless config_path
+            expand_build_settings[config_path].each do |path|
+              path = Pathname(path).expand_path(target.project.project_dir)
+              yield UsedPath.new(path: path,
+                                 inclusion_reason: "#{shell_script_build_phase.name} build phase #{file_type}")
+            end
+          end
+        end
+      end
+
+      %w[INFOPLIST_FILE HEADER_SEARCH_PATHS FRAMEWORK_SEARCH_PATHS USER_HEADER_SEARCH_PATHS].each do |build_setting|
+        target.resolved_build_setting(build_setting, true).each_value do |paths|
+          Array(paths).each do |path|
+            next unless path
+            path = Pathname(path).expand_path(target.project.project_dir)
+            yield UsedPath.new(path: path, inclusion_reason: "#{build_setting} value")
+          end
+        end
+      end
+    end
+
+    # @return [FileModification,Nil] a modification to a file that is used by the given target, or `nil`
+    #   if none if found
+    # @param target [Xcodeproj::Project::AbstractTarget]
+    def find_target_modification_in_changeset(target:)
+      augmenting_paths = used_paths_from_augmenting_paths_by_target[target.name]
+      find_in_changeset = ->(path) { path.find_in_changeset(changeset) }
+      Refinement.map_find(augmenting_paths, &find_in_changeset) ||
+        Refinement.map_find(target_each_file_path(target: target), &find_in_changeset)
+    end
+
+    # @yieldparam used_path [UsedPath] an absolute path that belongs to the given project
+    # @return [Void]
+    # @param project [Xcodeproj::Project]
+    def project_each_file_path(project:)
+      return enum_for(__method__, project: project) unless block_given?
+
+      yield UsedPath.new(path: project.path, inclusion_reason: 'project directory')
+
+      project.root_object.build_configuration_list.build_configurations.each do |build_configuration|
+        ref = build_configuration.base_configuration_reference
+        next unless ref
+        yield UsedPath.new(path: ref.real_path,
+                           inclusion_reason: "base configuration reference for #{build_configuration}")
+      end
+    end
+
+    # # @return [FileModification,Nil] a modification to a file that is directly used by the given project, or `nil`
+    #   if none if found
+    # @note This method does not take into account whatever file paths targets in the project may reference
+    # @param project [Xcodeproj::Project]
+    def find_project_modification_in_changeset(project:)
+      Refinement.map_find(project_each_file_path(project: project)) do |path|
+        path.find_in_changeset(changeset)
+      end
+    end
+
+    # @return [FileModification,Nil] a modification to the workspace itself, or `nil`
+    #   if none if found
+    # @note This method does not take into account whatever file paths projects or
+    #   targets in the workspace path may reference
+    def find_workspace_modification_in_changeset
+      return unless workspace_path
+
+      UsedPath.new(path: workspace_path, inclusion_reason: 'workspace directory')
+              .find_in_changeset(changeset)
+    end
+
+    # @return [Hash<String,UsedPath>]
+    def used_paths_from_augmenting_paths_by_target
+      @used_paths_from_augmenting_paths_by_target ||= begin
+        repo = changeset.repository
+        used_paths_from_augmenting_paths_by_target =
+          augmenting_paths_by_target.each_with_object({}) do |(name, augmenting_paths), h|
+            h[name] = augmenting_paths.map do |augmenting_path|
+              case augmenting_path.keys.sort
+              when %w[inclusion_reason path], %w[inclusion_reason path yaml_keypath]
+                kwargs = {
+                  path: Pathname(augmenting_path['path']).expand_path(repo),
+                  inclusion_reason: augmenting_path['inclusion_reason']
+                }
+                if augmenting_path.key?('yaml_keypath')
+                  kwargs[:yaml_keypath] = augmenting_path['yaml_keypath']
+                  UsedPath::YAML.new(**kwargs)
+                else
+                  UsedPath.new(**kwargs)
+                end
+              when %w[glob inclusion_reason]
+                UsedGlob.new(glob: File.expand_path(augmenting_path['glob'], repo),
+                             inclusion_reason: augmenting_path['inclusion_reason'])
+              else
+                raise ArgumentError,
+                      "unhandled set of keys in augmenting paths dictionary entry: #{augmenting_path.keys.inspect}"
+              end
+            end
+          end
+        wildcard_paths = used_paths_from_augmenting_paths_by_target.fetch('*', [])
+
+        Hash.new do |h, k|
+          h[k] = wildcard_paths + used_paths_from_augmenting_paths_by_target.fetch(k, [])
+        end
+      end
+    end
+  end
+end

data/lib/refinement/annotated_target.rb

@@ -0,0 +1,71 @@
+module Refinement
+  # A target, annotated with any changes
+  class AnnotatedTarget
+    # @return [Xcodeproj::Project::AbstactTarget] the target in an Xcode project
+    attr_reader :xcode_target
+
+    # @return [String,Nil] the reason why the target has changed, or `nil` if it has not changed
+    attr_reader :direct_change_reason
+    private :direct_change_reason
+
+    def initialize(target:, change_reason:, dependencies: [])
+      @xcode_target = target
+      @direct_change_reason = change_reason
+      @dependencies = dependencies
+      dependencies.each do |dependency|
+        dependency.depended_upon_by << self
+      end
+      @depended_upon_by = []
+    end
+
+    # @visibility private
+    def to_s
+      xcode_target.to_s
+    end
+
+    CHANGE_LEVELS = %i[
+      itself
+      at_most_n_away
+      full_transitive
+    ].freeze
+    private_constant :CHANGE_LEVELS
+
+    # @return [Boolean] whether the target has changed, at the given change level
+    # @param level [Symbol,(:at_most_n_away,Integer)] change level, e.g. :itself, :at_most_n_away, :full_transitive
+    def change_reason(level:)
+      @change_reason ||= {}
+      # need to use this form for memoization, as opposed to ||=,
+      # since this will (often) be nil and it makes a significant performance difference
+      return @change_reason[level] if @change_reason.key?(level)
+
+      @change_reason[level] =
+        case level
+        when :itself
+          direct_change_reason
+        when :full_transitive
+          direct_change_reason || Refinement.map_find(dependencies) do |dependency|
+            next unless (dependency_change_reason = dependency.change_reason(level: level))
+            "dependency #{dependency} changed because #{dependency_change_reason}"
+          end
+        when proc { |symbol, int| (symbol == :at_most_n_away) && int.is_a?(Integer) }
+          distance_from_target = level.last
+          raise ArgumentError, "level must be positive, not #{distance_from_target}" if distance_from_target < 0
+          change_reason = direct_change_reason
+          if distance_from_target > 0
+            change_reason ||= Refinement.map_find(dependencies) do |dependency|
+              next unless (dependency_change_reason = dependency.change_reason(level: [:at_most_n_away, level.last.pred]))
+              "dependency #{dependency} changed because #{dependency_change_reason}"
+            end
+          end
+          change_reason
+        else
+          raise Error, "No known change level #{level.inspect}, only #{CHANGE_LEVELS.inspect} are known"
+        end
+    end
+
+    # @return [Array<AnnotatedTarget>] the list of annotated targets this target depends upon
+    attr_reader :dependencies
+    # @return [Array<AnnotatedTarget>] the list of annotated targets that depend upon this target
+    attr_reader :depended_upon_by
+  end
+end

data/lib/refinement/changeset/file_modification.rb

@@ -0,0 +1,131 @@
+module Refinement
+  class Changeset
+    # Represents a modification to a single file or directory on disk
+    class FileModification
+      # @return [Symbol] the change type for directories
+      DIRECTORY_CHANGE_TYPE = :'had contents change'
+
+      # @return [Pathname] the path to the modified file
+      attr_reader :path
+
+      # @return [Pathname, Nil] the prior path to the modified file, or `nil` if it was not renamed or copied
+      attr_reader :prior_path
+
+      # @return [#to_s] the type of change that happened to this file
+      attr_reader :type
+
+      def initialize(path:, type:,
+                     prior_path: nil,
+                     contents_reader: -> { nil },
+                     prior_contents_reader: -> { nil })
+        @path = path
+        @type = type
+        @prior_path = prior_path
+        @contents_reader = contents_reader
+        @prior_contents_reader = prior_contents_reader
+      end
+
+      # @visibility private
+      def to_s
+        case type
+        when DIRECTORY_CHANGE_TYPE
+          "contents of dir `#{path}` changed"
+        else
+          message = "file `#{path}` #{type}"
+          message += " (from #{prior_path})" if prior_path
+          message
+        end
+      end
+
+      # @visibility private
+      def inspect
+        "#<#{self.class} path=#{path.inspect} type=#{type.inspect} prior_path=#{prior_path.inspect}" \
+          " contents=#{contents.inspect} prior_contents=#{prior_contents.inspect}>"
+      end
+
+      # @visibility private
+      def hash
+        path.hash ^ type.hash
+      end
+
+      # @visibility private
+      def ==(other)
+        return unless other.is_a?(FileModification)
+        (path == other.path) && (type == other.type) && prior_path == other.prior_path
+      end
+
+      # @visibility private
+      def eql?(other)
+        return unless other.is_a?(FileModification)
+        path.eql?(other.path) && type.eql?(other.type) && prior_path.eql?(other.prior_path)
+      end
+
+      # @return [String,Nil] a YAML string representing the diff of the file
+      #  from the prior revision to the current revision at the given keypath
+      #  in the YAML, or `nil` if there is no diff
+      # @param keypath [Array] a list of indices passed to `dig`.
+      #  An empty array is equivalent to the entire YAML document
+      def yaml_diff(keypath)
+        require 'yaml'
+
+        dig_yaml = lambda do |yaml|
+          return yaml if DOES_NOT_EXIST == yaml
+          object = YAML.safe_load(yaml, [Symbol])
+          if keypath.empty?
+            object
+          elsif object.respond_to?(:dig)
+            object.dig(*keypath)
+          else # backwards compatibility
+            keypath.reduce(object) do |acc, elem|
+              acc[elem]
+            end
+          end
+        end
+
+        prior = dig_yaml[prior_contents]
+        current = dig_yaml[contents]
+
+        require 'xcodeproj/differ'
+
+        return unless (diff = Xcodeproj::Differ.diff(
+          prior,
+          current,
+          key_1: 'prior_revision',
+          key_2: 'current_revision'
+        ))
+
+        diff.to_yaml.prepend("#{path} changed at keypath #{keypath.inspect}\n")
+      end
+
+      DOES_NOT_EXIST = Object.new.tap do |o|
+        class << o
+          def to_s
+            'DOES NOT EXISTS'
+          end
+          alias_method :inspect, :to_s
+        end
+      end.freeze
+      private_constant :DOES_NOT_EXIST
+
+      # @return [String] the current contents of the file
+      def contents
+        @contents ||=
+          begin
+            @contents_reader[].tap { @contents_reader = nil } || DOES_NOT_EXIST
+          rescue StandardError
+            DOES_NOT_EXIST
+          end
+      end
+
+      # @return [String] the prior contents of the file
+      def prior_contents
+        @prior_contents ||=
+          begin
+            @prior_contents_reader[].tap { @prior_contents_reader = nil } || DOES_NOT_EXIST
+          rescue StandardError
+            DOES_NOT_EXIST
+          end
+      end
+    end
+  end
+end

data/lib/refinement/changeset.rb

@@ -0,0 +1,213 @@
+require 'cocoapods/executable'
+require 'set'
+
+module Refinement
+  # Represents a set of changes in a repository between a prior revision and the current state
+  class Changeset
+    # An error that happens when computing a git diff
+    class GitError < Error; end
+    require 'refinement/changeset/file_modification'
+
+    # @return [Pathname] the path to the repository
+    attr_reader :repository
+    # @return [Array<FileModification>] the modifications in the changeset
+    attr_reader :modifications
+    # @return [Hash<Pathname,FileModification>] modifications keyed by relative path
+    attr_reader :modified_paths
+    # @return [Hash<Pathname,FileModification>] modifications keyed by relative path
+    attr_reader :modified_absolute_paths
+
+    private :modifications, :modified_paths, :modified_absolute_paths
+
+    def initialize(repository:, modifications:)
+      @repository = repository
+      @modifications = self.class.add_directories(modifications).uniq.freeze
+
+      @modified_paths = {}
+      @modifications
+        .each { |mod| @modified_paths[mod.path] = mod }
+        .each { |mod| @modified_paths[mod.prior_path] ||= mod if mod.prior_path }
+      @modified_paths.freeze
+
+      @modified_absolute_paths = {}
+      @modified_paths
+        .each { |path, mod| @modified_absolute_paths[path.expand_path(repository).freeze] = mod }
+      @modified_absolute_paths.freeze
+    end
+
+    # @visibility private
+    # @return [Array<FileModification>] file modifications that include modifications for each
+    #                                   directory that has had a child modified
+    # @param  modifications [Array<FileModification>] The modifications to add directory modifications to
+    def self.add_directories(modifications)
+      dirs = Set.new
+      add = lambda { |path|
+        break unless dirs.add?(path)
+        add[path.dirname]
+      }
+      modifications.each do |mod|
+        add[mod.path.dirname]
+        add[mod.prior_path.dirname] if mod.prior_path
+      end
+      modifications +
+        dirs.map { |d| FileModification.new(path: Pathname("#{d}/").freeze, type: FileModification::DIRECTORY_CHANGE_TYPE) }
+    end
+
+    # @return [FileModification,Nil] the changeset for the given absolute path,
+    #   or `nil` if the given path is un-modified
+    # @param absolute_path [Pathname]
+    def find_modification_for_path(absolute_path:)
+      modified_absolute_paths[absolute_path]
+    end
+
+    # @return [Array<String>] An array of patterns converted from a
+    #         {Dir.glob} pattern to patterns that {File.fnmatch} can handle.
+    #         This is used by the {#relative_glob} method to emulate
+    #         {Dir.glob}.
+    #
+    #   The expansion provides support for:
+    #
+    #   - Literals
+    #
+    #       dir_glob_equivalent_patterns('{file1,file2}.{h,m}')
+    #       => ["file1.h", "file1.m", "file2.h", "file2.m"]
+    #
+    #   - Matching the direct children of a directory with `**`
+    #
+    #       dir_glob_equivalent_patterns('Classes/**/file.m')
+    #       => ["Classes/**/file.m", "Classes/file.m"]
+    #
+    # @param [String] pattern   A {Dir#glob} like pattern.
+    #
+    def dir_glob_equivalent_patterns(pattern)
+      pattern = pattern.gsub('/**/', '{/**/,/}')
+      values_by_set = {}
+      pattern.scan(/\{[^}]*\}/) do |set|
+        values = set.gsub(/[{}]/, '').split(',')
+        values_by_set[set] = values
+      end
+
+      if values_by_set.empty?
+        [pattern]
+      else
+        patterns = [pattern]
+        values_by_set.each do |set, values|
+          patterns = patterns.flat_map do |old_pattern|
+            values.map do |value|
+              old_pattern.gsub(set, value)
+            end
+          end
+        end
+        patterns
+      end
+    end
+    private :dir_glob_equivalent_patterns
+
+    # @return [FileModification,Nil] the modification for the given absolute glob,
+    #   or `nil` if no files matching the glob were modified
+    # @note Will only return a single (arbitrary) matching modification, even if there are
+    #   multiple modifications that match the glob
+    # @param absolute_glob [String] a glob pattern for absolute paths, suitable for an invocation of `Dir.glob`
+    def find_modification_for_glob(absolute_glob:)
+      absolute_globs = dir_glob_equivalent_patterns(absolute_glob)
+      _path, modification = modified_absolute_paths.find do |absolute_path, _modification|
+        absolute_globs.any? do |glob|
+          File.fnmatch?(glob, absolute_path, File::FNM_CASEFOLD | File::FNM_PATHNAME)
+        end
+      end
+      modification
+    end
+
+    # @return [FileModification,Nil] a modification and yaml diff for the keypath at the given absolute path,
+    #  or `nil` if the value at the given keypath is un-modified
+    # @param absolute_path [Pathname]
+    # @param keypath [Array]
+    def find_modification_for_yaml_keypath(absolute_path:, keypath:)
+      return unless (file_modification = find_modification_for_path(absolute_path: absolute_path))
+      diff = file_modification.yaml_diff(keypath)
+      return unless diff
+      [file_modification, diff]
+    end
+
+    # @return [Changeset] the changes in the given git repository between the given revision and HEAD
+    # @param repository [Pathname,String]
+    # @param base_revision [String]
+    def self.from_git(repository:, base_revision:)
+      merge_base = git!('merge-base', base_revision, 'HEAD', chdir: repository).strip
+      diff = git!('diff', '--raw', '-z', merge_base, chdir: repository)
+      modifications = parse_raw_diff(diff, repository: repository, base_revision: base_revision).freeze
+
+      new(repository: repository, modifications: modifications)
+    end
+
+    CHANGE_TYPES = {
+      :'was added' => 'A',
+      :'was copied' => 'C',
+      :'was deleted' => 'D',
+      :'was modified' => 'M',
+      :'was renamed' => 'R',
+      :'changed type' => 'T',
+      :'is unmerged' => 'U',
+      :'changed in an unknown way' => 'X'
+    }.freeze
+    private_constant :CHANGE_TYPES
+
+    CHANGE_CHARACTERS = CHANGE_TYPES.invert.freeze
+    private_constant :CHANGE_CHARACTERS
+
+    # Parses the raw diff into FileModification objects
+    # @return [Array<FileModification>]
+    # @param diff [String] a diff generated by `git diff --raw -z`
+    # @param repository [Pathname] the path to the repository
+    # @param base_revision [String] the base revision the diff was constructed agains
+    def self.parse_raw_diff(diff, repository:, base_revision:)
+      # since we're null separating the chunks (to avoid dealing with path escaping) we have to reconstruct
+      # the chunks into individual diff entries. entries always start with a colon so we can use that to signal if
+      # we're on a new entry
+      parsed_lines = diff.split("\0").each_with_object([]) do |chunk, lines|
+        lines << [] if chunk.start_with?(':')
+        lines.last << chunk
+      end
+
+      parsed_lines.map do |split_line|
+        # change chunk (letter + optional similarity percentage) will always be the last part of first line chunk
+        change_chunk = split_line[0].split(/\s/).last
+
+        new_path = Pathname(split_line[2]).freeze if split_line[2]
+        old_path = Pathname(split_line[1]).freeze
+        prior_path = old_path if new_path
+        # new path if one exists, else existing path. new path only exists for rename and copy
+        changed_path = new_path || old_path
+
+        change_character = change_chunk[0]
+        # returns 0 when a similarity percentage isn't specified by git.
+        _similarity = change_chunk[1..3].to_i
+
+        FileModification.new(
+          path: changed_path,
+          type: CHANGE_CHARACTERS[change_character],
+          prior_path: prior_path,
+          contents_reader: -> { repo.join(changed_path).read },
+          prior_contents_reader: lambda {
+            git!('show', "#{base_revision}:#{prior_path || changed_path}", chdir: repository)
+          }
+        )
+      end
+    end
+
+    # @return [String] the STDOUT of the git command
+    # @raise [GitError] when running the git command fails
+    # @param command [String] the base git command to run
+    # @param args [String...] arguments to the git command
+    # @param chdir [String,Pathname] the directory to run the git command in
+    def self.git!(command, *args, chdir:)
+      require 'open3'
+      out, err, status = Open3.capture3('git', command, *args, chdir: chdir.to_s)
+      unless status.success?
+        raise GitError, "Running git #{command} failed (#{status.to_s.gsub(/pid \d+\s*/, '')}):\n\n#{err}"
+      end
+      out
+    end
+    private_class_method :git!
+  end
+end

data/lib/refinement/cli.rb

@@ -0,0 +1,113 @@
+require 'claide'
+
+module Refinement
+  # @visibility private
+  class CLI < CLAide::Command
+    self.abstract_command = true
+    self.command = 'refine'
+    self.version = VERSION
+
+    self.summary = 'Generates a list of Xcode targets to build & test as a result of a diff'
+
+    def self.options
+      super + [
+        ['--repository=REPOSITORY', 'Path to repository'],
+        ['--workspace=WORKSPACE_PATH', 'Path to project or workspace'],
+        ['--scheme=SCHEME_PATH', 'Path to scheme to be filtered'],
+        ['--augmenting-paths-yaml-files=PATH1,PATH2...', 'Paths to augmenting yaml files, relative to the repository path'],
+        ['--[no-]print-changes', 'Print the change reason for changed targets'],
+        ['--[no-]print-scheme-changes', 'Print the change reason for targets in the given scheme'],
+        ['--change-level=LEVEL', 'Change level at which a target must have changed in order to be considered changed. ' \
+                                 'One of `full-transitive`, `itself`, or an integer']
+      ]
+    end
+
+    def initialize(argv)
+      @repository = argv.option('repository', '.')
+      @workspace = argv.option('workspace')
+      @scheme = argv.option('scheme')
+      @augmenting_paths_yaml_files = argv.option('augmenting-paths-yaml-files', '')
+      @print_changes = argv.flag?('print-changes', false)
+      @print_scheme_changes = argv.flag?('print-scheme-changes', false)
+      @change_level = argv.option('change-level', 'full-transitive')
+
+      super
+    end
+
+    def run
+      changeset = compute_changeset
+
+      analyzer = Refinement::Analyzer.new(changeset: changeset,
+                                          workspace_path: @workspace,
+                                          augmenting_paths_yaml_files: @augmenting_paths_yaml_files)
+      analyzer.annotate_targets!
+
+      puts analyzer.format_changes if @print_changes
+
+      return unless @scheme
+      analyzer.filtered_scheme(scheme_path: @scheme, log_changes: @print_scheme_changes)
+              .save_as(@scheme.gsub(%r{\.(xcodeproj|xcworkspace)/.+}, '.\1'), File.basename(@scheme, '.xcscheme'), true)
+    end
+
+    def validate!
+      super
+
+      File.directory?(@repository) || help!("Unable to find a repository at #{@repository.inspect}")
+
+      @workspace || help!('Must specify a project or workspace path')
+      File.directory?(@workspace) || help!("Unable to find a project or workspace at #{@workspace.inspect}")
+
+      @augmenting_paths_yaml_files = @augmenting_paths_yaml_files.split(',')
+      @augmenting_paths_yaml_files.each do |yaml_path|
+        yaml_path = File.join(@repository, yaml_path)
+        File.file?(yaml_path) || help!("Unable to find a YAML file at #{yaml_path.inspect}")
+
+        require 'yaml'
+        begin
+          YAML.safe_load(File.read(yaml_path))
+        rescue StandardError => e
+          help! "Failed to load YAML file at #{yaml_path.inspect} (#{e})"
+        end
+      end
+
+      File.file?(@scheme) || help!("Unabled to find a scheme at #{@scheme.inspect}") if @scheme
+
+      @change_level =
+        case @change_level
+        when 'full-transitive' then :full_transitive
+        when 'itself' then :itself
+        when /\A\d+\z/ then [:at_most_n_away, @change_level.to_i]
+        else help! "Unknown change level #{@change_level.inspect}"
+        end
+    end
+
+    # @visibility private
+    class Git < CLI
+      self.summary = 'Generates a list of Xcode targets to build & test as a result of a git diff'
+
+      def self.options
+        super + [
+          ['--base-revision=SHA', 'Base revision to compute the git diff against']
+        ]
+      end
+
+      def initialize(argv)
+        @base_revision = argv.option('base-revision')
+
+        super
+      end
+
+      def validate!
+        super
+
+        @base_revision || help!('Must specify a base revision')
+      end
+
+      private
+
+      def compute_changeset
+        Refinement::Changeset.from_git(repository: @repository, base_revision: @base_revision)
+      end
+    end
+  end
+end

data/lib/refinement/cocoapods_post_install_writer.rb

@@ -0,0 +1,118 @@
+module Refinement
+  # Called after CocoaPods installation to write an augmenting file that
+  # takes into account changes to Pod configuration,
+  # as well as the globs used by podspecs to search for files
+  class CocoaPodsPostInstallWriter
+    attr_reader :aggregate_targets, :config, :repo, :options
+    private :aggregate_targets, :config, :repo, :options
+
+    # Initializes a post-install writer with CocoaPods target objects.
+    # @return [CocoaPodsPostInstallWriter] a new instance of CocoaPodsPostInstallWriter
+    # @param aggregate_targets [Array<Pod::AggregateTarget>]
+    # @param config [Pod::Config]
+    # @param options [Hash]
+    def initialize(aggregate_targets, config, options)
+      @aggregate_targets = aggregate_targets
+      @config = config
+      @repo = config.installation_root
+      @options = options || {}
+    end
+
+    # Writes the refinement augmenting file to the configured path
+    # @return [Void]
+    def write!
+      write_file options.fetch('output_path', config.sandbox.root.join('pods_refinement.json')), paths_by_target_name
+    end
+
+    private
+
+    def write_file(path, hash)
+      require 'json'
+      File.open(path, 'w') do |f|
+        f << JSON.generate(hash) << "\n"
+      end
+    end
+
+    def paths_by_target_name
+      targets = {}
+      aggregate_targets.each do |aggregate_target|
+        targets[aggregate_target.label] = paths_for_aggregate_target(aggregate_target)
+      end
+      aggregate_targets.flat_map(&:pod_targets).uniq.each do |pod_target|
+        targets.merge! paths_for_pod_targets(pod_target)
+      end
+      targets
+    end
+
+    def paths_for_aggregate_target(aggregate_target)
+      paths = []
+      if (podfile_path = aggregate_target.podfile.defined_in_file)
+        paths << { path: podfile_path.relative_path_from(repo), inclusion_reason: 'Podfile' }
+      end
+      if (user_project_path = aggregate_target.user_project_path)
+        paths << { path: user_project_path.relative_path_from(repo), inclusion_reason: 'user project' }
+      end
+      paths
+    end
+
+    def library_specification?(spec)
+      # Backwards compatibility
+      if spec.respond_to?(:library_specification?, false)
+        spec.library_specification?
+      else
+        !spec.test_specification?
+      end
+    end
+
+    def specification_paths_from_pod_target(pod_target)
+      pod_target
+        .target_definitions
+        .map(&:podfile)
+        .uniq
+        .flat_map do |podfile|
+        podfile
+          .dependencies
+          .select { |d| d.root_name == pod_target.pod_name }
+          .map { |d| (d.external_source || {})[:path] }
+          .compact
+      end.uniq
+    end
+
+    def paths_for_pod_targets(pod_target)
+      file_accessors_by_target_name = pod_target.file_accessors.group_by do |fa|
+        if library_specification?(fa.spec)
+          pod_target.label
+        elsif pod_target.respond_to?(:non_library_spec_label)
+          pod_target.non_library_spec_label(fa.spec)
+        else
+          pod_target.test_target_label(fa.spec)
+        end
+      end
+
+      pod_dir = pod_target.sandbox.pod_dir(pod_target.pod_name).relative_path_from(repo)
+
+      spec_paths = specification_paths_from_pod_target(pod_target)
+
+      file_accessors_by_target_name.each_with_object({}) do |(label, file_accessors), h|
+        paths = [
+          { path: 'Podfile.lock',
+            inclusion_reason: 'CocoaPods lockfile',
+            yaml_keypath: ['SPEC CHECKSUMS', pod_target.pod_name] }
+        ]
+        spec_paths.each { |path| paths << { path: path, inclusion_reason: 'podspec' } }
+
+        Pod::Validator::FILE_PATTERNS.each do |pattern|
+          file_accessors.each do |fa|
+            globs = fa.spec_consumer.send(pattern)
+            globs = globs.values.flatten if globs.is_a?(Hash)
+            globs.each do |glob|
+              paths << { glob: pod_dir.join(glob), inclusion_reason: pattern.to_s.tr('_', ' ').chomp('s') }
+            end
+          end
+        end
+
+        h[label] = paths.uniq
+      end
+    end
+  end
+end

data/lib/refinement/used_path.rb

@@ -0,0 +1,114 @@
+module Refinement
+  # Represents a path that some target depends upon.
+  class UsedPath
+    # @return [Pathname] the absolute path to the file
+    attr_reader :path
+    private :path
+
+    # @return [String] the reason why this path is being used by a target
+    attr_reader :inclusion_reason
+    private :inclusion_reason
+
+    def initialize(path:, inclusion_reason:)
+      @path = path
+      @inclusion_reason = inclusion_reason
+    end
+
+    # @return [Nil, String] If the path has been modified, a string explaining the modification
+    # @param changeset [Changeset] the changeset to search for a modification to this path
+    def find_in_changeset(changeset)
+      add_reason changeset.find_modification_for_path(absolute_path: path)
+    end
+
+    # @return [String]
+    # @visibility private
+    def to_s
+      "#{path.to_s.inspect} (#{inclusion_reason})"
+    end
+
+    private
+
+    # @return [Nil, String] A string suitable for user display that explains
+    #   why the given modification means a target is modified
+    # @param modification [Nil, FileModification]
+    def add_reason(modification)
+      return unless modification
+
+      "#{modification.path} (#{inclusion_reason}) #{modification.type}"
+    end
+
+    # Represents a path to a YAML file that some target depends upon,
+    # but where only a subset of the YAML is needed to determine a change.
+    class YAML < UsedPath
+      # @return [Array] the keypath to search for modifications in a YAML document
+      attr_reader :yaml_keypath
+      private :yaml_keypath
+
+      def initialize(yaml_keypath:, **kwargs)
+        super(**kwargs)
+        @yaml_keypath = yaml_keypath
+      end
+
+      # (see UsedPath#find_in_changeset)
+      def find_in_changeset(changeset)
+        modification, _yaml_diff = changeset.find_modification_for_yaml_keypath(absolute_path: path, keypath: yaml_keypath)
+        add_reason modification
+      end
+
+      # (see UsedPath#to_s)
+      def to_s
+        "#{path.to_s.inspect} @ #{yaml_keypath.join('.')} (#{inclusion_reason})"
+      end
+
+      private
+
+      # (see UsedPath#add_reason)
+      def add_reason(modification)
+        return unless modification
+
+        keypath_string =
+          if yaml_keypath.empty?
+            ''
+          else
+            ' @ ' + yaml_keypath.map { |path| path.to_s =~ /\A[a-zA-Z0-9_]+\z/ ? path : path.inspect }.join('.')
+          end
+        "#{modification.path}#{keypath_string} (#{inclusion_reason}) #{modification.type}"
+      end
+    end
+  end
+
+  # Represents a glob that some target depends upon.
+  class UsedGlob
+    # @return [String] a relative path glob
+    attr_reader :glob
+    private :glob
+
+    # (see UsedPath#inclusion_reason)
+    attr_reader :inclusion_reason
+    private :inclusion_reason
+
+    def initialize(glob:, inclusion_reason:)
+      @glob = glob
+      @inclusion_reason = inclusion_reason
+    end
+
+    # (see UsedPath#find_in_changeset)
+    def find_in_changeset(changeset)
+      add_reason changeset.find_modification_for_glob(absolute_glob: glob)
+    end
+
+    # (see UsedPath#to_s)
+    def to_s
+      "#{glob.to_s.inspect} (#{inclusion_reason})"
+    end
+
+    private
+
+    # (see UsedPath#add_reason)
+    def add_reason(modification)
+      return unless modification
+
+      "#{modification.path} (#{inclusion_reason}) #{modification.type}"
+    end
+  end
+end

data/lib/refinement/version.rb

@@ -1,3 +1,4 @@
 module Refinement
+  # @visibility private
   VERSION = File.read(File.expand_path('../../VERSION', __dir__)).strip.freeze
 end

data/lib/refinement.rb

@@ -1,6 +1,27 @@
-require 'refinement/version'
+require 'xcodeproj'
 
+# Generates a list of Xcode targets to build & test as a result of a git diff.
 module Refinement
   class Error < StandardError; end
-  # Your code goes here...
+
+  # @visibility private
+  # @param enum [Enumerable]
+  # Enumerates through `enum`, and applied the given block to each element.
+  # If the result of calling the block is truthy, the first such result is returned.
+  # If no such result is found, `nil` is returned.
+  def self.map_find(enum)
+    enum.each do |elem|
+      transformed = yield elem
+      return transformed if transformed
+    end
+
+    nil
+  end
+
+  require 'refinement/version'
+
+  require 'refinement/analyzer'
+  require 'refinement/annotated_target'
+  require 'refinement/changeset'
+  require 'refinement/used_path'
 end

metadata

@@ -1,49 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: refinement
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Samuel Giddins
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-18 00:00:00.000000000 Z
+date: 2019-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: cocoapods
+  name: xcodeproj
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.a
+        version: 1.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.a
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.17'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.17'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
+        version: 1.8.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -61,14 +41,25 @@ dependencies:
 description: 
 email:
 - segiddins@squareup.com
-executables: []
+executables:
+- refine
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - README.md
 - VERSION
+- exe/refine
+- lib/cocoapods_plugin.rb
 - lib/refinement.rb
+- lib/refinement/analyzer.rb
+- lib/refinement/annotated_target.rb
+- lib/refinement/changeset.rb
+- lib/refinement/changeset/file_modification.rb
+- lib/refinement/cli.rb
+- lib/refinement/cocoapods_post_install_writer.rb
+- lib/refinement/used_path.rb
 - lib/refinement/version.rb
 homepage: https://github.com/square/refinement
 licenses: []