danger-dangermattic 1.0.0

data/lib/dangermattic/plugins/android_unit_test_checker.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Danger
+  # This plugin provides methods to check for the presence of unit tests for newly added classes in a pull request.
+  #
+  # @example Check missing unit tests using the default parameters:
+  #          android_unit_test_checker.check_missing_tests
+  #
+  # @example Check missing unit tests while excluding certain classes, subclasses, and paths:
+  #          android_unit_test_checker.check_missing_tests(
+  #            classes_exceptions: [/ViewHolder$/],
+  #            subclasses_exceptions: [/RecyclerView/],
+  #            path_exceptions: ['*.java', 'org/app/ui/**']
+  #          )
+  #
+  # @example Check missing unit tests with a custom bypass label:
+  #          android_unit_test_checker.check_missing_tests(bypass_label: 'BypassTestCheck')
+  #
+  # @example Check missing unit tests excluding certain classes, subclasses and paths:
+  #          android_unit_test_checker.check_missing_tests(classes_exceptions: [/ViewHolder$/], subclasses_exceptions: [/RecyclerView/], path_exceptions: ['*.java', 'org/app/ui/**'])
+  #
+  # @see Automattic/dangermattic
+  # @tags android, unit test, github, pull request
+  #
+  class AndroidUnitTestChecker < Plugin
+    ANY_CLASS_DETECTOR = /class\s+([A-Z]\w+)\s*(.*?)\s*{/m
+    NON_PRIVATE_CLASS_DETECTOR = /(?:\s|public|internal|protected|final|abstract|static)*class\s+([A-Z]\w+)\s*(.*?)\s*{/m
+    DEFAULT_CLASSES_EXCEPTIONS = [
+      /ViewHolder$/,
+      /Module$/,
+      /Button$/
+    ].freeze
+
+    DEFAULT_SUBCLASSES_EXCEPTIONS = [
+      /(Fragment|Activity)\b/,
+      /RecyclerView/,
+      /^BroadcastReceiver$/,
+      /^ContentProvider$/,
+      /Service$/,
+      /View$/,
+      /ViewGroup$/,
+      /Layout$/
+    ].freeze
+
+    DEFAULT_UNIT_TESTS_BYPASS_PR_LABEL = 'unit-tests-exemption'
+
+    # Check and warns about missing unit tests for a Git diff, with optional classes/subclasses to ignore and an
+    # optional PR label to bypass the checks.
+    #
+    # @param classes_exceptions [Array<String>] Optional list of regexes matching class names to exclude from the
+    # check.
+    #   Defaults to DEFAULT_CLASSES_EXCEPTIONS.
+    # @param subclasses_exceptions [Array<String>] Optional list of regexes matching base class names to exclude from
+    # the check.
+    #   Defaults to DEFAULT_SUBCLASSES_EXCEPTIONS.
+    # @param path_exceptions [Array<String>] Optional list of file paths to exclude from the check.
+    #   Defaults to [].
+    # @param bypass_label [String] Optional label to indicate we can bypass the check. Defaults to
+    #   DEFAULT_UNIT_TESTS_BYPASS_PR_LABEL.
+    #
+    # @return [void]
+    def check_missing_tests(classes_exceptions: DEFAULT_CLASSES_EXCEPTIONS,
+                            subclasses_exceptions: DEFAULT_SUBCLASSES_EXCEPTIONS,
+                            path_exceptions: [],
+                            bypass_label: DEFAULT_UNIT_TESTS_BYPASS_PR_LABEL)
+      list = find_classes_missing_tests(
+        git_diff: git.diff,
+        classes_exceptions: classes_exceptions,
+        subclasses_exceptions: subclasses_exceptions,
+        path_exceptions: path_exceptions
+      )
+
+      return if list.empty?
+
+      if danger.github.pr_labels.include?(bypass_label)
+        list.each do |c|
+          warn("Class `#{c.classname}` is missing tests, but `#{bypass_label}` label was set to ignore this.")
+        end
+      else
+        list.each do |c|
+          failure("Please add tests for class `#{c.classname}` (or add `#{bypass_label}` label to ignore this).")
+        end
+      end
+    end
+
+    private
+
+    ClassViolation = Struct.new(:classname, :file)
+
+    # @param git_diff [Git::Diff] the git diff object
+    # @param classes_exceptions [Array<String>] Regexes matching class names to exclude from the check.
+    # @param subclasses_exceptions [Array<String>] Regexes matching base class names to exclude from the check
+    # @param path_exceptions [Array<String>] Regexes matching base class names to exclude from the check
+    #
+    # @return [Array<ClassViolation>] An array of `ClassViolation` objects for each added class that is missing a test
+    def find_classes_missing_tests(git_diff:, classes_exceptions:, subclasses_exceptions:, path_exceptions:)
+      violations = []
+      removed_classes = []
+      added_test_lines = []
+
+      # Parse the diff of each file, storing test lines for test files, and added/removed classes for non-test files
+      git_diff.each do |file_diff|
+        file_path = file_diff.path
+
+        next if path_exceptions.any? { |exception| File.fnmatch?(exception, file_path) }
+
+        if test_file?(path: file_path)
+          # Store added test lines from test files
+          added_test_lines += file_diff.patch.each_line.select do |line|
+            git_utils.change_type(diff_line: line) == :added
+          end
+        else
+          # Detect added classes (violations) and removed classes in non-test files
+          patch = file_diff.patch
+
+          violations += find_violations(
+            path: file_path,
+            diff_patch: patch,
+            classes_exceptions: classes_exceptions,
+            subclasses_exceptions: subclasses_exceptions
+          )
+
+          removed_classes += find_removed_classes(diff_patch: patch)
+        end
+      end
+
+      # We only want newly added classes, not if class signature was modified or line was moved
+      violations.reject! { |v| removed_classes.include?(v.classname) }
+
+      # For each remaining candidate, only keep the ones _not_ used in a new test.
+      # The regex will match usages of this class in any test file
+      violations.select { |v| added_test_lines.none? { |line| line =~ /\b#{v.classname}\b/ } }
+    end
+
+    # Finds added classes that potentially will require a test (violations) in the given file based on the changes in the diff patch.
+    #
+    # @param path [String] The file in the diff to check for violations.
+    # @param diff_patch [String] The diff patch containing the changes to the file.
+    # @param classes_exceptions [Array<String>] An array of class names that are exceptions and should be ignored.
+    # @param subclasses_exceptions [Array<String>] An array of class names whose subclasses should be ignored as well.
+    #
+    # @return [Array<ClassViolation>] An array of ClassViolation objects representing the violations found.
+    def find_violations(path:, diff_patch:, classes_exceptions:, subclasses_exceptions:)
+      added_lines = git_utils.added_lines(diff_patch: diff_patch)
+      matches = added_lines.scan(NON_PRIVATE_CLASS_DETECTOR)
+      matches.reject! do |m|
+        class_match_is_exception?(
+          m,
+          path,
+          classes_exceptions,
+          subclasses_exceptions
+        )
+      end
+
+      matches.map { |m| ClassViolation.new(m[0], path) }
+    end
+
+    # Finds the names of removed classes based on the removals the diff patch.
+    #
+    # @param diff_patch [String] The diff patch containing the changes to the file.
+    #
+    # @return [Array<String>] An array with the class names of the classes that were removed in the diff.
+    def find_removed_classes(diff_patch:)
+      removed_lines = git_utils.removed_lines(diff_patch: diff_patch)
+      matches = removed_lines.scan(ANY_CLASS_DETECTOR)
+      matches.map { |m| m[0] }
+    end
+
+    # @param match [Array<String>] match an array of captured substrings matching our `*_CLASS_DETECTOR` for a given line
+    # @param file [String] file the path to the file where that class declaration line was matched
+    # @param classes_exceptions [Array<String>] Regexes matching class names to exclude from the check.
+    # @param subclasses_exceptions [Array<String>] Regexes matching base class names to exclude from the check
+    #
+    # @return [void]
+    def class_match_is_exception?(match, file, classes_exceptions, subclasses_exceptions)
+      return true if classes_exceptions.any? { |re| match[0] =~ re }
+
+      subclass_regexp = File.extname(file) == '.java' ? /extends\s+([A-Z]\w+)/m : /\s*:\s*([A-Z]\w+)/m
+      subclass = match[1].scan(subclass_regexp)&.last&.last
+      subclasses_exceptions.any? { |re| subclass =~ re }
+    end
+
+    def test_file?(path:)
+      path.match? %r{/(test|androidTest).*\.(java|kt)$}
+    end
+  end
+end

data/lib/dangermattic/plugins/common/common_release_checker.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Danger
+  # Plugin to perform generic checks related to releases.
+  # It can be used directly or via the specialised plugins `AndroidReleaseChecker` and `IosReleaseChecker`.
+  #
+  # @example Checking if a specific file has changed on a release branch:
+  #          common_release_checker.check_file_changed(
+  #            file_comparison: ->(path) { path == 'metadata/full_release_notes.txt' },
+  #            message: 'Release notes have been modified on a release branch.',
+  #            on_release_branch: true
+  #          )
+  #
+  # @example Checking if release notes and store strings have changed:
+  #          common_release_checker.check_release_notes_and_store_strings(
+  #            release_notes_file: 'metadata/release_notes.txt',
+  #            po_file: 'metadata/PlayStoreStrings.po'
+  #          )
+  #
+  # @example Checking for changes in internal release notes:
+  #          common_release_checker.check_internal_release_notes_changed
+  #
+  # @see Automattic/dangermattic
+  # @tags util, process, release
+  #
+  class CommonReleaseChecker < Plugin
+    DEFAULT_INTERNAL_RELEASE_NOTES = 'RELEASE-NOTES.txt'
+
+    MESSAGE_STORE_FILE_NOT_CHANGED = 'The `%s` file should be updated if the editorialized release notes file `%s` is being changed.'
+    MESSAGE_INTERNAL_RELEASE_NOTES_CHANGED = <<~WARNING
+      This PR contains changes to `%s`.
+      Note that these changes won't affect the final version of the release notes as this version is in code freeze.
+      Please, get in touch with a release manager if you want to update the final release notes.
+    WARNING
+
+    # Check if certain files have been modified, returning a warning or failure message based on the branch type.
+    #
+    # @param file_comparison [Proc] Function used to compare modified file paths.
+    #   It should take a single argument, which is the path to a modified file,
+    #   and return true if the file matches the desired condition.
+    #   Example: `file_comparison = ->(file_path) { file_path.include?('app/') }`
+    #
+    # @param message [String] The message to display in the warning or failure output if the condition is met.
+    #
+    # @param on_release_branch [Boolean] If true, the check will only run on release branches, otherwise on non-release branches.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @example Check if any modified file is under the 'app/' directory and emit a warning on release branches:
+    #   check_file_changed(file_comparison: ->(file_path) { file_path.include?('app/') },
+    #                      message: 'Some files in the "app/" directory have been modified. Please review the changes.',
+    #                      on_release_branch: true)
+    #
+    # @example Check if a specific file has been modified and emit a failure on non-release branches:
+    #   check_file_changed(file_comparison: ->(file_path) { file_path == 'path/to/file/DoNotChange.java' },
+    #                      message: 'The "DoNotChange.java" file has been modified. This change is not allowed on non-release branches.',
+    #                      on_release_branch: false,
+    #                      report_type: :error)
+    #
+    # @return [void]
+    def check_file_changed(file_comparison:, message:, on_release_branch:, report_type: :warning)
+      has_modified_file = git_utils.all_changed_files.any?(&file_comparison)
+
+      should_be_changed = (on_release_branch == github_utils.release_branch?)
+      return unless should_be_changed && has_modified_file
+
+      reporter.report(message: message, type: report_type)
+    end
+
+    # Check if the release notes and store strings files are correctly updated after a modification to the release notes.
+    #
+    # @param release_notes_file [String] The name of the release notes file that should be checked for modifications.
+    #   Example: 'metadata/release_notes.txt'
+    #
+    # @param po_file [String] The name of the store strings file that should be checked for modifications.
+    #   Example: 'metadata/PlayStoreStrings.po'
+    #
+    # @example Check if the release notes file 'release_notes.txt' is modified, and the 'PlayStoreStrings.po' file is not modified, posting a message:
+    #          check_release_notes_and_store_strings(release_notes_file: 'release_notes.txt', po_file: 'PlayStoreStrings.po')
+    #
+    # @return [void]
+    def check_release_notes_and_store_strings(release_notes_file:, po_file:)
+      has_modified_release_notes = danger.git.modified_files.any? { |f| f == release_notes_file }
+      has_modified_app_store_strings = danger.git.modified_files.any? { |f| f == po_file }
+
+      return unless has_modified_release_notes && !has_modified_app_store_strings
+
+      message(format(MESSAGE_STORE_FILE_NOT_CHANGED, po_file, release_notes_file))
+    end
+
+    # Check if there are changes to the internal release notes file in the release branch and emit a warning if that's the case.
+    #
+    # @param release_notes_file [String] (optional) The path to the internal release notes file.
+    #        Defaults to the `DEFAULT_INTERNAL_RELEASE_NOTES` constant if not provided.
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @example Checking for changes in the default internal release notes file:
+    #   check_internal_release_notes_changed
+    #
+    # @example Checking for changes in a custom internal release notes file at a specific path:
+    #   check_internal_release_notes_changed(release_notes_file: '/path/to/internal_release_notes.txt')
+    #
+    # @return [void]
+    def check_internal_release_notes_changed(release_notes_file: DEFAULT_INTERNAL_RELEASE_NOTES, report_type: :warning)
+      check_file_changed(
+        file_comparison: ->(path) { path == release_notes_file },
+        message: format(MESSAGE_INTERNAL_RELEASE_NOTES_CHANGED, release_notes_file),
+        on_release_branch: true,
+        report_type: report_type
+      )
+    end
+  end
+end

data/lib/dangermattic/plugins/common/git_utils.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Danger
+  # Represents a utility plugin for working with Git: to check added and modified lines in Git diffs,
+  # to determine the type of change (added, removed, or other) in a diff line, and to retrieve lists of
+  # added, modified, and deleted files.
+  #
+  # @example Check if there is a "TODO" in Ruby files:
+  #          git_utils.check_added_diff_lines(
+  #            file_selector: ->(path) { path.end_with?('.rb') },
+  #            line_matcher: ->(line) { line.include?('TODO') },
+  #            message: 'Found a TODO in a Ruby file'
+  #          )
+  #
+  # @example Get added lines from a diff patch:
+  #          added_lines = git_utils.added_lines(diff_patch: diff_patch)
+  #
+  # @example Get removed lines from a diff patch:
+  #          removed_lines = git_utils.removed_lines(diff_patch: diff_patch)
+  #
+  # @example Determining the change type of a diff line:
+  #          git_utils.change_type(diff_line: "+ new line added")
+  #          #=> :added
+  #
+  #         git_utils.change_type(diff_line: "- line removed")
+  #         #=> :removed
+  #
+  #         git_utils.change_type(diff_line: " context line")
+  #         #=> :other
+  #
+  # @example Select removed lines from a diff patch:
+  #          removed_lines = git_utils.select_lines(diff_patch: diff_patch, change_type: :removed)
+  #
+  # @see Automattic/dangermattic
+  # @tags tool, util, git
+  #
+  class GitUtils < Plugin
+    # Check added lines in a PR for a specific pattern and issue a warning or failure message when found.
+    #
+    # @param file_selector [Proc] A block to select the files in the PR.
+    #   The block should take a file path as input and return true if the file should be checked.
+    #
+    # @param line_matcher [Proc] A block that will select the diff lines to report.
+    #   The block should take a line of text as input and return true if the line matches the pattern.
+    #
+    # @param message [String] The warning or failure message to display when the pattern is found in a line.
+    #
+    # @param report_type [Symbol] (optional) Type of report (:error, :warning, :message) whenever a line matches the criteria. Default is :warning.
+    #
+    # @example Checking for added lines containing 'FIXME' and failing the build:
+    #   check_added_diff_lines(file_selector: ->(path) { File.extname(path) == ('.swift') }, line_matcher: ->(line) { line.include?("FIXME") }, message: "A FIXME was added, failing build.", report_type: :error)
+    #
+    # @return [void]
+    def check_added_diff_lines(file_selector:, line_matcher:, message:, report_type: :warning)
+      modified_files = added_and_modified_files.select(&file_selector)
+
+      matches = matching_lines_in_diff_files(
+        files: modified_files,
+        line_matcher: line_matcher,
+        change_type: :added
+      )
+
+      matches.each do |match|
+        match.lines.each do |line|
+          final_message = <<~MESSAGE
+            #{message}
+            File `#{match.file}`:
+            ```diff
+            #{line.chomp}
+            ```
+          MESSAGE
+
+          reporter.report(message: final_message, type: report_type)
+        end
+      end
+    end
+
+    MatchedData = Struct.new(:file, :lines)
+
+    # Matches diff lines in the provided files based on the line matcher and change type
+    #
+    # @param files [Array<String>] List of file names to check
+    # @param line_matcher [Proc] A callable that takes a line and returns true if it matches the desired pattern
+    # @param change_type [Symbol, nil] Change type to filter lines (e.g., :added, :removed) or nil for no filter
+    # @return [Array<MatchedData>] Array of MatchedData objects representing matched lines in files
+    def matching_lines_in_diff_files(files:, line_matcher:, change_type: nil)
+      matched_data = []
+
+      files.each do |file|
+        matched_lines = []
+
+        diff = danger.git.diff_for_file(file)
+
+        diff.patch.each_line do |line|
+          matched_lines << line if line_matcher.call(line) && (change_type.nil? || change_type(diff_line: line) == change_type)
+        end
+
+        matched_data << MatchedData.new(file, matched_lines) unless matched_lines.empty?
+      end
+
+      matched_data
+    end
+
+    # Determine the type of change for a given line in a git diff.
+    #
+    # @param diff_line [String] The line from a git diff that needs to be classified.
+    #
+    # @return [Symbol] The type of change for the given diff line. Possible values are:
+    #   - :added for added lines
+    #   - :removed for removed lines
+    #   - :other for any other type of lines
+    def change_type(diff_line:)
+      if diff_line.start_with?('+') && !diff_line.start_with?('+++ ')
+        :added
+      elsif diff_line.start_with?('-') && !diff_line.start_with?('--- ')
+        :removed
+      else
+        :other
+      end
+    end
+
+    # Get the list of added and modified files in the current Pull Request.
+    #
+    # @return [Array<String>] An array containing the file paths of added and modified files.
+    def added_and_modified_files
+      danger.git.added_files + danger.git.modified_files
+    end
+
+    # Get the list of all files added, modified and deleted in the current Pull Request.
+    #
+    # @return [Array<String>] An array containing the file paths of all changed files.
+    #
+    def all_changed_files
+      danger.git.added_files + danger.git.modified_files + danger.git.deleted_files
+    end
+
+    # Returns the lines that were added in the given diff patch.
+    #
+    # @param diff_patch [String] The diff patch containing the changes.
+    #
+    # @return [String] A concatenated string of added lines.
+    def added_lines(diff_patch:)
+      select_lines(diff_patch: diff_patch, change_type: :added)
+    end
+
+    # Returns the lines that were removed in the given diff patch.
+    #
+    # @param diff_patch [String] The diff patch containing the changes.
+    #
+    # @return [String] A concatenated string of removed lines.
+    def removed_lines(diff_patch:)
+      select_lines(diff_patch: diff_patch, change_type: :removed)
+    end
+
+    # Selects lines of a specific change type (added or removed) from the given diff patch.
+    #
+    # @param diff_patch [String] The diff patch containing the changes.
+    # @param change_type [Symbol] The desired change type (:added or :removed).
+    #
+    # @return [String] A concatenated string of selected lines of the specified change type.
+    def select_lines(diff_patch:, change_type:)
+      selected_lines = diff_patch.lines.select { |line| change_type(diff_line: line) == change_type }
+      selected_lines.map { |line| line[1..] }.join
+    end
+  end
+end

data/lib/dangermattic/plugins/common/github_utils.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Danger
+  # Provides common GitHub utility methods related to Pull Requests in a Danger context.
+  #
+  # @example Checking if the branch is a release or hotfix branch:
+  #   github_utils.release_branch? #=> true or false
+  #
+  # @example Checking if there are active reviewers on the PR:
+  #   github_utils.active_reviewers? #=> true or false
+  #
+  # @example Checking if there are requested teams or reviewers on the PR:
+  #   github_utils.requested_reviewers? #=> true or false
+  #
+  # @example Checking if the branch is a main branch (trunk, main, master, or develop):
+  #   github_utils.main_branch? #=> true or false
+  #
+  # @example Checking if the PR is a work-in-progress (WIP) based on labels or title:
+  #   github_utils.wip_feature? #=> true or false
+  #
+  # @see Automattic/dangermattic
+  # @tags tool, util
+  #
+  class GithubUtils < Plugin
+    # Checks if there are active reviewers providing feedback and potentially changing the state of the PR
+    # (e.g., approved, changes requested).
+    #
+    # @return [Boolean] True if there are active reviewers, otherwise false.
+    def active_reviewers?
+      repo_name = github.pr_json['base']['repo']['full_name']
+      pr_number = github.pr_json['number']
+
+      !github.api.pull_request_reviews(repo_name, pr_number).empty?
+    end
+
+    # Checks if there are requested teams or reviewers who haven't reacted yet.
+    #
+    # @return [Boolean] True if there are requested teams or reviewers, otherwise false.
+    def requested_reviewers?
+      has_requested_reviews = !github.pr_json['requested_teams'].to_a.empty? || !github.pr_json['requested_reviewers'].to_a.empty?
+      has_requested_reviews || active_reviewers?
+    end
+
+    # Checks if the current branch is a main branch (trunk, main, master, or develop).
+    #
+    # @return [Boolean] True if the branch is a main branch, otherwise false.
+    def main_branch?
+      %w[trunk main master develop].include?(github.branch_for_base)
+    end
+
+    # Checks if the current branch is a release or hotfix branch.
+    #
+    # @return [Boolean] True if the branch is a release or hotfix branch, otherwise false.
+    def release_branch?
+      github.branch_for_base.start_with?('release/') || github.branch_for_base.start_with?('hotfix/')
+    end
+
+    # Checks if the PR is a work-in-progress (WIP) based on labels or title.
+    #
+    # @return [Boolean] True if the PR is a work-in-progress, otherwise false.
+    def wip_feature?
+      has_wip_label = github.pr_labels.any? { |label| label.include?('WIP') }
+      has_wip_title = github.pr_title.include?('WIP')
+
+      has_wip_label || has_wip_title
+    end
+  end
+end

data/lib/dangermattic/plugins/common/reporter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Danger
+  # Handles reporting messages in the context of Danger, allowing the generation of
+  # warnings, errors, and simple messages in a Danger run.
+  #
+  # @example Reporting a Warning
+  #   reporter.report(message: "This is a warning message", type: :warning)
+  #
+  # @example Reporting an Error
+  #   reporter.report(message: "This is an error message", type: :error)
+  #
+  # @see Automattic/dangermattic
+  # @tags tool, util, danger
+  #
+  class Reporter < Plugin
+    # Report a message to be posted by Danger as an error (failing the build), a warning or a simple message.
+    #
+    # @param message [String] The message to be reported to Danger.
+    # @param type [Symbol] The type of report. Possible values:
+    #                        - :warning (default): Reports a warning.
+    #                        - :error: Reports an error.
+    #                        - :message: Reports a simple message.
+    #                        - Any other value or nil: Takes no action.
+    #
+    # @return [void]
+    def report(message:, type: :warning)
+      case type
+      when :error
+        failure(message)
+      when :warning
+        warn(message)
+      when :message
+        danger.message(message)
+      end
+    end
+  end
+end

data/lib/dangermattic/plugins/ios_release_checker.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Danger
+  # Plugin for performing iOS / macOS release-related checks in a pull request.
+  #
+  # @example Checking for changes in Core Data models on a release branch:
+  #          ios_release_checker.check_core_data_model_changed
+  #
+  # @example Checking for modified Localizable.strings on a regular branch:
+  #          ios_release_checker.check_modified_localizable_strings
+  #
+  # @example Checking for synchronization between release notes and App Store strings:
+  #          ios_release_checker.check_release_notes_and_app_store_strings
+  #
+  # @see Automattic/dangermattic
+  # @tags ios, macos, process, release
+  #
+  class IosReleaseChecker < Plugin
+    LOCALIZABLE_STRINGS_FILE = 'Localizable.strings'
+    BASE_STRINGS_FILE = "en.lproj/#{LOCALIZABLE_STRINGS_FILE}".freeze
+
+    MESSAGE_STRINGS_FILE_UPDATED = "The `#{LOCALIZABLE_STRINGS_FILE}` files should only be updated on release branches, when the translations are downloaded by our automation.".freeze
+    MESSAGE_BASE_STRINGS_FILE_UPDATED = "The `#{BASE_STRINGS_FILE}` file should only be updated before creating a release branch.".freeze
+    MESSAGE_TRANSLATION_FILE_UPDATED = "Translation files `*.lproj/#{LOCALIZABLE_STRINGS_FILE}` should only be updated on a release branch.".freeze
+    MESSAGE_CORE_DATA_UPDATED = 'Do not edit an existing Core Data model in a release branch unless it hasn\'t been released to testers yet. ' \
+                                'Instead create a new model version and merge back to develop soon.'
+
+    # Checks if an existing Core Data model has been edited in a release branch.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_core_data_model_changed(report_type: :warning)
+      common_release_checker.check_file_changed(
+        file_comparison: ->(path) { File.extname(path) == '.xcdatamodeld' },
+        message: MESSAGE_CORE_DATA_UPDATED,
+        on_release_branch: true,
+        report_type: report_type
+      )
+    end
+
+    # Checks if any Localizable.strings file has been modified on a release branch, otherwise reporting a warning.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_modified_localizable_strings_on_release(report_type: :warning)
+      common_release_checker.check_file_changed(
+        file_comparison: ->(path) { File.basename(path) == LOCALIZABLE_STRINGS_FILE },
+        message: MESSAGE_STRINGS_FILE_UPDATED,
+        on_release_branch: false,
+        report_type: report_type
+      )
+    end
+
+    # Checks if the en.lproj/Localizable.strings file has been modified on a regular branch, otherwise reporting a warning.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_modified_en_strings_on_regular_branch(report_type: :warning)
+      common_release_checker.check_file_changed(
+        file_comparison: ->(path) { base_strings_file?(path: path) },
+        message: MESSAGE_BASE_STRINGS_FILE_UPDATED,
+        on_release_branch: true,
+        report_type: report_type
+      )
+    end
+
+    # Checks if a translation file (*.lproj/Localizable.strings) has been modified on a release branch, otherwise reporting a warning.
+    #
+    # @param report_type [Symbol] (optional) The type of report for the message. Types: :error, :warning (default), :message.
+    #
+    # @return [void]
+    def check_modified_translations_on_release_branch(report_type: :warning)
+      common_release_checker.check_file_changed(
+        file_comparison: ->(path) { !base_strings_file?(path: path) && File.basename(path) == LOCALIZABLE_STRINGS_FILE },
+        message: MESSAGE_TRANSLATION_FILE_UPDATED,
+        on_release_branch: false,
+        report_type: report_type
+      )
+    end
+
+    # Checks if changes made to the release notes are also followed by changes in the App Store strings file.
+    #
+    # @return [void]
+    def check_release_notes_and_app_store_strings
+      common_release_checker.check_release_notes_and_store_strings(
+        release_notes_file: 'Resources/release_notes.txt',
+        po_file: 'Resources/AppStoreStrings.po'
+      )
+    end
+
+    private
+
+    # Checks if a given path corresponds to the base (English) strings file, en.lproj/Localizable.strings.
+    #
+    # @return [Boolean] true if path is the base strings file
+    def base_strings_file?(path:)
+      base_strings_path_components = Pathname.new(BASE_STRINGS_FILE).each_filename.to_a
+      path_components = Pathname.new(path).each_filename.to_a
+
+      base_strings_path_components == path_components.last(base_strings_path_components.length)
+    end
+  end
+end