danger-dangermattic 1.0.0

data/lib/dangermattic/plugins/labels_checker.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Danger
+  # Plugin for checking labels associated with a pull request.
+  #
+  # @example Checking for specific labels and generating warnings/errors:
+  #   labels_checker.check(
+  #     do_not_merge_labels: ['Do Not Merge'],
+  #     required_labels: ['Bug', 'Enhancement'],
+  #     required_labels_error: 'Please ensure the PR has labels "Bug" or "Enhancement".',
+  #     recommended_labels: ['Documentation'],
+  #     recommended_labels_warning: 'Consider adding the "Documentation" label for better tracking.'
+  #   )
+  #
+  # @see Automattic/dangermattic
+  # @tags github, process
+  #
+  class LabelsChecker < Plugin
+    # Checks if a PR is missing labels or is marked with labels for not merging.
+    # If recommended labels are missing, the plugin will emit a warning. If a required label is missing, or the PR
+    # has a label indicating that the PR should not be merged, an error will be emitted, preventing the final merge.
+    #
+    # @param do_not_merge_labels [Array<String>] The possible labels indicating that a merge should not be allowed.
+    # @param required_labels [Array<Regexp>] The list of Regular Expressions describing all the type of labels that are *required* on PR (e.g. `[/^feature:/, `/^type:/]` or `bug|bugfix-exemption`).
+    #   Defaults to an empty array if not provided.
+    # @param required_labels_error [String] The error message displayed if the required labels are not present.
+    #   Defaults to a generic message that includes the missing label's regexes.
+    # @param recommended_labels [Array<Regexp>] The list of Regular Expressions describing all the type of labels that we want a PR to have,
+    # with a warning if it doesn't (e.g. `[/^feature:/, `/^type:/]` or `bug|bugfix-exemption`).
+    #   Defaults to an empty array if not provided.
+    # @param recommended_labels_warning [String] The warning message displayed if the recommended labels are not present.
+    #   Defaults to a generic message that includes the missing label's regexes.
+    #
+    # @note Tip: if you want to require or recommend "at least one label", you can use
+    #  an array of a single empty regex `[//]` to match "a label with any name".
+    #
+    # @return [void]
+    def check(do_not_merge_labels: [], required_labels: [], required_labels_error: nil, recommended_labels: [], recommended_labels_warning: nil)
+      github_labels = danger.github.pr_labels
+
+      # A PR shouldn't be merged with the 'DO NOT MERGE' label
+      found_do_not_merge_labels = github_labels.select do |github_label|
+        do_not_merge_labels&.any? { |label| github_label.casecmp?(label) }
+      end
+
+      failure("This PR is tagged with #{markdown_list_string(found_do_not_merge_labels)} label(s).") unless found_do_not_merge_labels.empty?
+
+      # fail if a PR is missing any of the required labels
+      check_missing_labels(labels: github_labels, expected_labels: required_labels, report_on_missing: :error, custom_message: required_labels_error)
+
+      # warn if a PR is missing any of the recommended labels
+      check_missing_labels(labels: github_labels, expected_labels: recommended_labels, report_on_missing: :warning, custom_message: recommended_labels_warning)
+    end
+
+    private
+
+    def check_missing_labels(labels:, expected_labels:, report_on_missing:, custom_message: nil)
+      missing_expected_labels = expected_labels.reject do |required_label|
+        labels.any? { |label| label =~ required_label }
+      end
+
+      return if missing_expected_labels.empty?
+
+      missing_labels_list = missing_expected_labels.map(&:source)
+      message = custom_message || "PR is missing label(s) matching: #{markdown_list_string(missing_labels_list)}"
+
+      reporter.report(message: message, type: report_on_missing)
+    end
+
+    def markdown_list_string(items)
+      items.map { |item| "`#{item}`" }.join(', ')
+    end
+  end
+end

data/lib/dangermattic/plugins/manifest_pr_checker.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Danger
+  # Plugin to check if the a lock file (Gemfile.lock, Podfile.lock, Package.resolved) was updated when changing a manifest
+  # file (Gemfile, Podfile, Package.swift) in a PR.
+  #
+  # @example Running manifest / lock checks
+  #
+  #          # Check all manifest files (Gemfile, Podfile, Package.swift) have a corresponding lock change
+  #          checker.check_all_manifest_lock_updated
+  #
+  # @example Gemfile check
+  #
+  #          # Check if the Gemfile and the Gemfile.lock are both updated
+  #          checker.check_gemfile_lock_updated
+  #
+  # @example Podfile check
+  #
+  #          # Check if the Podfile and the Podfile.lock are both updated
+  #          checker.check_podfile_lock_updated
+  #
+  # @example Package.swift check
+  #
+  #          # Check if the Package.swift and the Package.resolved are both updated
+  #          checker.check_swift_package_resolved_updated
+  #
+  # @see Automattic/dangermattic
+  # @tags ios, android
+  #
+  class ManifestPRChecker < Plugin
+    MESSAGE = '`%s` was changed without updating its corresponding `%s`. %s.'
+
+    # Performs all the checks, asserting that changes on `Gemfile`, `Podfile` and `Package.swift` must have corresponding
+    # lock file changes.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_all_manifest_lock_updated(report_type: :warning)
+      check_gemfile_lock_updated(report_type: report_type)
+      check_podfile_lock_updated(report_type: report_type)
+      check_swift_package_resolved_updated(report_type: report_type)
+    end
+
+    # Check if the `Gemfile` file was modified without a corresponding `Gemfile.lock` update
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    #
+    # @return [void]
+    def check_gemfile_lock_updated(report_type: :warning)
+      check_manifest_lock_updated(
+        file_name: 'Gemfile',
+        lock_file_name: 'Gemfile.lock',
+        instruction: 'Please run `bundle install` or `bundle update <updated_gem>`',
+        report_type: report_type
+      )
+    end
+
+    # Check if the `Podfile` file was modified without a corresponding `Podfile.lock` update
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    #
+    # @return [void]
+    def check_podfile_lock_updated(report_type: :warning)
+      check_manifest_lock_updated(
+        file_name: 'Podfile',
+        lock_file_name: 'Podfile.lock',
+        instruction: 'Please run `bundle exec pod install`',
+        report_type: report_type
+      )
+    end
+
+    # Check if the `Package.swift` file was modified without a corresponding `Package.resolved` update
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    #
+    # @return [void]
+    def check_swift_package_resolved_updated(report_type: :warning)
+      check_manifest_lock_updated(
+        file_name: 'Package.swift',
+        lock_file_name: 'Package.resolved',
+        instruction: 'Please resolve the Swift packages in Xcode',
+        report_type: report_type
+      )
+    end
+
+    private
+
+    def check_manifest_lock_updated(file_name:, lock_file_name:, instruction:, report_type: :warning)
+      # Find all the modified manifest files
+      manifest_modified_files = git.modified_files.select { |f| File.basename(f) == file_name }
+
+      # For each manifest file, check if the corresponding lockfile (in the same dir) was also modified
+      manifest_modified_files.each do |manifest_file|
+        lockfile_modified = git.modified_files.any? { |f| File.dirname(f) == File.dirname(manifest_file) && File.basename(f) == lock_file_name }
+        next if lockfile_modified
+
+        message = format(MESSAGE, manifest_file, lock_file_name, instruction)
+        reporter.report(message: message, type: report_type)
+      end
+    end
+  end
+end

data/lib/dangermattic/plugins/milestone_checker.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Danger
+  # This plugin checks whether a pull request is assigned to a milestone and whether the milestone's due date is approaching.
+  #
+  # @example Check if a milestone is set
+  #
+  #          # Check if PR is assigned to a milestone
+  #          checker.check_milestone_set
+  #
+  #          # Check if PR is assigned to a milestone, reporting an error if that's not the case
+  #          checker.check_milestone_set(report_type: :error)
+  #
+  # @example Run a milestone check
+  #
+  #          # Check if milestone due date is approaching, reporting a warning if the milestone is in less than 5 days
+  #          checker.check_milestone_due_date(days_before_due: 5)
+  #
+  # @example Run a milestone check with custom parameters
+  #
+  #          # Check if milestone due date is within 3 days, reporting an error if the due date has passed and in case there's no milestone set
+  #          checker.check_milestone_due_date(days_before_due: 3, report_type: :error, report_type_if_no_milestone: :error)
+  #
+  # @example Run a milestone check with a custom milestone behaviour parameter
+  #
+  #          # Check if milestone due date is approaching and don't report anything if no milestone is assigned
+  #          checker.check_milestone_due_date(report_type_if_no_milestone: :none)
+  #
+  # @see Automattic/dangermattic
+  # @tags milestone, github, process
+  #
+  class MilestoneChecker < Plugin
+    # Checks if the pull request is assigned to a milestone.
+    #
+    # @return [void]
+    def check_milestone_set(report_type: :warning)
+      return unless milestone.nil?
+
+      message = 'PR is not assigned to a milestone.'
+      reporter.report(message: message, type: report_type)
+    end
+
+    # Checks if the pull request's milestone is due to finish within a certain number of days.
+    #
+    # @param days_before_due [Integer] Number of days before the milestone due date for the check to apply.
+    # @param report_type [Symbol] (optional) The type of message for when the PR is has passed over the `days_before_due` threshold. Types: :error, :warning (default), :message.
+    # @param report_type_if_no_milestone [Symbol] The type of message for when the PR is not assigned to a milestone. Types: :error, :warning (default), :message. You can also pass :none to not leave a message when there is no milestone.
+    #
+    # @return [void]
+    def check_milestone_due_date(days_before_due:, report_type: :warning, report_type_if_no_milestone: :warning)
+      if milestone.nil?
+        check_milestone_set(report_type: report_type_if_no_milestone)
+        return
+      end
+
+      return unless pr_state != 'closed' && milestone_due_date
+
+      today = DateTime.now
+
+      seconds_threshold = days_before_due * 24 * 60 * 60
+      time_before_due_date = milestone_due_date.to_time.to_i - today.to_time.to_i
+      return unless time_before_due_date <= seconds_threshold
+
+      message_text = "This PR is assigned to the milestone [#{milestone_title}](#{milestone_url}). "
+      message_text += if time_before_due_date.positive?
+                        "This milestone is due in less than #{days_before_due} days.\n" \
+                          'Please make sure to get it merged by then or assign it to a milestone with a later deadline.'
+                      else
+                        "The due date for this milestone has already passed.\n" \
+                          'Please assign it to a milestone with a later deadline or check whether the release for this milestone has already been finished.'
+                      end
+
+      reporter.report(message: message_text, type: report_type)
+    end
+
+    private
+
+    def milestone
+      github.pr_json['milestone']
+    end
+
+    def milestone_due_date
+      milestone['due_on']
+    end
+
+    def milestone_title
+      milestone['title']
+    end
+
+    def milestone_url
+      milestone['html_url']
+    end
+
+    def pr_state
+      github.pr_json['state']
+    end
+  end
+end

data/lib/dangermattic/plugins/podfile_checker.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Danger
+  # Plugin for checking that the Podfile.lock doesn't contain direct commit references.
+  #
+  # @example Checking a Podfile for commit references:
+  #          podfile_checker.check_podfile_does_not_have_commit_references(podfile_lock_path: './aLib/Podfile.lock')
+  #
+  # @example Checking Git diffs for Podfile.lock commit references:
+  #          podfile_checker.check_podfile_diff_does_not_have_commit_references
+  #
+  # @see Automattic/dangermattic
+  # @tags android, localization
+  #
+  class PodfileChecker < Plugin
+    PODFILE_LOCK = 'Podfile.lock'
+    PODFILE_LOCK_DEPENDENCIES_ENTRY = 'DEPENDENCIES'
+    DEFAULT_PODFILE_LOCK_PATH = './Podfile.lock'
+
+    # Check if the Podfile.lock contains any references to commit hashes and raise a failure if it does.
+    #
+    # @param podfile_lock_path [String] (optional) The path to the Podfile.lock file.
+    #        Defaults to the `DEFAULT_PODFILE_LOCK_PATH` constant if not provided.
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error (default), :warning, :message.
+    #
+    # @example Checking the default Podfile.lock:
+    #   check_podfile_does_not_have_commit_references
+    #
+    # @example Checking a custom Podfile.lock at a specific path:
+    #   check_podfile_does_not_have_commit_references(podfile_lock_path: '/path/to/Podfile.lock')
+    #
+    # @return [void]
+    def check_podfile_does_not_have_commit_references(podfile_lock_path: DEFAULT_PODFILE_LOCK_PATH, report_type: :error)
+      check_podfile_does_not_match(
+        regexp: COMMIT_REFERENCE_REGEXP,
+        podfile_lock_path: podfile_lock_path,
+        match_found_message_generator: ->(matches) { "Podfile reference(s) to a commit hash:\n```#{matches.join("\n")}```" },
+        report_type: report_type
+      )
+    end
+
+    # Check for Podfile references to commit hashes in the Podfile.lock in a pull request.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_podfile_diff_does_not_have_commit_references(report_type: :warning)
+      warning_message = 'This PR adds a Podfile reference to a commit hash:'
+      check_podfile_diff_entries_do_not_match(regexp: COMMIT_REFERENCE_REGEXP, match_found_message: warning_message, report_type: report_type)
+    end
+
+    # Check if the Podfile.lock contains any references to branches and raise a failure if it does.
+    #
+    # @param podfile_lock_path [String] (optional) The path to the Podfile.lock file.
+    #        Defaults to the `DEFAULT_PODFILE_LOCK_PATH` constant if not provided.
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error (default), :warning, :message.
+    #
+    # @example Checking the default Podfile.lock:
+    #   check_podfile_does_not_have_branch_references
+    #
+    # @example Checking a custom Podfile.lock at a specific path:
+    #    check_podfile_does_not_have_branch_references(podfile_lock_path: '/path/to/Podfile.lock')
+    #
+    # @return [void]
+    def check_podfile_does_not_have_branch_references(podfile_lock_path: DEFAULT_PODFILE_LOCK_PATH, report_type: :error)
+      check_podfile_does_not_match(
+        regexp: BRANCH_REFERENCE_REGEXP,
+        podfile_lock_path: podfile_lock_path,
+        match_found_message_generator: ->(matches) { "Podfile reference(s) to a branch:\n```#{matches.join("\n")}```" },
+        report_type: report_type
+      )
+    end
+
+    # Check for Podfile references to branches in the Podfile.lock in a pull request.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_podfile_diff_does_not_have_branch_references(report_type: :warning)
+      warning_message = 'This PR adds a Podfile reference to a branch:'
+      check_podfile_diff_entries_do_not_match(regexp: BRANCH_REFERENCE_REGEXP, match_found_message: warning_message, report_type: report_type)
+    end
+
+    private
+
+    COMMIT_REFERENCE_REGEXP = /\(from `\S+`, commit `\S+`\)/
+    BRANCH_REFERENCE_REGEXP = /\(from `\S+`, branch `\S+`\)/
+
+    def check_podfile_does_not_match(
+      regexp:,
+      podfile_lock_path:,
+      match_found_message_generator: ->(matches) { "Matches found in:\n#{matches.join("\n")}" },
+      report_type: :error
+    )
+      podfile_lock_contents = File.read(podfile_lock_path)
+      podfile_lock_data = YAML.load(podfile_lock_contents)
+
+      commit_references = []
+      podfile_lock_dependencies = podfile_lock_data[PODFILE_LOCK_DEPENDENCIES_ENTRY]
+      podfile_lock_dependencies&.each do |dependency|
+        commit_references << dependency if dependency.match?(regexp)
+      end
+
+      return if commit_references.empty?
+
+      message = match_found_message_generator.call(commit_references)
+      reporter.report(message: message, type: report_type)
+    end
+
+    def check_podfile_diff_entries_do_not_match(regexp:, match_found_message:, report_type:)
+      git_utils.check_added_diff_lines(
+        # Notice the lockfile name is not configurable because we check the basename from the files in the diff and one cannot change the name of the lockfile CocoaPods generates.
+        file_selector: ->(path) { File.basename(path) == PODFILE_LOCK },
+        line_matcher: ->(line) { line.match?(regexp) },
+        message: match_found_message,
+        report_type: report_type
+      )
+    end
+  end
+end

data/lib/dangermattic/plugins/pr_size_checker.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Danger
+  # Plugin to check the size of a Pull Request content and text body.
+  #
+  # @example Running a PR diff size check with default parameters
+  #
+  #          # Check the total size of changes in the PR using the default parameters, reporting a warning if the PR is larger than 500
+  #          pr_size_checker.check_diff_size(max_size: 500)
+  #
+  # @example Running a PR diff size check customizing the size, message and type of report
+  #
+  #          # Check the total size of changes in the PR, reporting an error if the diff is larger than 1000 using the specified message
+  #          pr_size_checker.check_diff_size(max_size: 1000, message: 'PR too large, 1000 is the max!!', report_type: :error)
+  #
+  # @example Running a PR diff size check on the specified files in part of the diff
+  #
+  #          # Check the size of insertions in the files selected by the file_selector
+  #          pr_size_checker.check_diff_size(file_selector: ->(file) { file.include?('/java/test/') }, type: :insertions)
+  #
+  # @example Running a PR description length check
+  #
+  #          # Check the PR Body using the default parameters, reporting a warning if the PR is smaller than 10 characters
+  #          pr_size_checker.check_pr_body(min_length: 10)
+  #
+  # @example Running a PR description length check with custom parameters
+  #
+  #          # Check if the minimum length of the PR body is smaller than 20 characters, reporting an error using a custom error message
+  #          pr_size_checker.check_pr_body(min_length: 20, message: 'Add a better description, 20 chars at least!!', report_type: :error)
+  #
+  # @see Automattic/dangermattic
+  # @tags github, pull request, process
+  #
+  class PRSizeChecker < Plugin
+    DEFAULT_DIFF_SIZE_MESSAGE_FORMAT = 'This PR is larger than %d lines of changes. Please consider splitting it into smaller PRs for easier and faster reviews.'
+    DEFAULT_MIN_PR_BODY_MESSAGE_FORMAT = 'The PR description appears very short, less than %d characters long. Please provide a summary of your changes in the PR description.'
+
+    # Check the size of the PR diff against a specified maximum size.
+    #
+    # @param max_size [Integer] The maximum allowed size for the diff.
+    # @param file_selector [Proc] Optional closure to filter the files in the diff to be used for size calculation.
+    # @param type [:insertions, :deletions, :all] The type of diff size to check. (default: :all)
+    # @param message [String] The message to display if the diff size exceeds the maximum. (default: DEFAULT_DIFF_SIZE_MESSAGE)
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_diff_size(max_size:, file_selector: nil, type: :all, message: format(DEFAULT_DIFF_SIZE_MESSAGE_FORMAT, max_size), report_type: :warning)
+      case type
+      when :insertions
+        reporter.report(message: message, type: report_type) if insertions_size(file_selector: file_selector) > max_size
+      when :deletions
+        reporter.report(message: message, type: report_type) if deletions_size(file_selector: file_selector) > max_size
+      when :all
+        reporter.report(message: message, type: report_type) if diff_size(file_selector: file_selector) > max_size
+      end
+    end
+
+    # Check the size of the Pull Request description (PR body) against a specified minimum size.
+    #
+    # @param min_length [Integer] The minimum allowed length for the PR body.
+    # @param message [String] The message to display if the length of the PR body is smaller than the minimum. (default: DEFAULT_MIN_PR_BODY_MESSAGE_FORMAT)
+    # @param report_type [Boolean] If true, fail the PR check when the PR body length is too small. (default: false)
+    #
+    # @return [void]
+    def check_pr_body(min_length:, message: format(DEFAULT_MIN_PR_BODY_MESSAGE_FORMAT, min_length), report_type: :warning)
+      return if danger.github.pr_body.length > min_length
+
+      reporter.report(message: message, type: report_type)
+    end
+
+    # Calculate the total size of insertions in modified files that match the file selector.
+    #
+    # @param file_selector [Proc] Select the files to be used for the insertions calculation.
+    #
+    # @return [Integer] The total size of insertions in the selected modified files.
+    def insertions_size(file_selector: nil)
+      return danger.git.insertions unless file_selector
+
+      filtered_files = git_utils.all_changed_files.select(&file_selector)
+
+      filtered_files.sum do |file|
+        # stats for a file in the GitHub API might be nil, making `info_for_file()` crash
+        next 0 if danger.git.diff.stats[:files][file].nil?
+
+        danger.git.info_for_file(file)&.[](:insertions).to_i
+      end
+    end
+
+    # Calculate the total size of deletions in modified files that match the file selector.
+    #
+    # @param file_selector [Proc] Select the files to be used for the deletions calculation.
+    #
+    # @return [Integer] The total size of deletions in the selected modified files.
+    def deletions_size(file_selector: nil)
+      return danger.git.deletions unless file_selector
+
+      filtered_files = git_utils.all_changed_files.select(&file_selector)
+
+      filtered_files.sum do |file|
+        # stats for a file in the GitHub API might be nil, making `info_for_file()` crash
+        next 0 if danger.git.diff.stats[:files][file].nil?
+
+        danger.git.info_for_file(file)&.[](:deletions).to_i
+      end
+    end
+
+    # Calculate the total size of changes (insertions and deletions) in modified files that match the file selector.
+    #
+    # @param file_selector [Proc] Select the files to be used for the total insertions and deletions calculation.
+    #
+    # @return [Integer] The total size of changes in the selected modified files.
+    def diff_size(file_selector: nil)
+      return danger.git.lines_of_code unless file_selector
+
+      filtered_files = git_utils.all_changed_files.select(&file_selector)
+
+      filtered_files.sum do |file|
+        # stats for a file in the GitHub API might be nil, making `info_for_file()` crash
+        next 0 if danger.git.diff.stats[:files][file].nil?
+
+        danger.git.info_for_file(file)&.[](:deletions).to_i + danger.git.info_for_file(file)&.[](:insertions).to_i
+      end
+    end
+  end
+end

data/lib/dangermattic/plugins/tracks_checker.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Danger
+  # Plugin for checking tracks-related changes and providing instructions in the PR if that's the case.
+  #
+  # @example Checking Tracks changes with default settings:
+  #          tracks_checker.check_tracks_changes
+  #
+  # @example Checking Tracks changes with custom Tracks-related files and usage matchers:
+  #          tracks_files = ['AnalyticsTracking.swift', 'AnalyticsHelper.swift']
+  #          usage_matchers = [/AnalyticsHelper\.sendEvent/]
+  #          tracks_checker.check_tracks_changes(tracks_files: tracks_files, tracks_usage_matchers: usage_matchers)
+  #
+  # @see Automattic/dangermattic
+  # @tags github, pull request, tracks, process
+  #
+  class TracksChecker < Plugin
+    TRACKS_PR_INSTRUCTIONS = <<~MESSAGE
+      This PR contains changes to Tracks-related logic. Please ensure (**author and reviewer**) the following are completed:
+
+      - The tracks events must be validated in the Tracks system.
+      - Verify the internal Tracks spreadsheet has also been updated.
+      - Please consider registering any new events.
+    MESSAGE
+
+    TRACKS_NO_LABEL_INSTRUCTION_FORMAT = "- The PR must be assigned the **%s** label.\n"
+    TRACKS_NO_LABEL_MESSAGE_FORMAT = 'Please ensure the PR has the `%s` label.'
+
+    # Checks the PR diff for changes in Tracks-related files and provides instructions if changes are detected
+    #
+    # @param tracks_files [Array<String>] List of Tracks-related file names to check
+    # @param tracks_usage_matchers [Array<Regexp>] List of regular expressions representing tracks usages to match the diff lines
+    # @param tracks_label [String] A label the check should validate the PR against
+    # @return [void]
+    def check_tracks_changes(tracks_files:, tracks_usage_matchers:, tracks_label:)
+      return unless changes_tracks_files?(tracks_files: tracks_files) || diff_has_tracks_changes?(tracks_usage_matchers: tracks_usage_matchers)
+
+      tracks_message = TRACKS_PR_INSTRUCTIONS
+
+      unless tracks_label.nil? || tracks_label.empty?
+        tracks_message += format(TRACKS_NO_LABEL_INSTRUCTION_FORMAT, tracks_label)
+
+        labels_checker.check(
+          do_not_merge_labels: [],
+          required_labels: [/#{Regexp.escape(tracks_label)}/],
+          required_labels_error: format(TRACKS_NO_LABEL_MESSAGE_FORMAT, tracks_label)
+        )
+      end
+
+      # Tracks-related changes detected: publishing instructions
+      message(tracks_message)
+    end
+
+    private
+
+    def changes_tracks_files?(tracks_files:)
+      git_utils.all_changed_files.any? do |file|
+        tracks_files.any? { |tracks_file| File.basename(file) == File.basename(tracks_file) }
+      end
+    end
+
+    def diff_has_tracks_changes?(tracks_usage_matchers:)
+      matched_lines = git_utils.matching_lines_in_diff_files(
+        files: git_utils.all_changed_files,
+        line_matcher: ->(line) { tracks_usage_matchers.any? { |tracks_usage_match| line.match(tracks_usage_match) } },
+        change_type: nil
+      )
+
+      !matched_lines.empty?
+    end
+  end
+end

data/lib/dangermattic/plugins/view_changes_checker.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Danger
+  # Plugin to make sure View file changes in a Pull Request will have accompanying screenshots in the PR description.
+  #
+  # @example Check if a PR changing views needs to have screenshots
+  #
+  #          # If a PR has view changes, report a warning if there are no screenshots attached
+  #          view_changes_checker.check
+  #
+  # @see Automattic/dangermattic
+  # @tags ios, android, swift, java, kotlin, screenshots
+  #
+  class ViewChangesChecker < Plugin
+    VIEW_EXTENSIONS_IOS = /(View|Button)\.(swift|m)$|\.xib$|\.storyboard$/
+    VIEW_EXTENSIONS_ANDROID = /(?i)(View|Button)\.(java|kt|xml)$/
+
+    MEDIA_IN_PR_BODY_PATTERNS = [
+      %r{https?://\S*\.(gif|jpg|jpeg|png|svg)},
+      %r{https?://\S*\.(mp4|avi|mov|mkv)},
+      %r{https?://\S*github\S+/\S+/assets/\d+/},
+      /!\[(.*?)\]\((.*?)\)/,
+      /<img\s+[^>]*src\s*=\s*[^>]*>/,
+      /<video\s+[^>]*src\s*=\s*[^>]*>/
+    ].freeze
+
+    MESSAGE = 'View files have been modified, but no screenshot or video is included in the pull request. ' \
+              'Consider adding some for clarity.'
+
+    # Checks if view files have been modified and if a screenshot or video is included in the pull request body,
+    # displaying a warning if view files have been modified but no screenshot or video is included.
+    #
+    # @return [void]
+    def check
+      view_files_modified = git.modified_files.any? do |file|
+        VIEW_EXTENSIONS_IOS =~ file || VIEW_EXTENSIONS_ANDROID =~ file
+      end
+
+      pr_has_media = MEDIA_IN_PR_BODY_PATTERNS.any? do |pattern|
+        github.pr_body =~ pattern
+      end
+
+      warn(MESSAGE) if view_files_modified && !pr_has_media
+    end
+  end
+end