fastlane-plugin-wpmreleasetoolkit 1.3.1 → 2.2.0

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/comment_on_pr.rb

@@ -0,0 +1,89 @@
+require 'fastlane/action'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      PR_COMMENT_REUSE_IDENTIFIER = :PR_COMMENT_REUSE_IDENTIFIER
+    end
+
+    class CommentOnPrAction < Action
+      def self.run(params)
+        require_relative '../../helper/github_helper'
+
+        reuse_identifier = Fastlane::Helper::GithubHelper.comment_on_pr(
+          project_slug: params[:project],
+          pr_number: params[:pr_number],
+          body: params[:body],
+          reuse_identifier: params[:reuse_identifier]
+        )
+
+        Actions.lane_context[SharedValues::PR_COMMENT_REUSE_IDENTIFIER] = reuse_identifier
+
+        reuse_identifier
+      end
+
+      def self.description
+        'Post a comment on a given PR number (optionally updating an existing one)'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.details
+        <<~DETAILS
+          If used just once, this method makes it nice and easy to post a quick comment to a GitHub PR.
+
+          Subsequent runs will allow you to update an existing comment as many times as you need to
+          (e.g. across multiple CI runs), by using a `:reuse_identifier` to identify the comment to update.
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :access_token,
+            env_name: 'GITHUB_TOKEN',
+            description: 'The GitHub token to use for posting the comment',
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :reuse_identifier,
+            description: 'If provided, the reuse identifier can identify an existing comment to overwrite',
+            type: String,
+            default_value: nil
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :project,
+            description: 'The project slug (ex: `wordpress-mobile/wordpress-ios`)',
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :pr_number,
+            description: 'The PR number',
+            type: Integer
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :body,
+            description: 'The content of the comment',
+            type: String
+          ),
+        ]
+      end
+
+      def self.output
+        [
+          ['PR_COMMENT_REUSE_IDENTIFIER', 'The `reuse_identifier` for the most recently posted comment'],
+        ]
+      end
+
+      def self.return_value
+        'The `reuse_identifier` for the posted comment (useful for updating it later, if needed)'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_release_action.rb

@@ -10,7 +10,9 @@ module Fastlane
         repository = params[:repository]
         version = params[:version]
         assets = params[:release_assets]
-        release_notes = params[:release_notes_file_path].nil? ? '' : IO.read(params[:release_notes_file_path])
+        release_notes = params[:release_notes_file_path].nil? ? '' : File.read(params[:release_notes_file_path])
+        # Replace full URLS to PRs/Issues with shorthand, because GitHub does not render them properly otherwise.
+        release_notes.gsub!(%r{https://github.com/([^/]*/[^/]*)/(pulls?|issues?)/([0-9]*)}, '\1#\3')
         prerelease = params[:prerelease]
 
         UI.message("Creating draft release #{version} in #{repository}.")

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_bump_version_hotfix.rb

@@ -9,14 +9,18 @@ module Fastlane
         create_config(params[:previous_version], params[:version])
         show_config()
 
-        UI.message 'Updating Fastlane deliver file...'
-        Fastlane::Helper::Ios::VersionHelper.update_fastlane_deliver(@new_short_version)
-        UI.message 'Done!'
+        update_deliverfile = params[:skip_deliver] == false
+        if update_deliverfile
+          UI.message 'Updating Fastlane deliver file...'
+          Fastlane::Helper::Ios::VersionHelper.update_fastlane_deliver(@new_short_version)
+          UI.message 'Done!'
+        end
+
         UI.message 'Updating XcConfig...'
         Fastlane::Helper::Ios::VersionHelper.update_xc_configs(@new_version, @new_short_version, @new_version_internal)
         UI.message 'Done!'
 
-        Fastlane::Helper::Ios::GitHelper.commit_version_bump(include_deliverfile: true, include_metadata: false)
+        Fastlane::Helper::Ios::GitHelper.commit_version_bump(include_deliverfile: update_deliverfile, include_metadata: false)
 
         UI.message 'Done.'
       end
@@ -34,18 +38,29 @@ module Fastlane
       end
 
       def self.available_options
-        # Define all options your action supports.
-
-        # Below a few examples
         [
-          FastlaneCore::ConfigItem.new(key: :version,
-                                       env_name: 'FL_IOS_BUMP_VERSION_HOTFIX_VERSION',
-                                       description: 'The version of the hotfix',
-                                       is_string: true),
-          FastlaneCore::ConfigItem.new(key: :previous_version,
-                                       env_name: 'FL_IOS_BUMP_VERSION_HOTFIX_PREVIOUS_VERSION',
-                                       description: 'The version to branch from',
-                                       is_string: true), # the default value if the user didn't provide one
+          FastlaneCore::ConfigItem.new(
+            key: :version,
+            env_name: 'FL_IOS_BUMP_VERSION_HOTFIX_VERSION',
+            description: 'The version of the hotfix',
+            is_string: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :previous_version,
+            env_name: 'FL_IOS_BUMP_VERSION_HOTFIX_PREVIOUS_VERSION',
+            description: 'The version to branch from',
+            is_string: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :skip_deliver,
+            env_name: 'FL_IOS_BUMP_VERSION_HOTFIX_SKIP_DELIVER',
+            description: 'Skips Deliverfile key update',
+            is_string: false, # Boolean parameter
+            optional: true,
+            # Don't skip the Deliverfile by default. At the time of writing, 2 out of 3 consumers
+            # still have a Deliverfile.
+            default_value: false
+          ),
         ]
       end
 

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_generate_strings_file_from_code.rb

@@ -0,0 +1,115 @@
+module Fastlane
+  module Actions
+    class IosGenerateStringsFileFromCodeAction < Action
+      def self.run(params)
+        files = files_matching(paths: params[:paths], exclude: params[:exclude])
+        flags = [('-q' if params[:quiet]), ('-SwiftUI' if params[:swiftui])].compact
+        flags += Array(params[:routines]).flat_map { |routine| ['-s', routine] }
+        cmd = ['genstrings', '-o', params[:output_dir], *flags, *files]
+        out = Actions.sh_control_output(*cmd, print_command: FastlaneCore::Globals.verbose?, print_command_output: true)
+        out = out.scrub.strip.split("\n")
+        errors = out.select { |line| line.include?('genstrings: error: ') }
+        UI.user_error!(errors.join("\n")) unless !params[:fail_on_error] || errors.empty?
+        out
+      end
+
+      # Adds the proper `**/*.{m,swift}` to the list of paths
+      def self.glob_pattern(path)
+        if path.end_with?('**') || path.end_with?('**/')
+          File.join(path, '*.{m,swift}')
+        elsif File.directory?(path) || path.end_with?('/')
+          File.join(path, '**', '*.{m,swift}')
+        else
+          path
+        end
+      end
+
+      def self.files_matching(paths:, exclude:)
+        globbed_paths = paths.map { |p| glob_pattern(p) }
+        Dir.glob(globbed_paths).reject do |file|
+          exclude&.any? { |ex| File.fnmatch?(ex, file) }
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Generate the .strings files from your Objective-C and Swift code'
+      end
+
+      def self.details
+        <<~DETAILS
+          Uses `genstrings` to generate the `.strings` files from your Objective-C and Swift code.
+          (especially `Localizable.strings` but it could generate more if the code uses custom tables).
+
+          You can provide a list of paths to scan but also paths to exclude. Both supports glob patterns.
+          You can also optionally provide a list of custom "routines" (aka macros or functions) that
+          `genstrings` should parse in addition to the usual `NSLocalizedString`. (see `-s` option of `genstrings`).
+
+          Tip: support for custom routines is useful if some of your targets define a helper function e.g.
+          `PodLocalizedString` to wrap calls to `Bundle.localizedString(forKey: key, value: value, table: nil)`,
+          just like the build-in `NSLocalizedString` does, but providing a custom bundle to look up the strings from.
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :paths,
+                                       env_name: 'FL_IOS_GENERATE_STRINGS_FILE_FROM_CODE_PATHS',
+                                       description: 'Array of paths to scan for `.m` and `.swift` files. The entries can also contain glob patterns',
+                                       type: Array,
+                                       default_value: ['.']),
+          FastlaneCore::ConfigItem.new(key: :exclude,
+                                       env_name: 'FL_IOS_GENERATE_STRINGS_FILE_FROM_CODE_EXCLUDE',
+                                       description: 'Array of paths or glob patterns to exclude from scanning',
+                                       type: Array,
+                                       default_value: []),
+          FastlaneCore::ConfigItem.new(key: :routines,
+                                       env_name: 'FL_IOS_GENERATE_STRINGS_FILE_FROM_CODE_ROUTINES',
+                                       description: 'Base name of the alternate methods to be parsed in addition to the standard `NSLocalizedString()` one. See the `-s` option in `man genstrings`',
+                                       type: Array,
+                                       default_value: []),
+          FastlaneCore::ConfigItem.new(key: :quiet,
+                                       env_name: 'FL_IOS_GENERATE_STRINGS_FILE_FROM_CODE_QUIET',
+                                       description: 'In quiet mode, `genstrings` will log warnings about duplicate values, but not about duplicate comments',
+                                       is_string: false, # Boolean
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :swiftui,
+                                       env_name: 'FL_IOS_GENERATE_STRINGS_FILE_FROM_CODE_SWIFTUI',
+                                       description: "Should we include SwiftUI's `Text()` when parsing code with `genstrings`",
+                                       is_string: false, # Boolean
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :output_dir,
+                                       env_name: 'FL_IOS_GENERATE_STRINGS_FILE_FROM_CODE_OUTPUT_DIR',
+                                       description: 'The path to the directory where the generated `.strings` files should be created',
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :fail_on_error,
+                                       env_name: 'FL_IOS_GENERATE_STRINGS_FILE_FROM_CODE_FAIL_ON_ERROR',
+                                       description: 'If true, will fail with user_error! if `genstrings` printed any error while parsing',
+                                       is_string: false, # Boolean
+                                       default_value: true),
+        ]
+      end
+
+      def self.return_type
+        # Describes what type of data is expected to be returned
+        # see RETURN_TYPES in https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/action.rb
+        :array_of_strings
+      end
+
+      def self.return_value
+        'List of warning lines generated by genstrings on stdout'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_localize_project.rb

@@ -20,16 +20,15 @@ module Fastlane
       end
 
       def self.details
-        'Gathers the string to localise'
-      end
-
-      def self.available_options
+        'Gathers the string to localise. Deprecated in favor of the new `ios_generate_strings_file_from_code`'
       end
 
-      def self.output
+      def self.category
+        :deprecated
       end
 
-      def self.return_value
+      def self.deprecated_notes
+        'This action is deprecated in favor of `ios_generate_strings_file_from_code`'
       end
 
       def self.authors

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/an_metadata_update_helper.rb

@@ -50,7 +50,7 @@ module Fastlane
 
         if line_count <= 1
           # Single line output
-          fw.puts("msgid \"#{File.open(@content_file_path, 'r').read}\"")
+          fw.puts("msgid \"#{File.open(@content_file_path, 'r').read.rstrip}\"")
         else
           # Multiple line output
           fw.puts('msgid ""')

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_git_helper.rb

@@ -13,7 +13,7 @@ module Fastlane
         #
         def self.commit_version_bump
           require_relative './android_version_helper'
-          if Fastlane::Helper::Android::VersionHelper.properties_file_exists
+          if File.exist?(Fastlane::Helper::Android::VersionHelper.version_properties_file)
             Fastlane::Helper::GitHelper.commit(
               message: 'Bump version number',
               files: File.join(ENV['PROJECT_ROOT_FOLDER'], 'version.properties'),

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_version_helper.rb

@@ -26,14 +26,12 @@ module Fastlane
         #    "1.2" # Assuming build.gradle contains versionName "1.2.0"
         #    "1.2.3" # Assuming build.gradle contains versionName "1.2.3"
         #
-        # @param [String] app The name of the app to be used for beta and alpha version update
-        #
         # @return [String] The public-facing version number, extracted from the `versionName` of the `build.gradle` file.
         #         - If this version is a hotfix (more than 2 parts and 3rd part is non-zero), returns the "X.Y.Z" formatted string
         #         - Otherwise (not a hotfix / 3rd part of version is 0), returns "X.Y" formatted version number
         #
-        def self.get_public_version(app)
-          version = get_release_version(product_name: app)
+        def self.get_public_version
+          version = get_release_version
           vp = get_version_parts(version[VERSION_NAME])
           return "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}" unless is_hotfix?(version)
 
@@ -42,12 +40,10 @@ module Fastlane
 
         # Extract the version name and code from the release version of the app from `version.properties file`
         #
-        # @param [String] product_name The name of the app to be used for beta and alpha version update
-        #
         # @return [Hash] A hash with 2 keys "name" and "code" containing the extracted version name and code, respectively
         #
-        def self.get_release_version(product_name:)
-          return get_version_from_properties(product_name: product_name) if properties_file_exists
+        def self.get_release_version
+          return get_version_from_properties() if File.exist?(version_properties_file)
 
           section = ENV['HAS_ALPHA_VERSION'].nil? ? 'defaultConfig' : 'vanilla {'
           gradle_path = self.gradle_path
@@ -56,66 +52,36 @@ module Fastlane
           return { VERSION_NAME => name, VERSION_CODE => code }
         end
 
-        def self.properties_file_exists
-          properties_file_path = File.join(ENV['PROJECT_ROOT_FOLDER'] || '.', 'version.properties')
-
-          return File.exist?(properties_file_path)
+        def self.version_properties_file
+          File.join(ENV['PROJECT_ROOT_FOLDER'] || '.', 'version.properties')
         end
 
         # Extract the version name and code from the `version.properties` file in the project root
         #
-        # @param [String] product_name The name of the app to extract the version from e.g. wordpress, simplenote
         # @param [Boolean] is_alpha true if the alpha version should be returned, false otherwise
         #
         # @return [Hash] A hash with 2 keys "name" and "code" containing the extracted version name and code, respectively
         #
-        def self.get_version_from_properties(product_name:, is_alpha: false)
-          alpha_variant = is_alpha ? alpha_flavor_name : nil
-          version_name_key = [product_name, alpha_variant, 'versionName'].compact.join('.')
-          version_code_key = [product_name, alpha_variant, 'versionCode'].compact.join('.')
+        def self.get_version_from_properties(is_alpha: false)
+          return nil unless File.exist?(version_properties_file)
 
-          properties_file_path = File.join(ENV['PROJECT_ROOT_FOLDER'] || '.', 'version.properties')
+          version_name_key = is_alpha ? 'alpha.versionName' : 'versionName'
+          version_code_key = is_alpha ? 'alpha.versionCode' : 'versionCode'
 
-          return nil unless File.exist?(properties_file_path)
-
-          File.open(properties_file_path, 'r') do |f|
-            text = f.read
-            name = text.match(/#{version_name_key}=(\S*)/m)&.captures&.first
-            code = text.match(/#{version_code_key}=(\S*)/m)&.captures&.first
+          text = File.read(version_properties_file)
+          name = text.match(/#{version_name_key}=(\S*)/m)&.captures&.first
+          code = text.match(/#{version_code_key}=(\S*)/m)&.captures&.first
 
-            f.close
-
-            return nil if name.nil? || code.nil?
-
-            return { VERSION_NAME => name, VERSION_CODE => code.to_i }
-          end
-        end
-
-        # Returns the name of the flavor used for alpha builds
-        #
-        # @env HAS_ALPHA_VERSION Should contain the name of the flavor used for alpha
-        #
-        # @return [String] The flavor name as provided by the env var, defaulting to `zalpha` if the env var
-        #                  is not set or is set to '1' ('boolean' value used in legacy call sites)
-        def self.alpha_flavor_name
-          # TODO: Have each fastlane action which depends on this take the alpha flavor name as ConfigItem/parameter
-          #   explicitly instead (and get rid of the HAS_ALPHA_VERSION global / env var after that)
-
-          # For now we pass the alpha flavor name by reusing the HAS_ALPHA_VERSION env var.
-          return ENV['HAS_ALPHA_VERSION'] if ENV['HAS_ALPHA_VERSION'] && ENV['HAS_ALPHA_VERSION'] != '1'
-
-          'zalpha' # Default value if HAS_ALPHA_VERSION is not set or hasn't been updated at call site to the flavor name instead of '1'
+          return name.nil? || code.nil? ? nil : { VERSION_NAME => name, VERSION_CODE => code.to_i }
         end
 
         # Extract the version name and code from the `version.properties` file in the project root
         #
-        # @param [String] app The name of the app to be used for beta and alpha version update
-        #
         # @return [Hash] A hash with 2 keys `"name"` and `"code"` containing the extracted version name and code, respectively,
         #                or `nil` if `$HAS_ALPHA_VERSION` is not defined.
         #
-        def self.get_alpha_version(app)
-          return get_version_from_properties(product_name: app, is_alpha: true) if properties_file_exists
+        def self.get_alpha_version
+          return get_version_from_properties(is_alpha: true) if File.exist?(version_properties_file)
 
           return nil if ENV['HAS_ALPHA_VERSION'].nil?
 
@@ -312,12 +278,11 @@ module Fastlane
 
         # Prints the current and next release version names to stdout, then returns the next release version
         #
-        # @param [String] app The name of the app to be used for beta and alpha version update
         # @return [String] The next release version name to use after bumping the currently used release version.
         #
-        def self.bump_version_release(app)
+        def self.bump_version_release
           # Bump release
-          current_version = get_release_version(product_name: app)
+          current_version = self.get_release_version
           UI.message("Current version: #{current_version[VERSION_NAME]}")
           new_version = calc_next_release_base_version(current_version)
           UI.message("New version: #{new_version[VERSION_NAME]}")
@@ -328,24 +293,24 @@ module Fastlane
 
         # Update the `version.properties` file with new `versionName` and `versionCode` values
         #
-        # @param [String] app The name of the app to be used for beta and alpha version update
         # @param [Hash] new_version_beta The version hash for the beta, containing values for keys "name" and "code"
         # @param [Hash] new_version_alpha The version hash for the alpha , containing values for keys "name" and "code"
         #
-        def self.update_versions(app, new_version_beta, new_version_alpha)
-          if properties_file_exists
-            new_version_name_beta_key = "#{app}.versionName"
-            new_version_code_beta_key = "#{app}.versionCode"
-            Action.sh('./gradlew', 'updateVersionProperties', "-Pkey=#{new_version_name_beta_key}", "-Pvalue=#{new_version_beta[VERSION_NAME]}")
-            Action.sh('./gradlew', 'updateVersionProperties', "-Pkey=#{new_version_code_beta_key}", "-Pvalue=#{new_version_beta[VERSION_CODE]}")
-
-            unless new_version_alpha.nil?
-              new_version_name_alpha_key = "#{app}.#{alpha_flavor_name}.versionName"
-              new_version_code_alpha_key = "#{app}.#{alpha_flavor_name}.versionCode"
-
-              Action.sh('./gradlew', 'updateVersionProperties', "-Pkey=#{new_version_name_alpha_key}", "-Pvalue=#{new_version_alpha[VERSION_NAME]}") unless new_version_alpha.nil?
-              Action.sh('./gradlew', 'updateVersionProperties', "-Pkey=#{new_version_code_alpha_key}", "-Pvalue=#{new_version_alpha[VERSION_CODE]}") unless new_version_alpha.nil?
+        def self.update_versions(new_version_beta, new_version_alpha)
+          if File.exist?(version_properties_file)
+            replacements = {
+              versionName: (new_version_beta || {})[VERSION_NAME],
+              versionCode: (new_version_beta || {})[VERSION_CODE],
+              'alpha.versionName': (new_version_alpha || {})[VERSION_NAME],
+              'alpha.versionCode': (new_version_alpha || {})[VERSION_CODE]
+            }
+            content = File.read(version_properties_file)
+            content.gsub!(/^(.*) ?=.*$/) do |line|
+              key = Regexp.last_match(1).to_sym
+              value = replacements[key]
+              value.nil? ? line : "#{key}=#{value}"
             end
+            File.write(version_properties_file, content)
           else
             self.update_version(new_version_beta, ENV['HAS_ALPHA_VERSION'].nil? ? 'defaultConfig' : 'vanilla {')
             self.update_version(new_version_alpha, 'defaultConfig') unless new_version_alpha.nil?
@@ -434,7 +399,7 @@ module Fastlane
         #
         # @return [Bool] true if the string is representing an integer value, false if not
         #
-        def self.is_int? string
+        def self.is_int?(string)
           true if Integer(string) rescue false
         end
 

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/filesystem_helper.rb

@@ -36,7 +36,9 @@ module Fastlane
         while continue
           child_filenames = dir.children.map! { |x| File.basename(x) }
 
-          if child_filenames.include? 'fastlane-plugin-wpmreleasetoolkit.gemspec'
+          # The first case is for development – where the `.gemspec` is present in the project root
+          # The second case is for production – where there's no `.gemspec`, but the root dir of the plugin is named `fastlane-plugin-wpmreleasetoolkit-{version}`.
+          if child_filenames.include?('fastlane-plugin-wpmreleasetoolkit.gemspec') || File.basename(dir).start_with?('fastlane-plugin-wpmreleasetoolkit-')
             continue = false
           else
             dir = dir.parent

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/github_helper.rb

@@ -1,23 +1,37 @@
 require 'fastlane_core/ui/ui'
 require 'octokit'
 require 'open-uri'
+require 'securerandom'
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?('UI')
 
   module Helper
     class GithubHelper
+      def self.github_token!
+        token = [
+          'GHHELPER_ACCESS', # For historical reasons / backward compatibility
+          'GITHUB_TOKEN',    # Used by the `gh` CLI tool
+        ].map { |key| ENV[key] }
+                .compact
+                .first
+
+        token || UI.user_error!('Please provide a GitHub authentication token via the `GITHUB_TOKEN` environment variable')
+      end
+
       def self.github_client
-        client = Octokit::Client.new(access_token: ENV['GHHELPER_ACCESS'])
+        @@client ||= begin
+          client = Octokit::Client.new(access_token: github_token!)
 
-        # Fetch the current user
-        user = client.user
-        UI.message("Logged in as: #{user.name}")
+          # Fetch the current user
+          user = client.user
+          UI.message("Logged in as: #{user.name}")
 
-        # Auto-paginate to ensure we're not missing data
-        client.auto_paginate = true
+          # Auto-paginate to ensure we're not missing data
+          client.auto_paginate = true
 
-        client
+          client
+        end
       end
 
       def self.get_milestone(repository, release)
@@ -117,8 +131,11 @@ module Fastlane
         file_name = File.basename(file_path)
         download_path = File.join(download_folder, file_name)
 
+        download_url = github_client.contents(repository,
+                                              path: file_path,
+                                              ref: tag).download_url
         begin
-          uri = URI.parse("https://raw.githubusercontent.com/#{repository}/#{tag}/#{file_path}")
+          uri = URI.parse(download_url)
           uri.open do |remote_file|
             File.write(download_path, remote_file.read)
           end
@@ -128,6 +145,29 @@ module Fastlane
 
         download_path
       end
+
+      # Creates (or updates an existing) GitHub PR Comment
+      def self.comment_on_pr(project_slug:, pr_number:, body:, reuse_identifier: SecureRandom.uuid)
+        client = github_client
+        comments = client.issue_comments(project_slug, pr_number)
+
+        reuse_marker = "<!-- REUSE_ID: #{reuse_identifier} -->"
+
+        existing_comment = comments.find do |comment|
+          # Only match comments posted by the owner of the GitHub Token, and with the given reuse ID
+          comment.user.id == client.user.id and comment.body.include?(reuse_marker)
+        end
+
+        comment_body = reuse_marker + body
+
+        if existing_comment.nil?
+          client.add_comment(project_slug, pr_number, comment_body)
+        else
+          client.update_comment(project_slug, existing_comment.id, comment_body)
+        end
+
+        reuse_identifier
+      end
     end
   end
 end