fastlane-plugin-wpmreleasetoolkit 2.0.0 → 3.0.0

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

@@ -1,205 +1,140 @@
-require 'yaml'
-require 'tmpdir'
+require 'fileutils'
+require 'json'
+require 'nokogiri'
+require 'open3'
+require 'open-uri'
+require 'tempfile'
 
 module Fastlane
   module Helper
     module Ios
       class L10nHelper
-        SWIFTGEN_VERSION = '6.4.0'
-        DEFAULT_BASE_LANG = 'en'
-        CONFIG_FILE_NAME = 'swiftgen-stringtypes.yml'
-
-        attr_reader :install_path, :version
-
-        # @param [String] install_path The path to install SwiftGen to. Usually something like "$PROJECT_DIR/vendor/swiftgen/#{SWIFTGEN_VERSION}".
-        #        It's recommended to provide an absolute path here rather than a relative one, to ensure it's not dependant on where the action is run from.
-        # @param [String] version The version of SwiftGen to use. This will be used both:
-        #        - to check if the current version located in `install_path`, if it already exists, is the expected one
-        #        - to know which version to download if there is not one installed in `install_path` yet
-        #
-        def initialize(install_path:, version: SWIFTGEN_VERSION)
-          @install_path = install_path
-          @version = version || SWIFTGEN_VERSION
-        end
-
-        # Check if SwiftGen is installed in the provided `install_path` and if so if the installed version matches the expected `version`
-        #
-        def check_swiftgen_installed
-          return false unless File.exist?(swiftgen_bin)
-
-          vers_string = `#{swiftgen_bin} --version`
-          # The SwiftGen version string has this format:
-          #
-          # SwiftGen v6.4.0 (Stencil v0.13.1, StencilSwiftKit v2.7.2, SwiftGenKit v6.4.0)
-          return vers_string.include?("SwiftGen v#{version}")
-        rescue
-          return false
-        end
-
-        # Download the ZIP of SwiftGen for the requested `version` and install it in the `install_path`
+        # Returns the type of a `.strings` file (XML, binary or ASCII)
         #
-        # @note This action nukes anything at `install_path` – if something already exists – prior to install SwiftGen there
+        # @param [String] path The path to the `.strings` file to check
+        # @return [Symbol] The file format used by the `.strings` file. Can be one of:
+        #         - `:text` for the ASCII-plist file format (containing typical `"key" = "value";` lines)
+        #         - `:xml` for XML plist file format (can be used if machine-generated, especially since there's no official way/tool to generate the ASCII-plist file format as output)
+        #         - `:binary` for binary plist file format (usually only true for `.strings` files converted by Xcode at compile time and included in the final `.app`/`.ipa`)
+        #         - `nil` if the file does not exist or is neither of those format (e.g. not a `.strings` file at all)
         #
-        def install_swiftgen!
-          UI.message "Installing SwiftGen #{version} into #{install_path}"
-          Dir.mktmpdir do |tmpdir|
-            zipfile = File.join(tmpdir, "swiftgen-#{version}.zip")
-            Action.sh('curl', '--fail', '--location', '-o', zipfile, "https://github.com/SwiftGen/SwiftGen/releases/download/#{version}/swiftgen-#{version}.zip")
-            extracted_dir = File.join(tmpdir, "swiftgen-#{version}")
-            Action.sh('unzip', zipfile, '-d', extracted_dir)
-
-            FileUtils.rm_rf(install_path) if File.exist?(install_path)
-            FileUtils.mkdir_p(install_path)
-            FileUtils.cp_r("#{extracted_dir}/.", install_path)
+        def self.strings_file_type(path:)
+          # Start by checking it seems like a valid property-list file (and not e.g. an image or plain text file)
+          _, status = Open3.capture2('/usr/bin/plutil', '-lint', path)
+          return nil unless status.success?
+
+          # If it is a valid property-list file, determine the actual format used
+          format_desc, status = Open3.capture2('/usr/bin/file', path)
+          return nil unless status.success?
+
+          case format_desc
+          when /Apple binary property list/ then return :binary
+          when /XML/ then return :xml
+          when /text/ then return :text
           end
         end
 
-        # Install SwiftGen if necessary (if not installed yet with the expected version), then run the checks and returns the violations found, if any
+        # Merge the content of multiple `.strings` files into a new `.strings` text file.
         #
-        # @param [String] input_dir The path (ideally absolute) to the directory containing the `.lproj` folders to parse
-        # @param [String] base_lang The code name (i.e the basename of one of the `.lproj` folders) of the locale to use as the baseline
-        # @return [Hash<String, String>] A hash whose keys are the language codes (basename of `.lproj` folders) for which violations were found,
-        #         and the values are the output of the `diff` showing these violations.
+        # @param [Array<String>] paths The paths of the `.strings` files to merge together
+        # @param [String] into The path to the merged `.strings` file to generate as a result.
+        # @return [Array<String>] List of duplicate keys found while validating the merge.
         #
-        def run(input_dir:, base_lang: DEFAULT_BASE_LANG, only_langs: nil)
-          check_swiftgen_installed || install_swiftgen!
-          find_diffs(input_dir: input_dir, base_lang: base_lang, only_langs: only_langs)
-        end
-
-        ##################
-
-        private
-
-        # Path to the swiftgen binary installed at install_path
-        def swiftgen_bin
-          "#{install_path}/bin/swiftgen"
-        end
-
-        # Name to use for the generated files / output files of SwiftGen for each locale. Those files will be generated in the temporary directory to then diff them.
-        def output_filename(lang)
-          "L10nParamsList.#{lang}.txt"
-        end
-
-        # The Stencil template that we want SwiftGen to use to generate the output.
-        # It iterates on every "table" (`.strings` file, in most cases there's only one, `Localizable.strings`),
-        # and for each, iterates on every entry found to print the key and the corresponding types parsed by SwiftGen from the placeholders found in that translation
-        def template_content
-          <<~TEMPLATE
-            {% macro recursiveBlock table item %}
-              {% for string in item.strings %}
-            "{{string.key}}" => [{{string.types|join:","}}]
-              {% endfor %}
-              {% for child in item.children %}
-              {% call recursiveBlock table child %}
-              {% endfor %}
-            {% endmacro %}
-
-            {% for table in tables %}
-            {% call recursiveBlock table.name table.levels %}
-            {% endfor %}
-          TEMPLATE
-        end
-
-        # Create the template file and the config file, in the temp dir, to be used by SwiftGen when parsing the input files.
+        # @note For now, this method only supports merging `.strings` file in `:text` format
+        #       and basically concatenates the files (+ checking for duplicates in the process)
+        # @note The method is able to handle input files which are using different encodings,
+        #       guessing the encoding of each input file using the BOM (and defaulting to UTF8).
+        #       The generated file will always be in utf-8, by convention.
         #
-        # @return [(String, Array<String>)] A tuple of (config_file_absolute_path, Array<langs>)
+        # @raise [RuntimeError] If one of the paths provided is not in text format (but XML or binary instead), or if any of the files are missing.
         #
-        def generate_swiftgen_config!(input_dir, output_dir, only_langs: nil)
-          # Create the template file
-          template_path = File.absolute_path(File.join(output_dir, 'strings-types.stencil'))
-          File.write(template_path, template_content)
-
-          # Dynamically create a SwiftGen config which will cover all supported languages
-          langs = Dir.chdir(input_dir) do
-            Dir.glob('*.lproj/Localizable.strings').map { |loc_file| File.basename(File.dirname(loc_file), '.lproj') }
-          end.sort
-          langs.select! { |lang| only_langs.include?(lang) } unless only_langs.nil?
-
-          config = {
-            'input_dir' => input_dir,
-            'output_dir' => output_dir,
-            'strings' => langs.map do |lang|
-              {
-                'inputs' => ["#{lang}.lproj/Localizable.strings"],
-                # Choose an unlikely separator (instead of the default '.') to avoid creating needlessly complex Stencil Context nested
-                # structure just because we have '.' in the English sentences we use (instead of structured reverse-dns notation) for the keys
-                'options' => { 'separator' => '____' },
-                'outputs' => [{
-                  'templatePath' => template_path,
-                  'output' => output_filename(lang)
-                }]
-              }
+        def self.merge_strings(paths:, output_path: nil)
+          duplicates = []
+          Tempfile.create('wpmrt-l10n-merge-', encoding: 'utf-8') do |tmp_file|
+            all_keys_found = []
+
+            tmp_file.write("/* Generated File. Do not edit. */\n\n")
+            paths.each do |input_file|
+              fmt = strings_file_type(path: input_file)
+              raise "The file `#{input_file}` does not exist or is of unknown format." if fmt.nil?
+              raise "The file `#{input_file}` is in #{fmt} format but we currently only support merging `.strings` files in text format." unless fmt == :text
+
+              string_keys = read_strings_file_as_hash(path: input_file).keys
+              duplicates += (string_keys & all_keys_found) # Find duplicates using Array intersection, and add those to duplicates list
+              all_keys_found += string_keys
+
+              tmp_file.write("/* MARK: - #{File.basename(input_file)} */\n\n")
+              # Read line-by-line to reduce memory footprint during content copy; Be sure to guess file encoding using the Byte-Order-Mark.
+              File.readlines(input_file, mode: 'rb:BOM|UTF-8').each { |line| tmp_file.write(line) }
+              tmp_file.write("\n")
             end
-          }
-
-          # Write SwiftGen config file
-          config_file = File.join(output_dir, CONFIG_FILE_NAME)
-          File.write(config_file, config.to_yaml)
-
-          return [config_file, langs]
+            tmp_file.close # ensure we flush the content to disk
+            FileUtils.cp(tmp_file.path, output_path)
+          end
+          duplicates
         end
 
-        # Because we use English copy verbatim as key names, some keys are the same except for the upper/lowercase.
-        # We need to sort the output again because SwiftGen only sort case-insensitively so that means keys that are
-        # the same except case might be in swapped order for different outputs
+        # Return the list of translations in a `.strings` file.
         #
-        # @param [String] dir The temporary directory in which the file to sort lines for is located
-        # @param [String] lang The code for the locale we need to sort the output lines for
+        # @param [String] path The path to the `.strings` file to read
+        # @return [Hash<String,String>] A dictionary of key=>translation translations.
+        # @raise [RuntimeError] If the file is not a valid strings file or there was an error in parsing its content.
         #
-        def sort_file_lines!(dir, lang)
-          file = File.join(dir, output_filename(lang))
-          return nil unless File.exist?(file)
+        def self.read_strings_file_as_hash(path:)
+          output, status = Open3.capture2e('/usr/bin/plutil', '-convert', 'json', '-o', '-', path)
+          raise output unless status.success?
 
-          sorted_lines = File.readlines(file).sort
-          File.write(file, sorted_lines.join)
-          return file
+          JSON.parse(output)
         end
 
-        # Prepares the template and config files, then run SwiftGen, run `diff` on each generated output against the baseline, and returns a Hash of the violations found.
+        # Generate a `.strings` file from a dictionary of string translations.
         #
-        # @param [String] input_dir The directory where the `.lproj` folders to scan are located
-        # @param [String] base_lang The base language used as source of truth that all other languages will be compared against
-        # @param [Array<String>] only_langs The list of languages to limit the generation for. Useful to focus only on a couple of issues or just one language
-        # @return [Hash<String, String>] A hash of violations, keyed by language code, whose values are the diff output.
+        # Especially useful to generate `.strings` files not from code, but from keys extracted from another source
+        # (like a JSON file export from GlotPress, or subset of keys extracted from the main `Localizable.strings` to generate an `InfoPlist.strings`)
         #
-        # @note The returned Hash contains keys only for locales with violations. Locales parsed but without any violations found will not appear in the resulting hash.
+        # @note The generated file will be in XML-plist format
+        #       since ASCII plist is deprecated as an output format by every Apple tool so there's no **safe** way to generate ASCII format.
         #
-        def find_diffs(input_dir:, base_lang:, only_langs: nil)
-          Dir.mktmpdir('a8c-lint-translations-') do |tmpdir|
-            # Run SwiftGen
-            langs = only_langs.nil? ? nil : (only_langs + [base_lang]).uniq
-            (config_file, langs) = generate_swiftgen_config!(input_dir, tmpdir, only_langs: langs)
-            Action.sh(swiftgen_bin, 'config', 'run', '--config', config_file)
-
-            # Run diffs
-            base_file = sort_file_lines!(tmpdir, base_lang)
-            langs.delete(base_lang)
-            return langs.map do |lang|
-              file = sort_file_lines!(tmpdir, lang)
-              # If the lang ends up not having any translation at all (e.g. a `.lproj` without any `.strings` file in it but maybe just a storyboard or assets catalog), ignore it
-              next nil if file.nil? || only_empty_lines?(file)
-
-              # Compute the diff
-              diff = `diff -U0 "#{base_file}" "#{file}"`
-              # Remove the lines starting with `---`/`+++` which contains the file names (which are temp files we don't want to expose in the final diff to users)
-              # Note: We still keep the `@@ from-file-line-numbers to-file-line-numbers @@` lines to help the user know the index of the key to find it faster,
-              #       and also to serve as a clear visual separator between diff entries in the output.
-              #       Those numbers won't be matching the original `.strings` file line numbers because they are line numbers in the SwiftGen-generated intermediate
-              #       file instead, but they can still give an indication at the index in the list of keys at which this difference is located.
-              diff.gsub!(/^(---|\+\+\+).*\n/, '')
-              diff.empty? ? nil : [lang, diff]
-            end.compact.to_h
+        # @param [Hash<String,String>] translations The dictionary of key=>translation translations to put in the generated `.strings` file
+        # @param [String] output_path The path to the `.strings` file to generate
+        #
+        def self.generate_strings_file_from_hash(translations:, output_path:)
+          builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+            xml.doc.create_internal_subset(
+              'plist',
+              '-//Apple//DTD PLIST 1.0//EN',
+              'http://www.apple.com/DTDs/PropertyList-1.0.dtd'
+            )
+            xml.comment('Warning: Auto-generated file, do not edit.')
+            xml.plist(version: '1.0') do
+              xml.dict do
+                translations.each do |k, v|
+                  xml.key(k.to_s)
+                  xml.string(v.to_s)
+                end
+              end
+            end
           end
+          File.write(output_path, builder.to_xml)
         end
 
-        # Returns true if the file only contains empty lines, i.e. lines that only contains whitespace (space, tab, CR, LF)
-        def only_empty_lines?(file)
-          File.open(file) do |f|
-            while (line = f.gets)
-              return false unless line.strip.empty?
-            end
+        # Downloads the export from GlotPress for a given locale and given filters.
+        #
+        # @param [String] project_url The URL to the GlotPress project to export from, e.g. `"https://translate.wordpress.org/projects/apps/ios/dev"`
+        # @param [String] locale The GlotPress locale code to download strings for.
+        # @param [Hash{Symbol=>String}] filters The hash of filters to apply when exporting from GlotPress.
+        #                               Typical examples include `{ status: 'current' }` or `{ status: 'review' }`.
+        # @param [String, IO] destination The path or `IO`-like instance, where to write the downloaded file on disk.
+        #
+        def self.download_glotpress_export_file(project_url:, locale:, filters:, destination:)
+          query_params = (filters || {}).transform_keys { |k| "filters[#{k}]" }.merge(format: 'strings')
+          uri = URI.parse("#{project_url.chomp('/')}/#{locale}/default/export-translations?#{URI.encode_www_form(query_params)}")
+          begin
+            IO.copy_stream(uri.open, destination)
+          rescue StandardError => e
+            UI.error "Error downloading locale `#{locale}` — #{e.message}"
+            return nil
           end
-          return true
         end
       end
     end

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

@@ -0,0 +1,207 @@
+require 'yaml'
+require 'tmpdir'
+
+module Fastlane
+  module Helper
+    module Ios
+      class L10nLinterHelper
+        SWIFTGEN_VERSION = '6.4.0'
+        DEFAULT_BASE_LANG = 'en'
+        CONFIG_FILE_NAME = 'swiftgen-stringtypes.yml'
+
+        attr_reader :install_path, :version
+
+        # @param [String] install_path The path to install SwiftGen to. Usually something like "$PROJECT_DIR/vendor/swiftgen/#{SWIFTGEN_VERSION}".
+        #        It's recommended to provide an absolute path here rather than a relative one, to ensure it's not dependant on where the action is run from.
+        # @param [String] version The version of SwiftGen to use. This will be used both:
+        #        - to check if the current version located in `install_path`, if it already exists, is the expected one
+        #        - to know which version to download if there is not one installed in `install_path` yet
+        #
+        def initialize(install_path:, version: SWIFTGEN_VERSION)
+          @install_path = install_path
+          @version = version || SWIFTGEN_VERSION
+        end
+
+        # Check if SwiftGen is installed in the provided `install_path` and if so if the installed version matches the expected `version`
+        #
+        def check_swiftgen_installed
+          return false unless File.exist?(swiftgen_bin)
+
+          vers_string = `#{swiftgen_bin} --version`
+          # The SwiftGen version string has this format:
+          #
+          # SwiftGen v6.4.0 (Stencil v0.13.1, StencilSwiftKit v2.7.2, SwiftGenKit v6.4.0)
+          return vers_string.include?("SwiftGen v#{version}")
+        rescue
+          return false
+        end
+
+        # Download the ZIP of SwiftGen for the requested `version` and install it in the `install_path`
+        #
+        # @note This action nukes anything at `install_path` – if something already exists – prior to install SwiftGen there
+        #
+        def install_swiftgen!
+          UI.message "Installing SwiftGen #{version} into #{install_path}"
+          Dir.mktmpdir do |tmpdir|
+            zipfile = File.join(tmpdir, "swiftgen-#{version}.zip")
+            Action.sh('curl', '--fail', '--location', '-o', zipfile, "https://github.com/SwiftGen/SwiftGen/releases/download/#{version}/swiftgen-#{version}.zip")
+            extracted_dir = File.join(tmpdir, "swiftgen-#{version}")
+            Action.sh('unzip', zipfile, '-d', extracted_dir)
+
+            FileUtils.rm_rf(install_path) if File.exist?(install_path)
+            FileUtils.mkdir_p(install_path)
+            FileUtils.cp_r("#{extracted_dir}/.", install_path)
+          end
+        end
+
+        # Install SwiftGen if necessary (if not installed yet with the expected version), then run the checks and returns the violations found, if any
+        #
+        # @param [String] input_dir The path (ideally absolute) to the directory containing the `.lproj` folders to parse
+        # @param [String] base_lang The code name (i.e the basename of one of the `.lproj` folders) of the locale to use as the baseline
+        # @return [Hash<String, String>] A hash whose keys are the language codes (basename of `.lproj` folders) for which violations were found,
+        #         and the values are the output of the `diff` showing these violations.
+        #
+        def run(input_dir:, base_lang: DEFAULT_BASE_LANG, only_langs: nil)
+          check_swiftgen_installed || install_swiftgen!
+          find_diffs(input_dir: input_dir, base_lang: base_lang, only_langs: only_langs)
+        end
+
+        ##################
+
+        private
+
+        # Path to the swiftgen binary installed at install_path
+        def swiftgen_bin
+          "#{install_path}/bin/swiftgen"
+        end
+
+        # Name to use for the generated files / output files of SwiftGen for each locale. Those files will be generated in the temporary directory to then diff them.
+        def output_filename(lang)
+          "L10nParamsList.#{lang}.txt"
+        end
+
+        # The Stencil template that we want SwiftGen to use to generate the output.
+        # It iterates on every "table" (`.strings` file, in most cases there's only one, `Localizable.strings`),
+        # and for each, iterates on every entry found to print the key and the corresponding types parsed by SwiftGen from the placeholders found in that translation
+        def template_content
+          <<~TEMPLATE
+            {% macro recursiveBlock table item %}
+              {% for string in item.strings %}
+            "{{string.key}}" => [{{string.types|join:","}}]
+              {% endfor %}
+              {% for child in item.children %}
+              {% call recursiveBlock table child %}
+              {% endfor %}
+            {% endmacro %}
+
+            {% for table in tables %}
+            {% call recursiveBlock table.name table.levels %}
+            {% endfor %}
+          TEMPLATE
+        end
+
+        # Create the template file and the config file, in the temp dir, to be used by SwiftGen when parsing the input files.
+        #
+        # @return [(String, Array<String>)] A tuple of (config_file_absolute_path, Array<langs>)
+        #
+        def generate_swiftgen_config!(input_dir, output_dir, only_langs: nil)
+          # Create the template file
+          template_path = File.absolute_path(File.join(output_dir, 'strings-types.stencil'))
+          File.write(template_path, template_content)
+
+          # Dynamically create a SwiftGen config which will cover all supported languages
+          langs = Dir.chdir(input_dir) do
+            Dir.glob('*.lproj/Localizable.strings').map { |loc_file| File.basename(File.dirname(loc_file), '.lproj') }
+          end.sort
+          langs.select! { |lang| only_langs.include?(lang) } unless only_langs.nil?
+
+          config = {
+            'input_dir' => input_dir,
+            'output_dir' => output_dir,
+            'strings' => langs.map do |lang|
+              {
+                'inputs' => ["#{lang}.lproj/Localizable.strings"],
+                # Choose an unlikely separator (instead of the default '.') to avoid creating needlessly complex Stencil Context nested
+                # structure just because we have '.' in the English sentences we use (instead of structured reverse-dns notation) for the keys
+                'options' => { 'separator' => '____' },
+                'outputs' => [{
+                  'templatePath' => template_path,
+                  'output' => output_filename(lang)
+                }]
+              }
+            end
+          }
+
+          # Write SwiftGen config file
+          config_file = File.join(output_dir, CONFIG_FILE_NAME)
+          File.write(config_file, config.to_yaml)
+
+          return [config_file, langs]
+        end
+
+        # Because we use English copy verbatim as key names, some keys are the same except for the upper/lowercase.
+        # We need to sort the output again because SwiftGen only sort case-insensitively so that means keys that are
+        # the same except case might be in swapped order for different outputs
+        #
+        # @param [String] dir The temporary directory in which the file to sort lines for is located
+        # @param [String] lang The code for the locale we need to sort the output lines for
+        #
+        def sort_file_lines!(dir, lang)
+          file = File.join(dir, output_filename(lang))
+          return nil unless File.exist?(file)
+
+          sorted_lines = File.readlines(file).sort
+          File.write(file, sorted_lines.join)
+          return file
+        end
+
+        # Prepares the template and config files, then run SwiftGen, run `diff` on each generated output against the baseline, and returns a Hash of the violations found.
+        #
+        # @param [String] input_dir The directory where the `.lproj` folders to scan are located
+        # @param [String] base_lang The base language used as source of truth that all other languages will be compared against
+        # @param [Array<String>] only_langs The list of languages to limit the generation for. Useful to focus only on a couple of issues or just one language
+        # @return [Hash<String, String>] A hash of violations, keyed by language code, whose values are the diff output.
+        #
+        # @note The returned Hash contains keys only for locales with violations. Locales parsed but without any violations found will not appear in the resulting hash.
+        #
+        def find_diffs(input_dir:, base_lang:, only_langs: nil)
+          Dir.mktmpdir('a8c-lint-translations-') do |tmpdir|
+            # Run SwiftGen
+            langs = only_langs.nil? ? nil : (only_langs + [base_lang]).uniq
+            (config_file, langs) = generate_swiftgen_config!(input_dir, tmpdir, only_langs: langs)
+            Action.sh(swiftgen_bin, 'config', 'run', '--config', config_file)
+
+            # Run diffs
+            base_file = sort_file_lines!(tmpdir, base_lang)
+            langs.delete(base_lang)
+            return langs.map do |lang|
+              file = sort_file_lines!(tmpdir, lang)
+              # If the lang ends up not having any translation at all (e.g. a `.lproj` without any `.strings` file in it but maybe just a storyboard or assets catalog), ignore it
+              next nil if file.nil? || only_empty_lines?(file)
+
+              # Compute the diff
+              diff = `diff -U0 "#{base_file}" "#{file}"`
+              # Remove the lines starting with `---`/`+++` which contains the file names (which are temp files we don't want to expose in the final diff to users)
+              # Note: We still keep the `@@ from-file-line-numbers to-file-line-numbers @@` lines to help the user know the index of the key to find it faster,
+              #       and also to serve as a clear visual separator between diff entries in the output.
+              #       Those numbers won't be matching the original `.strings` file line numbers because they are line numbers in the SwiftGen-generated intermediate
+              #       file instead, but they can still give an indication at the index in the list of keys at which this difference is located.
+              diff.gsub!(/^(---|\+\+\+).*\n/, '')
+              diff.empty? ? nil : [lang, diff]
+            end.compact.to_h
+          end
+        end
+
+        # Returns true if the file only contains empty lines, i.e. lines that only contains whitespace (space, tab, CR, LF)
+        def only_empty_lines?(file)
+          File.open(file) do |f|
+            while (line = f.gets)
+              return false unless line.strip.empty?
+            end
+          end
+          return true
+        end
+      end
+    end
+  end
+end

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

@@ -28,6 +28,8 @@ module Fastlane
           message << 'Aborting.'
           UI.user_error!(message)
         end
+
+        UI.user_error!('`drawText` not found – install it using `brew install automattic/build-tools/drawText`.') unless system('command -v drawText')
       end
 
       def read_json(configFilePath)
@@ -233,9 +235,7 @@ module Fastlane
         begin
           tempTextFile = Tempfile.new()
 
-          command = "bundle exec drawText html=\"#{text}\" maxWidth=#{width} maxHeight=#{height} output=#{tempTextFile.path} fontSize=#{font_size} stylesheet=\"#{stylesheet_path}\" alignment=\"#{position}\""
-
-          UI.crash!('Unable to draw text') unless system(command)
+          sh('drawText', "html=\"#{text}\"", "maxWidth=#{width}", "maxHeight=#{height}", "output=\"#{tempTextFile.path}\"", "fontSize=#{font_size}", "stylesheet=\"#{stylesheet_path}\"", "alignment=\"#{position}\"")
 
           text_content = open_image(tempTextFile.path).trim
           text_frame = create_image(width, height)

data/lib/fastlane/plugin/wpmreleasetoolkit/models/file_reference.rb

@@ -10,10 +10,7 @@ module Fastlane
       end
 
       def source_contents
-        # TODO: This works only on CircleCI. I chose this variable because it's the one checked by Fastlane::is_ci.
-        # Fastlane::is_ci doesn't work here, so reimplementing the code has been necessary.
-        # (This should be updated if we change CI or if fastlane is updated.)
-        return File.read(secrets_repository_file_path) unless self.encrypt || ENV.key?('CIRCLECI')
+        return File.read(secrets_repository_file_path) unless self.encrypt || FastlaneCore::Helper.is_ci?
         return nil unless File.file?(encrypted_file_path)
 
         encrypted = File.read(encrypted_file_path)

data/lib/fastlane/plugin/wpmreleasetoolkit/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Wpmreleasetoolkit
-    VERSION = '2.0.0'
+    VERSION = '3.0.0'
   end
 end