fastlane-plugin-wpmreleasetoolkit 1.0.0

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

@@ -0,0 +1,208 @@
+require 'yaml'
+require 'tmpdir'
+
+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
+        attr_reader :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 Hash[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]
+          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/ios/ios_version_helper.rb

@@ -0,0 +1,348 @@
+module Fastlane
+  module Helper
+    module Ios
+      # A module containing helper methods to manipulate/extract/bump iOS version strings in xcconfig files
+      #
+      module VersionHelper
+        # The index for the major version number part
+        MAJOR_NUMBER = 0
+        # The index for the minor version number part
+        MINOR_NUMBER = 1
+        # The index for the hotfix version number part
+        HOTFIX_NUMBER = 2
+        # The index for the build version number part
+        BUILD_NUMBER = 3
+
+        # Returns the public-facing version string.
+        #
+        # @return [String] The public-facing version number, extracted from the VERSION_LONG entry of the xcconfig 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
+          version = get_build_version
+          vp = get_version_parts(version)
+          return "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}" unless is_hotfix?(version)
+
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}"
+        end
+
+        # Compute the name of the next release version.
+        #
+        # @param [String] version The current version that we want to increment
+        #
+        # @return [String] The predicted next version, in the form of "X.Y".
+        #         Corresponds to incrementing the minor part, except if it reached 10
+        #         (in that case we go to the next major version, as decided in our versioning conventions)
+        #
+        def self.calc_next_release_version(version)
+          vp = get_version_parts(version)
+          vp[MINOR_NUMBER] += 1
+          if vp[MINOR_NUMBER] == 10
+            vp[MAJOR_NUMBER] += 1
+            vp[MINOR_NUMBER] = 0
+          end
+
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}"
+        end
+
+        # Return the short version string "X.Y" from the full version.
+        #
+        # @param [String] version The version to convert to a short version
+        #
+        # @return [String] A version string consisting of only the first 2 parts "X.Y"
+        #
+        def self.get_short_version_string(version)
+          vp = get_version_parts(version)
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}"
+        end
+
+        # Compute the name of the previous release version.
+        #
+        # @param [String] version The current version we want to decrement
+        #
+        # @return [String] The predicted previous version, in the form of "X.Y".
+        #         Corresponds to decrementing the minor part, or decrement the major and set minor to 9 if minor was 0.
+        #
+        def self.calc_prev_release_version(version)
+          vp = get_version_parts(version)
+          if vp[MINOR_NUMBER] == 0
+            vp[MAJOR_NUMBER] -= 1
+            vp[MINOR_NUMBER] = 9
+          else
+            vp[MINOR_NUMBER] -= 1
+          end
+
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}"
+        end
+
+        # Compute the name of the next build version.
+        #
+        # @param [String] version The current version we want to increment
+        #
+        # @return [String] The predicted next build version, in the form of "X.Y.Z.N".
+        #         Corresponds to incrementing the last (4th) component N of the version.
+        #
+        def self.calc_next_build_version(version)
+          vp = get_version_parts(version)
+          vp[BUILD_NUMBER] += 1
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}.#{vp[BUILD_NUMBER]}"
+        end
+
+        # Compute the name of the next hotfix version.
+        #
+        # @param [String] version The current version we want to increment
+        #
+        # @return [String] The predicted next hotfix version, in the form of "X.Y.Z".
+        #         Corresponds to incrementing the 3rd component of the version.
+        #
+        def self.calc_next_hotfix_version(version)
+          vp = get_version_parts(version)
+          vp[HOTFIX_NUMBER] += 1
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}"
+        end
+
+        # Compute the name of the previous build version.
+        #
+        # @param [String] version The current version we want to decrement
+        #
+        # @return [String] The predicted previous build version, in the form of "X.Y.Z.N".
+        #         Corresponds to decrementing the last (4th) component N of the version.
+        #
+        def self.calc_prev_build_version(version)
+          vp = get_version_parts(version)
+          vp[BUILD_NUMBER] -= 1 unless vp[BUILD_NUMBER] == 0
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}.#{vp[BUILD_NUMBER]}"
+        end
+
+        # Compute the name of the previous hotfix version.
+        #
+        # @param [String] version The current version we want to decrement
+        #
+        # @return [String] The predicted previous hotfix version, in the form of "X.Y.Z", or "X.Y" if Z is 0.
+        #         Corresponds to decrementing the 3rd component Z of the version, striping it if it ends up being zero.
+        #
+        def self.calc_prev_hotfix_version(version)
+          vp = get_version_parts(version)
+          vp[HOTFIX_NUMBER] -= 1 unless vp[HOTFIX_NUMBER] == 0
+          return "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}" unless vp[HOTFIX_NUMBER] == 0
+
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}"
+        end
+
+        # Create an internal version number, for which the build number is based on today's date.
+        #
+        # @param [String] version The current version to create an internal version name for.
+        #
+        # @return [String] The internal version, in the form of "X.Y.Z.YYYYMMDD".
+        #
+        def self.create_internal_version(version)
+          vp = get_version_parts(version)
+          d = DateTime.now
+          todayDate = d.strftime('%Y%m%d')
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}.#{todayDate}"
+        end
+
+        # Return the build number value incremented by one.
+        #
+        # @param [String|Int|nil] build_number The build number to increment
+        #
+        # @return [Int] The incremented build number, or 0 if it was `nil`.
+        #
+        def self.bump_build_number(build_number)
+          build_number.nil? ? 0 : build_number.to_i + 1
+        end
+
+        # Determines if a version number corresponds to a hotfix
+        #
+        # @param [String] version The version number to test
+        #
+        # @return [Bool] True if the version number has a non-zero 3rd component, meaning that it is a hotfix version.
+        #
+        def self.is_hotfix?(version)
+          vp = get_version_parts(version)
+          return (vp.length > 2) && (vp[HOTFIX_NUMBER] != 0)
+        end
+
+        # Returns the current value of the `VERSION_LONG` key from the public xcconfig file
+        #
+        # @return [String] The current version according to the public xcconfig file.
+        #
+        def self.get_build_version
+          versions = get_version_strings()[0]
+        end
+
+        # Returns the current value of the `VERSION_LONG` key from the internal xcconfig file
+        #
+        # @return [String] The current version according to the internal xcconfig file.
+        #
+        def self.get_internal_version
+          get_version_strings()[1]
+        end
+
+        # Prints the current and next release version numbers to stdout, then return the next release version
+        #
+        # @return [String] The next release version to use after bumping the currently used public version.
+        #
+        def self.bump_version_release
+          # Bump release
+          current_version = get_public_version()
+          UI.message("Current version: #{current_version}")
+          new_version = calc_next_release_version(current_version)
+          UI.message("New version: #{new_version}")
+          verified_version = verify_version(new_version)
+
+          return verified_version
+        end
+
+        # Updates the `app_version` entry in the `Deliverfile`
+        #
+        # @param [String] new_version The new value to set the `app_version` entry to.
+        # @raise [UserError] If the Deliverfile was not found.
+        #
+        def self.update_fastlane_deliver(new_version)
+          fd_file = './fastlane/Deliverfile'
+          if File.exist?(fd_file)
+            Action.sh("sed -i '' \"s/app_version.*/app_version \\\"#{new_version}\\\"/\" #{fd_file}")
+          else
+            UI.user_error!("Can't find #{fd_file}.")
+          end
+        end
+
+        # Update the `.xcconfig` files (the public one, and the internal one if it exists) with the new version strings.
+        #
+        # @env PUBLIC_CONFIG_FILE The path to the xcconfig file containing the public version numbers.
+        # @env INTERNAL_CONFIG_FILE The path to the xcconfig file containing the internal version numbers. Can be nil.
+        #
+        # @param [String] new_version The new version number to use as `VERSION_LONG` for the public xcconfig file
+        # @param [String] new_version_short The new version number to use for `VERSION_SHORT` (for both public and internal xcconfig files)
+        # @param [String] internal_version The new version number to use as `VERSION_LONG` for the interrnal xcconfig file, if it exists
+        #
+        def self.update_xc_configs(new_version, new_version_short, internal_version)
+          update_xc_config(ENV['PUBLIC_CONFIG_FILE'], new_version, new_version_short)
+          update_xc_config(ENV['INTERNAL_CONFIG_FILE'], internal_version, new_version_short) unless ENV['INTERNAL_CONFIG_FILE'].nil?
+        end
+
+        # Updates an xcconfig file with new values for VERSION_SHORT and VERSION_LONG entries.
+        # Also bumps the BUILD_NUMBER value from that config file if there is one present.
+        #
+        # @param [String] file_path The path to the xcconfig file
+        # @param [String] new_version The new version number to use for VERSION_LONG
+        # @param [String] new_version_short The new version number to use for VERSION_SHORT
+        # @raise [UserError] If the xcconfig file was not found
+        #
+        def self.update_xc_config(file_path, new_version, new_version_short)
+          if File.exist?(file_path)
+            UI.message("Updating #{file_path} to version #{new_version_short}/#{new_version}")
+            Action.sh("sed -i '' \"$(awk '/^VERSION_SHORT/{ print NR; exit }' \"#{file_path}\")s/=.*/=#{new_version_short}/\" \"#{file_path}\"")
+            Action.sh("sed -i '' \"$(awk '/^VERSION_LONG/{ print NR; exit }' \"#{file_path}\")s/=.*/=#{new_version}/\" \"#{file_path}\"")
+
+            build_number = read_build_number_from_config_file(file_path)
+            unless build_number.nil?
+              new_build_number = bump_build_number(build_number)
+              Action.sh("sed -i '' \"$(awk '/^BUILD_NUMBER/{ print NR; exit }' \"#{file_path}\")s/=.*/=#{new_build_number}/\" \"#{file_path}\"")
+            end
+          else
+            UI.user_error!("#{file_path} not found")
+          end
+        end
+
+        #----------------------------------------
+        private
+
+        # Split a version string into its 4 parts, ensuring its parts count is valid
+        #
+        # @param [String] version The version string to split into parts
+        # @return [Array<String>] An array of exactly 4 elements, containing each part of the version string.
+        # @note If the original version string contains less than 4 parts, the returned array is filled with zeros at the end to always contain 4 items.
+        # @raise [UserError] Interrupts the lane if the provided version contains _more_ than 4 parts
+        #
+        def self.get_version_parts(version)
+          parts = version.split('.')
+          parts = parts.fill('0', parts.length...4).map { |chr| chr.to_i }
+          UI.user_error!("Bad version string: #{version}") if parts.length > 4
+
+          return parts
+        end
+
+        # Extract the VERSION_LONG entry from an `xcconfig` file
+        #
+        # @param [String] filePath The path to the `.xcconfig` file to read the value from
+        # @return [String] The long version found in said xcconfig file, or nil if not found
+        #
+        def self.read_long_version_from_config_file(filePath)
+          read_from_config_file('VERSION_LONG', filePath)
+        end
+
+        # Extract the BUILD_NUMBER entry from an `xcconfig` file
+        #
+        # @param [String] filePath The path to the `.xcconfig` file to read the value from
+        # @return [String] The build number found in said xcconfig file, or nil if not found
+        #
+        def self.read_build_number_from_config_file(filePath)
+          read_from_config_file('BUILD_NUMBER', filePath)
+        end
+
+        # Read the value of a given key from an `.xcconfig` file.
+        #
+        # @param [String] key The xcconfig key to get the value for
+        # @param [String] filePath The path to the `.xcconfig` file to read the value from
+        #
+        # @return [String] The value for the given key, or `nil` if the key was not found.
+        #
+        def self.read_from_config_file(key, filePath)
+          File.open(filePath, 'r') do |f|
+            f.each_line do |line|
+              line = line.strip()
+              return line.split('=')[1] if line.start_with?("#{key}=")
+            end
+          end
+
+          return nil
+        end
+
+        # Read the version numbers from the xcconfig file
+        #
+        # @env PUBLIC_CONFIG_FILE The path to the xcconfig file containing the public version numbers.
+        # @env INTERNAL_CONFIG_FILE The path to the xcconfig file containing the internal version numbers. Can be nil.
+        #
+        # @return [String] Array of long version strings found.
+        #         The first element is always present and contains the version extracted from the public config file
+        #         The second element is the version extracted from the internal config file, only present if one was provided.
+        def self.get_version_strings
+          version_strings = []
+          version_strings << read_long_version_from_config_file(ENV['PUBLIC_CONFIG_FILE'])
+          version_strings << read_long_version_from_config_file(ENV['INTERNAL_CONFIG_FILE']) unless ENV['INTERNAL_CONFIG_FILE'].nil?
+
+          return version_strings
+        end
+
+        # Ensure that the version provided is only composed of number parts and return the validated string
+        #
+        # @param [String] version The version string to validate
+        # @return [String] The version string, re-validated as being a string of the form `X.Y.Z.T`
+        # @raise [UserError] Interrupts the lane with a user_error! if the version contains non-numberic parts
+        #
+        def self.verify_version(version)
+          v_parts = get_version_parts(version)
+
+          v_parts.each do |part|
+            UI.user_error!('Version value can only contains numbers.') unless is_int?(part)
+          end
+
+          "#{v_parts[MAJOR_NUMBER]}.#{v_parts[MINOR_NUMBER]}.#{v_parts[HOTFIX_NUMBER]}.#{v_parts[BUILD_NUMBER]}"
+        end
+
+        # Check if a string is an integer
+        #
+        # @param [String] string The string to test
+        #
+        # @return [Bool] true if the string is representing an integer value, false if not
+        #
+        def self.is_int? string
+          true if Integer(string) rescue false
+        end
+      end
+    end
+  end
+end