fastlane-plugin-wpmreleasetoolkit 2.0.0 → 3.0.0

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_lint_localizations.rb

@@ -17,8 +17,8 @@ module Fastlane
       def self.run_linter(params)
         UI.message 'Linting localizations for parameter placeholders consistency...'
 
-        require_relative '../../helper/ios/ios_l10n_helper'
-        helper = Fastlane::Helper::Ios::L10nHelper.new(
+        require_relative '../../helper/ios/ios_l10n_linter_helper'
+        helper = Fastlane::Helper::Ios::L10nLinterHelper.new(
           install_path: resolve_path(params[:install_path]),
           version: params[:version]
         )
@@ -92,7 +92,7 @@ module Fastlane
             description: 'The path where to install the SwiftGen tooling needed to run the linting process. If a relative path, should be relative to your repo_root',
             type: String,
             optional: true,
-            default_value: "vendor/swiftgen/#{Fastlane::Helper::Ios::L10nHelper::SWIFTGEN_VERSION}"
+            default_value: "vendor/swiftgen/#{Fastlane::Helper::Ios::L10nLinterHelper::SWIFTGEN_VERSION}"
           ),
           FastlaneCore::ConfigItem.new(
             key: :version,
@@ -100,7 +100,7 @@ module Fastlane
             description: 'The version of SwiftGen to install and use for linting',
             type: String,
             optional: true,
-            default_value: Fastlane::Helper::Ios::L10nHelper::SWIFTGEN_VERSION
+            default_value: Fastlane::Helper::Ios::L10nLinterHelper::SWIFTGEN_VERSION
           ),
           FastlaneCore::ConfigItem.new(
             key: :input_dir,
@@ -115,7 +115,7 @@ module Fastlane
             description: 'The language that should be used as the base language that every other language will be compared against',
             type: String,
             optional: true,
-            default_value: Fastlane::Helper::Ios::L10nHelper::DEFAULT_BASE_LANG
+            default_value: Fastlane::Helper::Ios::L10nLinterHelper::DEFAULT_BASE_LANG
           ),
           FastlaneCore::ConfigItem.new(
             key: :only_langs,

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

@@ -16,20 +16,19 @@ module Fastlane
       #####################################################
 
       def self.description
-        'Gathers the string to localise'
+        'Gathers the strings to localise. Deprecated'
       end
 
       def self.details
-        'Gathers the string to localise'
+        'Gathers the strings to localise. Deprecated in favor of the new `ios_generate_strings_file_from_code`'
       end
 
-      def self.available_options
+      def self.category
+        :deprecated
       end
 
-      def self.output
-      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/actions/ios/ios_merge_strings_files.rb

@@ -0,0 +1,75 @@
+module Fastlane
+  module Actions
+    class IosMergeStringsFilesAction < Action
+      def self.run(params)
+        UI.message "Merging strings files: #{params[:paths].inspect}"
+
+        duplicates = Fastlane::Helper::Ios::L10nHelper.merge_strings(paths: params[:paths], output_path: params[:destination])
+        duplicates.each do |dup_key|
+          UI.important "Duplicate key found while merging the `.strings` files: `#{dup_key}`"
+        end
+        duplicates
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Merge multiple `.strings` files into one'
+      end
+
+      def self.details
+        <<~DETAILS
+          Merge multiple `.strings` files into one.
+
+          Especially useful to prepare a single `.strings` file merging strings from both `Localizable.strings` from
+          the app code — typically previously extracted from `ios_generate_strings_file_from_code` —
+          and string files like `InfoPlist.strings` — which values may not be generated from the codebase but
+          manually maintained by developers.
+
+          The action only supports merging files which are in the OpenStep (`"key" = "value";`) text format (which is
+          the most common format for `.strings` files, and the one generated by `genstrings`), but can handle the case
+          of different files using different encodings (UTF8 vs UTF16) and is able to detect and report duplicates.
+          It does not handle `.strings` files in XML or binary-plist formats (which are valid but more rare)
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :paths,
+            env_name: 'FL_IOS_MERGE_STRINGS_FILES_PATHS',
+            description: 'The paths of all the `.strings` files to merge together',
+            type: Array,
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :destination,
+            env_name: 'FL_IOS_MERGE_STRINGS_FILES_DESTINATION',
+            description: 'The path of the merged `.strings` file to generate. If nil, the merge will happen in-place in the first file in the `paths:` list',
+            type: String,
+            optional: true,
+            default_value: nil
+          ),
+        ]
+      end
+
+      def self.return_type
+        :array_of_strings
+      end
+
+      def self.return_value
+        'The list of duplicate keys found while merging the various `.strings` files'
+      end
+
+      def self.authors
+        ['automattic']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+    end
+  end
+end

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

@@ -27,26 +27,6 @@ module Fastlane
             )
           end
         end
-
-        # Calls the `tools/update-translations.sh` script from the project repo, then lint them using the provided gradle task
-        #
-        # Deprecated. Use the `android_download_translations` action instead.
-        #
-        # @env PROJECT_ROOT_FOLDER The path to the git root of the project
-        # @env PROJECT_NAME The name of the directory containing the project code (especially containing the `build.gradle` file)
-        #
-        # @param [String] validate_translation_command The name of the gradle task to run to validate the translations
-        #
-        # @todo Remove this once every client has migrated to `android_download_translations` and we got rid of that legacy action.
-        #
-        def self.update_metadata(validate_translation_command)
-          Action.sh('./tools/update-translations.sh')
-          Action.sh('git', 'submodule', 'update', '--init', '--recursive')
-          Action.sh('./gradlew', validate_translation_command)
-
-          res_dir = File.join(ENV['PROJECT_ROOT_FOLDER'], ENV['PROJECT_NAME'], 'src', 'main', 'res')
-          Fastlane::Helper::GitHelper.commit(message: 'Update translations', files: res_dir, push: true)
-        end
       end
     end
   end

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

@@ -92,6 +92,14 @@ module Fastlane
           UI.user_error!("String #{string_name} [#{string_content}] was found in library #{library[:library]} but not in the main file.")
         end
 
+        # Merge strings from a library into the strings.xml of the main app
+        #
+        # @param [String] main Path to the main strings.xml file (something like `…/res/values/strings.xml`)
+        # @param [Hash] library Hash describing the library to merge. The Hash should contain the following keys:
+        #                       - `:library`: The human readable name of the library, used to display in console messages
+        #                       - `:strings_path`: The path to the strings.xml file of the library to merge into the main one
+        #                       - `:exclusions`: An array of strings keys to exclude during merge. Any of those keys from the library's `strings.xml` will be skipped and won't be merged into the main one.
+        # @return [Boolean] True if at least one string from the library has been added to (or has updated) the main strings file.
         def self.merge_lib(main, library)
           UI.message("Merging #{library[:library]} strings into #{main}")
           main_strings = File.open(main) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }

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

@@ -5,6 +5,9 @@ module Fastlane
     # Helper methods to execute git-related operations
     #
     module GitHelper
+      # Fallback default branch of the client repository.
+      DEFAULT_GIT_BRANCH = 'trunk'.freeze
+
       # Checks if the given path, or current directory if no path is given, is
       # inside a Git repository
       #

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

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

@@ -0,0 +1,93 @@
+require 'fastlane_core'
+
+# The features in this file are controlled by the following ENV vars:
+#
+# @env `FASTLANE_PROMPT_REMINDER_DISABLE_AUTO_PATCH`
+#     If this variable is set, it will disable the auto-application of the monkey patch. In such case,
+#     `UI.input`, `UI.confirm`, `UI.select` and `UI.password` methods won't be automatically patched
+#     unless you explicitly call `monkey_patch_interactive_prompts_with_reminder` yourself.
+#
+# @env `FASTLANE_PROMPT_REMINDER_MESSAGE`
+#     - If not set, then while auto-patching the `UI.…` methods, it will NOT make the patched methods
+#       speak any vocal message – and instead will only emit a beep and make your Terminal icon jump in the Dock.
+#     - If set to `default`, `true`, `yes` or `1`, then while auto-patching the `UI.…` methods, it will
+#       make the patched methods announce the default message.
+#     - If set to any other string, it will make the patched methods use that string as the message to announce
+#       during the reminders
+#     - NOTE: This env var only has an effect if the other `FASTLANE_PROMPT_REMINDER_DISABLE_AUTO_PATCH` env var
+#       is _not_ set (and thus the `UI.…` methods _are_ auto-patched), because it only affects how auto-patching is done.
+#
+# @env `FASTLANE_PROMPT_REMINDER_DELAYS`
+#     The delays (in seconds) to use when monkey-patching the `UI.…` methods to wrap them around `with_reminder`,
+#     separated by a comma (e.g. `60,300,900`). If unset, will use the default delays of `30,180,600`.
+
+module FastlaneCore
+  # NOTE: FastlaneCore::UI delegates to the FastlaneCore::Shell implementation when output is the terminal
+  class Shell
+    DEFAULT_PROMPT_REMINDER_MESSAGE = 'An interactive prompt is waiting for you in the Terminal!'.freeze
+    DEFAULT_PROMPT_REMINDER_DELAYS = [30, 180, 600].freeze
+
+    # Calls the block given and remind the user with a vocal message if the block does not return after specific delays.
+    #
+    # Especially useful when using a block which calls methods that are interactive, in order to remind the user
+    # to answer the interactive prompt if they forgot about it after some delays.
+    #
+    # Example usage:
+    #
+    #       text = with_reminder do
+    #         puts "Enter some text:"
+    #         $stdout.getch
+    #       end
+    #
+    # @param [Double,Array<Double>] after
+    #        Delay or list of delays to wait for before pronouncing the reminder message.
+    #        If an array of values is passed, the message will be pronounced multiple times, after having waited for the subsequent delays in turn.
+    #        Defaults to reminding after 30s, then 3mn, then 10mn.
+    # @param [String] message
+    #        The message to pronounce out loud after the delay has passed, if the block hasn't returned beforehand.
+    # @return The same value that the blocks might return
+    #
+    def self.with_reminder(after: DEFAULT_PROMPT_REMINDER_DELAYS, message: DEFAULT_PROMPT_REMINDER_MESSAGE)
+      delays_list = Array(after.dup)
+      thread = Thread.new do
+        until delays_list.empty?
+          sleep(delays_list.shift)
+          $stdout.beep
+          system('say', message) unless message.nil?
+        end
+      end
+      # execute the interactive code
+      res = yield
+      # if we replied before the timeout, kill the thread so message won't be triggered
+      thread.kill
+      # If the block given returned a value, pass it
+      return res
+    end
+
+    # Monkey-Patch fastlane's `UI.input`, `UI.confirm`, `UI.select` and `UI.password` interactive methods
+    # (which delegate to `FastlaneCore::Shell` when output is the terminal)
+    #
+    # Once you call this method, any invocation of `UI.input`, `UI.confirm`, `UI.select` or `UI.password`
+    # anywhere in Fastlane (by your Fastfile, an action, …) will be wrapped in a call to with_reminder automatically.
+    #
+    def self.monkey_patch_interactive_prompts_with_reminder(after: DEFAULT_PROMPT_REMINDER_DELAYS, message: DEFAULT_PROMPT_REMINDER_MESSAGE)
+      %i[input confirm select password].each do |method_name|
+        old_method = instance_method(method_name)
+
+        define_method(method_name) do |*args|
+          FastlaneCore::Shell.with_reminder(after: after, message: message) { old_method.bind(self).call(*args) }
+        end
+      end
+    end
+  end
+end
+
+# Apply Monkey patch
+unless ENV['FASTLANE_PROMPT_REMINDER_DISABLE_AUTO_PATCH']
+  message = ENV['FASTLANE_PROMPT_REMINDER_MESSAGE']
+  message = FastlaneCore::Shell::DEFAULT_PROMPT_REMINDER_MESSAGE if %w[default true yes 1].include?(message&.downcase)
+  delays = ENV['FASTLANE_PROMPT_REMINDER_DELAYS']&.split(',')&.map(&:to_i) || FastlaneCore::Shell::DEFAULT_PROMPT_REMINDER_DELAYS
+
+  FastlaneCore::UI.verbose("Monkey-patching the UI interactive methods to add a reminder (#{delays.inspect}, #{message.inspect})")
+  FastlaneCore::Shell.monkey_patch_interactive_prompts_with_reminder(after: delays, message: message)
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_git_helper.rb

@@ -35,8 +35,9 @@ module Fastlane
         # @env PROJECT_ROOT_FOLDER The path to the git root of the project
         # @env PROJECT_NAME The name of the directory containing the project code (especially containing the `build.gradle` file)
         #
-        # @todo Migrate the scripts, currently in each host repo and called by this method, to be helpers and actions
-        #       in the release-toolkit instead, and move this code away from `ios_git_helper`.
+        # @deprecated This method is only used by the `ios_localize_project` action, which is itself deprecated
+        #             in favor of the new `ios_generate_strings_file_from_code` action
+        # @todo [Next Major] Remove this method once we fully remove `ios_localize_project`
         #
         def self.localize_project
           Action.sh("cd #{get_from_env!(key: 'PROJECT_ROOT_FOLDER')} && ./Scripts/localize.py")