danger-packwerk 0.14.1 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6946e8aa9a49501462b01c156909b59d62fd975d73ef6cd1fe2f0ecd429e39bc
-  data.tar.gz: e9a9e236ef4d3b6ac351a9673991e631a33a34e03e0af8be9f86b2070951bad8
+  metadata.gz: 11de71d95ae9ff78daff3f87835d184e206d6088ecece8608e03d7e42eaa0424
+  data.tar.gz: 9386a9c42dbc1ef0fface734b0c6e1b9aa031629c46d3961364a37b1afda1b36
 SHA512:
-  metadata.gz: 492b200d5e8d0b1df2fdbea26e528c92097621271e354b0a64315cab9f217492d706ae28a635a784d9fe0c3e9a6fe78952ac9eb1baafbc4345bbc1d414f3a92f
-  data.tar.gz: f17a18417b0aaf3b4ac4ed92d9ba45810e41eb2f12f58b24a43a401aacd3da727f279f53354193ff0a9bb7b63e4e8e8a499720e5297c380ceb3265edfd66b12e
+  metadata.gz: 0114bf7aa642b184bd8ba990764eff04925bafd7defc7c3c77af8b4edcef5c576c8412471d5ab31e3150df4298582774b5f1943ad3106c04b3b0fa02c619fae6
+  data.tar.gz: 05ec9637958c0f80a2f2ec0cd3d25578081fc015d98b9f1a7a5b296ef3a8c8e2304319ed6af8c3b4ceffb5a4e5e5f421596f92593ed1002690f60cbb465bd5f3

data/lib/danger-packwerk/danger_package_todo_yml_changes.rb

@@ -29,22 +29,25 @@ module DangerPackwerk
         offenses_formatter: T.nilable(Update::OffensesFormatter),
         before_comment: BeforeComment,
         max_comments: Integer,
-        violation_types: T::Array[String]
+        violation_types: T::Array[String],
+        root_path: T.nilable(String)
       ).void
     end
     def check(
       offenses_formatter: nil,
       before_comment: DEFAULT_BEFORE_COMMENT,
       max_comments: DEFAULT_MAX_COMMENTS,
-      violation_types: DEFAULT_VIOLATION_TYPES
+      violation_types: DEFAULT_VIOLATION_TYPES,
+      root_path: nil
     )
       offenses_formatter ||= Update::DefaultFormatter.new
       repo_link = github.pr_json[:base][:repo][:html_url]
       org_name = github.pr_json[:base][:repo][:owner][:login]
 
-      changed_package_todo_ymls = (git.modified_files + git.added_files + git.deleted_files).grep(PACKAGE_TODO_PATTERN)
+      git_filesystem = Private::GitFilesystem.new(git: git, root: root_path || '')
+      changed_package_todo_ymls = (git_filesystem.modified_files + git_filesystem.added_files + git_filesystem.deleted_files).grep(PACKAGE_TODO_PATTERN)
 
-      violation_diff = get_violation_diff(violation_types)
+      violation_diff = get_violation_diff(violation_types, root_path: root_path)
 
       before_comment.call(
         violation_diff,
@@ -61,130 +64,30 @@ module DangerPackwerk
         markdown(
           offenses_formatter.format_offenses(violations, repo_link, org_name),
           line: location.line_number,
-          file: location.file
+          file: git_filesystem.convert_to_filesystem(location.file)
         )
 
         current_comment_count += 1
       end
     end
 
-    sig { params(violation_types: T::Array[String]).returns(ViolationDiff) }
-    def get_violation_diff(violation_types)
-      added_violations = T.let([], T::Array[BasicReferenceOffense])
-      removed_violations = T.let([], T::Array[BasicReferenceOffense])
-
-      git.added_files.grep(PACKAGE_TODO_PATTERN).each do |added_package_todo_yml_file|
-        # Since the file is added, we know on the base commit there are no violations related to this pack,
-        # and that all violations from this file are new
-        added_violations += BasicReferenceOffense.from(added_package_todo_yml_file)
-      end
-
-      git.deleted_files.grep(PACKAGE_TODO_PATTERN).each do |deleted_package_todo_yml_file|
-        # Since the file is deleted, we know on the HEAD commit there are no violations related to this pack,
-        # and that all violations from this file are deleted
-        deleted_violations = get_violations_before_patch_for(deleted_package_todo_yml_file)
-        removed_violations += deleted_violations
-      end
-
-      # The format for git.renamed_files is a T::Array[{after: "some/path/new", before: "some/path/old"}]
-      renamed_files_before = git.renamed_files.map { |before_after_file| before_after_file[:before] }
-      renamed_files_after = git.renamed_files.map { |before_after_file| before_after_file[:after] }
-
-      git.modified_files.grep(PACKAGE_TODO_PATTERN).each do |modified_package_todo_yml_file|
-        # We skip over modified files if one of the modified files is a renamed `package_todo.yml` file.
-        # This allows us to rename packs while ignoring "new violations" in those renamed packs.
-        next if renamed_files_before.include?(modified_package_todo_yml_file)
-
-        head_commit_violations = BasicReferenceOffense.from(modified_package_todo_yml_file)
-        base_commit_violations = get_violations_before_patch_for(modified_package_todo_yml_file)
-        added_violations += head_commit_violations - base_commit_violations
-        removed_violations += base_commit_violations - head_commit_violations
-      end
-
-      #
-      # This implementation creates some false negatives:
-      # That is – it doesn't capture some cases:
-      # 1) A file has been renamed without renaming a constant.
-      # That can happen if we change only the autoloaded portion of a filename.
-      # For example: `packs/foo/app/services/my_class.rb` (defines: `MyClass`)
-      # is changed to `packs/foo/app/public/my_class.rb` (still defines: `MyClass`)
-      #
-      # This implementation also doesn't cover these false positives:
-      # That is – it leaves a comment when it should not.
-      # 1) A CONSTANT within a class or module has been renamed.
-      # e.g. `class MyClass; MY_CONSTANT = 1; end` becomes `class MyClass; RENAMED_CONSTANT = 1; end`
-      # We would not detect based on file renames that `MY_CONSTANT` has been renamed.
-      #
-      renamed_constants = []
-
-      added_violations.each do |violation|
-        filepath_that_defines_this_constant = Private.constant_resolver.resolve(violation.class_name)&.location
-        renamed_constants << violation.class_name if renamed_files_after.include?(filepath_that_defines_this_constant)
-      end
-
-      relevant_added_violations = added_violations.reject do |violation|
-        renamed_files_after.include?(violation.file) ||
-          renamed_constants.include?(violation.class_name) ||
-          !violation_types.include?(violation.type)
-      end
+    sig do
+      params(
+        violation_types: T::Array[String],
+        root_path: T.nilable(String)
+      ).returns(ViolationDiff)
+    end
+    def get_violation_diff(violation_types, root_path: nil)
+      git_filesystem = Private::GitFilesystem.new(git: git, root: root_path || '')
 
-      relevant_removed_violations = removed_violations.select do |violation|
-        violation_types.include?(violation.type)
-      end
+      added_violations, removed_violations = Private::TodoYmlChanges.get_reference_offenses(
+        violation_types, git_filesystem
+      )
 
       ViolationDiff.new(
-        added_violations: relevant_added_violations,
-        removed_violations: relevant_removed_violations
+        added_violations: added_violations,
+        removed_violations: removed_violations
       )
     end
-
-    private
-
-    sig { params(package_todo_yml_file: String).returns(T::Array[BasicReferenceOffense]) }
-    def get_violations_before_patch_for(package_todo_yml_file)
-      # The strategy to get the violations before this PR is to reverse the patch on each `package_todo.yml`.
-      # A previous strategy attempted to use `git merge-base --fork-point`, but there are many situations where it returns
-      # empty values. That strategy is fickle because it depends on the state of the `reflog` within the CI suite, which appears
-      # to not be reliable to depend on.
-      #
-      # Instead, just inverting the patch should hopefully provide a more reliable way to figure out what was the state of the file before
-      # the PR without needing to use git commands that interpret the branch history based on local git history.
-      #
-      # We apply the patch to the original file so that we can seamlessly reverse the patch applied to that file (since patches are coupled to
-      # the files they modify). After parsing the violations from that `package_todo.yml` file with the patch reversed,
-      # we use a temporary copy of the original file to rewrite to it with the original contents.
-      # Note that practically speaking, we don't need to rewrite the original contents (since we already fetched the
-      # original contents above and the CI file system should be ephemeral). However, we do this anyways in case we later change these
-      # assumptions, or another client's environment is different and expects these files not to be mutated.
-
-      # Keep track of the original file contents. If the original file has been deleted, then we delete the file after inverting the patch at the end, rather than rewriting it.
-      package_todo_yml_file_copy = (File.read(package_todo_yml_file) if File.exist?(package_todo_yml_file))
-
-      Tempfile.create do |patch_file|
-        # Normally we'd use `git.diff_for_file(package_todo_yml_file).patch` here, but there is a bug where it does not work for deleted files yet.
-        # I have a fix for that here: https://github.com/danger/danger/pull/1357
-        # Until that lands, I'm just using the underlying implementation of that method to get the diff for a file.
-        # Note that I might want to use a safe escape operator, `&.patch` and return gracefully if the patch cannot be found.
-        # However I'd be interested in why that ever happens, so for now going to proceed as is.
-        # (Note that better yet we'd have observability into these so I can just log under those circumstances rather than surfacing an error to the user,
-        # but we don't have that quite yet.)
-        patch_for_file = git.diff[package_todo_yml_file].patch
-        # This appears to be a known issue that patches require new lines at the end. It seems like this is an issue with Danger that
-        # it gives us a patch without a newline.
-        # https://stackoverflow.com/questions/18142870/git-error-fatal-corrupt-patch-at-line-36
-        patch_file << "#{patch_for_file}\n"
-        patch_file.rewind
-        # https://git-scm.com/docs/git-apply
-        _stdout, _stderr, _status = Open3.capture3("git apply --reverse #{patch_file.path}")
-        # https://www.rubyguides.com/2019/05/ruby-tempfile/
-        BasicReferenceOffense.from(package_todo_yml_file)
-      end
-    ensure
-      if package_todo_yml_file_copy
-        File.write(package_todo_yml_file, package_todo_yml_file_copy)
-      else
-        File.delete(package_todo_yml_file)
-      end
-    end
   end
 end

data/lib/danger-packwerk/danger_packwerk.rb

@@ -6,6 +6,7 @@ require 'packwerk'
 require 'parse_packwerk'
 require 'sorbet-runtime'
 require 'danger-packwerk/packwerk_wrapper'
+require 'danger-packwerk/private/git'
 
 module DangerPackwerk
   # Note that Danger names the plugin (i.e. anything that inherits from `Danger::Plugin`) by taking the name of the class and gsubbing out "Danger"
@@ -43,7 +44,8 @@ module DangerPackwerk
         failure_message: String,
         on_failure: OnFailure,
         violation_types: T::Array[String],
-        grouping_strategy: CommentGroupingStrategy
+        grouping_strategy: CommentGroupingStrategy,
+        root_path: T.nilable(String)
       ).void
     end
     def check(
@@ -53,7 +55,8 @@ module DangerPackwerk
       failure_message: DEFAULT_FAILURE_MESSAGE,
       on_failure: DEFAULT_ON_FAILURE,
       violation_types: DEFAULT_VIOLATION_TYPES,
-      grouping_strategy: CommentGroupingStrategy::PerConstantPerLocation
+      grouping_strategy: CommentGroupingStrategy::PerConstantPerLocation,
+      root_path: nil
     )
       offenses_formatter ||= Check::DefaultFormatter.new
       repo_link = github.pr_json[:base][:repo][:html_url]
@@ -67,9 +70,12 @@ module DangerPackwerk
       # trigger the warning message, which is good, since we only want to trigger on new code.
       github.dismiss_out_of_range_messages
 
+      git_filesystem = Private::GitFilesystem.new(git: git, root: root_path || '')
+
       # https://github.com/danger/danger/blob/eca19719d3e585fe1cc46bc5377f9aa955ebf609/lib/danger/danger_core/plugins/dangerfile_git_plugin.rb#L80
-      renamed_files_after = git.renamed_files.map { |f| f[:after] }
-      targeted_files = (git.modified_files + git.added_files + renamed_files_after).select do |f|
+      renamed_files_after = git_filesystem.renamed_files.map { |f| f[:after] }
+
+      targeted_files = (git_filesystem.modified_files + git_filesystem.added_files + renamed_files_after).select do |f|
         path = Pathname.new(f)
 
         # We probably want to check the `include` key of `packwerk.yml`. By default, this value is "**/*.{rb,rake,erb}",
@@ -92,7 +98,7 @@ module DangerPackwerk
 
       packwerk_reference_offenses = PackwerkWrapper.get_offenses_for_files(targeted_files.to_a).compact
 
-      renamed_files = git.renamed_files.map { |before_after_file| before_after_file[:after] }
+      renamed_files = git_filesystem.renamed_files.map { |before_after_file| before_after_file[:after] }
 
       packwerk_reference_offenses_to_care_about = packwerk_reference_offenses.reject do |packwerk_reference_offense|
         constant_name = packwerk_reference_offense.reference.constant.name
@@ -131,8 +137,7 @@ module DangerPackwerk
         referencing_file = reference_offense.reference.relative_path
 
         message = offenses_formatter.format_offenses(unique_packwerk_reference_offenses, repo_link, org_name)
-
-        markdown(message, file: referencing_file, line: line_number)
+        markdown(message, file: git_filesystem.convert_to_filesystem(referencing_file), line: line_number)
       end
 
       if current_comment_count > 0

data/lib/danger-packwerk/private/git.rb

@@ -0,0 +1,65 @@
+# typed: strict
+
+require 'code_ownership'
+require 'packs'
+
+# In order to support running danger-packwerk from a non-root filepath, we need
+# to wrap some git functions in filesystem wrappers: packwerk runs relative to
+# the rails app root, whereas git returns paths on the actual filesystem.
+module DangerPackwerk
+  module Private
+    class GitFilesystem < T::Struct
+      extend T::Sig
+
+      const :git, Danger::DangerfileGitPlugin
+      const :root, String
+
+      sig { returns(T::Array[{ after: String, before: String }]) }
+      def renamed_files
+        @git.renamed_files.map do |f|
+          {
+            after: convert_file_from_filesystem(f[:after]),
+            before: convert_file_from_filesystem(f[:before])
+          }
+        end
+      end
+
+      sig { returns(T::Array[String]) }
+      def modified_files
+        convert_from_filesystem(@git.modified_files.to_a)
+      end
+
+      sig { returns(T::Array[String]) }
+      def deleted_files
+        convert_from_filesystem(@git.deleted_files.to_a)
+      end
+
+      sig { returns(T::Array[String]) }
+      def added_files
+        convert_from_filesystem(@git.added_files.to_a)
+      end
+
+      sig { params(filename_on_disk: String).returns(::Git::Diff::DiffFile) }
+      def diff(filename_on_disk)
+        @git.diff[filename_on_disk]
+      end
+
+      sig { params(path: String).returns(String) }
+      def convert_to_filesystem(path)
+        Pathname(@root).join(path).to_s
+      end
+
+      private
+
+      sig { params(files: T::Array[String]).returns(T::Array[String]) }
+      def convert_from_filesystem(files)
+        files.map { |f| convert_file_from_filesystem(f) }
+      end
+
+      sig { params(file: String).returns(String) }
+      def convert_file_from_filesystem(file)
+        Pathname(file).relative_path_from(@root).to_s
+      end
+    end
+  end
+end

data/lib/danger-packwerk/private/todo_yml_changes.rb

@@ -0,0 +1,135 @@
+# typed: strict
+
+module DangerPackwerk
+  module Private
+    class TodoYmlChanges
+      extend T::Sig
+      extend T::Helpers
+
+      sig do
+        params(
+          violation_types: T::Array[String],
+          git_filesystem: GitFilesystem
+        ).returns([T::Array[BasicReferenceOffense], T::Array[BasicReferenceOffense]])
+      end
+      def self.get_reference_offenses(violation_types, git_filesystem)
+        added_violations = T.let([], T::Array[BasicReferenceOffense])
+        removed_violations = T.let([], T::Array[BasicReferenceOffense])
+
+        git_filesystem.added_files.grep(PACKAGE_TODO_PATTERN).each do |added_package_todo_yml_file|
+          # Since the file is added, we know on the base commit there are no violations related to this pack,
+          # and that all violations from this file are new
+          added_violations += BasicReferenceOffense.from(added_package_todo_yml_file)
+        end
+
+        git_filesystem.deleted_files.grep(PACKAGE_TODO_PATTERN).each do |deleted_package_todo_yml_file|
+          # Since the file is deleted, we know on the HEAD commit there are no violations related to this pack,
+          # and that all violations from this file are deleted
+          deleted_violations = get_violations_before_patch_for(git_filesystem, deleted_package_todo_yml_file)
+          removed_violations += deleted_violations
+        end
+
+        # The format for git.renamed_files is a T::Array[{after: "some/path/new", before: "some/path/old"}]
+        renamed_files_before = git_filesystem.renamed_files.map { |before_after_file| before_after_file[:before] }
+        renamed_files_after = git_filesystem.renamed_files.map { |before_after_file| before_after_file[:after] }
+
+        git_filesystem.modified_files.grep(PACKAGE_TODO_PATTERN).each do |modified_package_todo_yml_file|
+          # We skip over modified files if one of the modified files is a renamed `package_todo.yml` file.
+          # This allows us to rename packs while ignoring "new violations" in those renamed packs.
+          next if renamed_files_before.include?(modified_package_todo_yml_file)
+
+          head_commit_violations = BasicReferenceOffense.from(modified_package_todo_yml_file)
+          base_commit_violations = get_violations_before_patch_for(git_filesystem, modified_package_todo_yml_file)
+          added_violations += head_commit_violations - base_commit_violations
+          removed_violations += base_commit_violations - head_commit_violations
+        end
+
+        #
+        # This implementation creates some false negatives:
+        # That is – it doesn't capture some cases:
+        # 1) A file has been renamed without renaming a constant.
+        # That can happen if we change only the autoloaded portion of a filename.
+        # For example: `packs/foo/app/services/my_class.rb` (defines: `MyClass`)
+        # is changed to `packs/foo/app/public/my_class.rb` (still defines: `MyClass`)
+        #
+        # This implementation also doesn't cover these false positives:
+        # That is – it leaves a comment when it should not.
+        # 1) A CONSTANT within a class or module has been renamed.
+        # e.g. `class MyClass; MY_CONSTANT = 1; end` becomes `class MyClass; RENAMED_CONSTANT = 1; end`
+        # We would not detect based on file renames that `MY_CONSTANT` has been renamed.
+        #
+        renamed_constants = []
+
+        added_violations.each do |violation|
+          filepath_that_defines_this_constant = Private.constant_resolver.resolve(violation.class_name)&.location
+          renamed_constants << violation.class_name if renamed_files_after.include?(filepath_that_defines_this_constant)
+        end
+
+        relevant_added_violations = added_violations.reject do |violation|
+          renamed_files_after.include?(violation.file) ||
+            renamed_constants.include?(violation.class_name) ||
+            !violation_types.include?(violation.type)
+        end
+
+        relevant_removed_violations = removed_violations.select do |violation|
+          violation_types.include?(violation.type)
+        end
+
+        [relevant_added_violations, relevant_removed_violations]
+      end
+
+      sig do
+        params(
+          git_filesystem: GitFilesystem,
+          package_todo_yml_file: String
+        ).returns(T::Array[BasicReferenceOffense])
+      end
+      def self.get_violations_before_patch_for(git_filesystem, package_todo_yml_file)
+        # The strategy to get the violations before this PR is to reverse the patch on each `package_todo.yml`.
+        # A previous strategy attempted to use `git merge-base --fork-point`, but there are many situations where it returns
+        # empty values. That strategy is fickle because it depends on the state of the `reflog` within the CI suite, which appears
+        # to not be reliable to depend on.
+        #
+        # Instead, just inverting the patch should hopefully provide a more reliable way to figure out what was the state of the file before
+        # the PR without needing to use git commands that interpret the branch history based on local git history.
+        #
+        # We apply the patch to the original file so that we can seamlessly reverse the patch applied to that file (since patches are coupled to
+        # the files they modify). After parsing the violations from that `package_todo.yml` file with the patch reversed,
+        # we use a temporary copy of the original file to rewrite to it with the original contents.
+        # Note that practically speaking, we don't need to rewrite the original contents (since we already fetched the
+        # original contents above and the CI file system should be ephemeral). However, we do this anyways in case we later change these
+        # assumptions, or another client's environment is different and expects these files not to be mutated.
+
+        # Keep track of the original file contents. If the original file has been deleted, then we delete the file after inverting the patch at the end, rather than rewriting it.
+        package_todo_yml_file_copy = (File.read(package_todo_yml_file) if File.exist?(package_todo_yml_file))
+
+        Tempfile.create do |patch_file|
+          # Normally we'd use `git.diff_for_file(package_todo_yml_file).patch` here, but there is a bug where it does not work for deleted files yet.
+          # I have a fix for that here: https://github.com/danger/danger/pull/1357
+          # Until that lands, I'm just using the underlying implementation of that method to get the diff for a file.
+          # Note that I might want to use a safe escape operator, `&.patch` and return gracefully if the patch cannot be found.
+          # However I'd be interested in why that ever happens, so for now going to proceed as is.
+          # (Note that better yet we'd have observability into these so I can just log under those circumstances rather than surfacing an error to the user,
+          # but we don't have that quite yet.)
+          package_todo_filesystem_path = git_filesystem.convert_to_filesystem(package_todo_yml_file)
+          patch_for_file = git_filesystem.diff(package_todo_filesystem_path).patch
+          # This appears to be a known issue that patches require new lines at the end. It seems like this is an issue with Danger that
+          # it gives us a patch without a newline.
+          # https://stackoverflow.com/questions/18142870/git-error-fatal-corrupt-patch-at-line-36
+          patch_file << "#{patch_for_file}\n"
+          patch_file.rewind
+          # https://git-scm.com/docs/git-apply
+          _stdout, _stderr, _status = Open3.capture3("git apply --reverse #{patch_file.path}")
+          # https://www.rubyguides.com/2019/05/ruby-tempfile/
+          BasicReferenceOffense.from(package_todo_yml_file)
+        end
+      ensure
+        if package_todo_yml_file_copy
+          File.write(package_todo_yml_file, package_todo_yml_file_copy)
+        else
+          File.delete(package_todo_yml_file)
+        end
+      end
+    end
+  end
+end

data/lib/danger-packwerk/private.rb

@@ -1,6 +1,7 @@
 # typed: strict
 
 require 'danger-packwerk/private/ownership_information'
+require 'danger-packwerk/private/todo_yml_changes'
 require 'constant_resolver'
 
 module DangerPackwerk

data/lib/danger-packwerk/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module DangerPackwerk
-  VERSION = '0.14.1'
+  VERSION = '0.14.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danger-packwerk
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.2
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2023-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_ownership
@@ -208,7 +208,9 @@ files:
 - lib/danger-packwerk/danger_packwerk.rb
 - lib/danger-packwerk/packwerk_wrapper.rb
 - lib/danger-packwerk/private.rb
+- lib/danger-packwerk/private/git.rb
 - lib/danger-packwerk/private/ownership_information.rb
+- lib/danger-packwerk/private/todo_yml_changes.rb
 - lib/danger-packwerk/update/default_formatter.rb
 - lib/danger-packwerk/update/offenses_formatter.rb
 - lib/danger-packwerk/version.rb