fastlane-plugin-wpmreleasetoolkit 1.0.0

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

@@ -0,0 +1,359 @@
+require 'fastlane_core/ui/ui'
+require 'fileutils'
+require 'nokogiri'
+require 'open-uri'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?('UI')
+
+  module Helper
+    module Android
+      module LocalizeHelper
+        # Checks if string_line has the content_override flag set
+        def self.skip_string_by_tag(string_line)
+          skip = string_line.attr('content_override') == 'true' unless string_line.attr('content_override').nil?
+          if skip
+            puts " - Skipping #{string_line.attr('name')} string"
+            return true
+          end
+
+          return false
+        end
+
+        # Checks if string_name is in the excluesion list
+        def self.skip_string_by_exclusion_list(library, string_name)
+          return false unless library.key?(:exclusions)
+
+          skip = library[:exclusions].include?(string_name)
+          if skip
+            puts " - Skipping #{string_name} string"
+            return true
+          end
+        end
+
+        # Merge string_line into main_string
+        def self.merge_string(main_strings, library, string_line)
+          string_name = string_line.attr('name')
+          string_content = string_line.content
+
+          # Skip strings in the exclusions list
+          return :skipped if skip_string_by_exclusion_list(library, string_name)
+
+          # Search for the string in the main file
+          result = :added
+          main_strings.xpath('//string').each do |this_string|
+            if this_string.attr('name') == string_name
+              # Skip if the string has the content_override tag
+              return :skipped if skip_string_by_tag(this_string)
+
+              # If nodes are equivalent, skip
+              return :found if string_line =~ this_string
+
+              # The string needs an update
+              result = :updated
+              if this_string.attr('tools:ignore').nil?
+                # It can be updated, so remove the current one and move ahead
+                this_string.remove
+                break
+              else
+                # It has the tools:ignore flag, so update the content without touching the other attributes
+                this_string.content = string_content
+                return result
+              end
+            end
+          end
+
+          # String not found, or removed because needing update and not in the exclusion list: add to the main file
+          main_strings.xpath('//string').last().add_next_sibling("\n#{' ' * 4}#{string_line.to_xml().strip}")
+          return result
+        end
+
+        # Verify a string
+        def self.verify_string(main_strings, library, string_line)
+          string_name = string_line.attr('name')
+          string_content = string_line.content
+
+          # Skip strings in the exclusions list
+          return if skip_string_by_exclusion_list(library, string_name)
+
+          # Search for the string in the main file
+          main_strings.xpath('//string').each do |this_string|
+            if this_string.attr('name') == string_name
+              # Skip if the string has the content_override tag
+              return if skip_string_by_tag(this_string)
+
+              # Update if needed
+              UI.user_error!("String #{string_name} [#{string_content}] has been updated in the main file but not in the library #{library[:library]}.") if this_string.content != string_content
+              return
+            end
+          end
+
+          # String not found and not in the exclusion list:
+          UI.user_error!("String #{string_name} [#{string_content}] was found in library #{library[:library]} but not in the main file.")
+        end
+
+        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) }
+          lib_strings = File.open(library[:strings_path]) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
+
+          updated_count = 0
+          untouched_count = 0
+          added_count = 0
+          skipped_count = 0
+          lib_strings.xpath('//string').each do |string_line|
+            res = merge_string(main_strings, library, string_line)
+            case res
+            when :updated
+              puts "#{string_line.attr('name')} updated."
+              updated_count = updated_count + 1
+            when :found
+              untouched_count = untouched_count + 1
+            when :added
+              puts "#{string_line.attr('name')} added."
+              added_count = added_count + 1
+            when :skipped
+              skipped_count = skipped_count + 1
+            else
+              UI.user_error!("Internal Error! #{res}")
+            end
+          end
+
+          File.open(main, 'w:UTF-8') do |f|
+            f.write(main_strings.to_xml(indent: 4))
+          end
+
+          UI.message("Done (#{added_count} added, #{updated_count} updated, #{untouched_count} untouched, #{skipped_count} skipped).")
+          return (added_count + updated_count) != 0
+        end
+
+        def self.verify_diff(diff_string, main_strings, lib_strings, library)
+          if diff_string.start_with?('name=')
+            diff_string.slice!('name="')
+
+            end_index = diff_string.index('"')
+            end_index ||= diff_string.length # Use the whole string if there's no '"'
+
+            diff_string = diff_string.slice(0..(end_index - 1))
+
+            lib_strings.xpath('//string').each do |string_line|
+              res = verify_string(main_strings, library, string_line) if string_line.attr('name') == diff_string
+            end
+          end
+        end
+
+        def self.verify_lib(main, library, source_diff)
+          UI.message("Checking #{library[:library]} strings vs #{main}")
+          main_strings = File.open(main) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
+          lib_strings = File.open(library[:strings_path]) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
+
+          verify_local_diff(main, library, main_strings, lib_strings)
+          verify_pr_diff(main, library, main_strings, lib_strings, source_diff) unless source_diff.nil?
+        end
+
+        def self.verify_local_diff(main, library, main_strings, lib_strings)
+          `git diff #{main}`.each_line do |line|
+            if line.start_with?('+ ') || line.start_with?('- ')
+              diffs = line.gsub(/\s+/m, ' ').strip.split(' ')
+              diffs.each do |diff|
+                verify_diff(diff, main_strings, lib_strings, library)
+              end
+            end
+          end
+        end
+
+        def self.verify_pr_diff(main, library, main_strings, lib_strings, source_diff)
+          source_diff.each_line do |line|
+            if line.start_with?('+ ') || line.start_with?('- ')
+              diffs = line.gsub(/\s+/m, ' ').strip.split(' ')
+              diffs.each do |diff|
+                verify_diff(diff, main_strings, lib_strings, library)
+              end
+            end
+          end
+        end
+
+        ########
+        # @!group Downloading translations from GlotPress
+        ########
+
+        # Create the `available_languages.xml` file.
+        #
+        # @param [String] res_dir The relative path to the `…/src/main/res` directory
+        # @param [Array<String>] locale_codes The list of locale codes to include in the available_languages.xml file
+        #
+        def self.create_available_languages_file(res_dir:, locale_codes:)
+          doc = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+            xml.comment('Warning: Auto-generated file, do not edit.')
+            xml.resources do
+              xml.send(:'string-array', name: 'available_languages', translatable: 'false') do
+                locale_codes.each { |code| xml.item(code.gsub('-r', '_')) }
+              end
+            end
+          end
+          File.write(File.join(res_dir, 'values', 'available_languages.xml'), doc.to_xml)
+        end
+
+        # Download translations from GlotPress
+        #
+        # @param [String] res_dir The relative path to the `…/src/main/res` directory.
+        # @param [String] glotpress_project_url The base URL to the glotpress project to download the strings from.
+        # @param [Hash{String=>String}, Array] glotpress_filters
+        #        The filters to apply when exporting strings from GlotPress.
+        #        Typical examples include `{ status: 'current' }` or `{ status: 'review' }`.
+        #        If an array of Hashes is provided instead of a single Hash, this method will perform as many
+        #        export requests as items in this array, then merge all the results – useful for OR-ing multiple filters.
+        # @param [Array<Hash{Symbol=>String}>] locales_map
+        #        An array of locales to download. Each item in the array must be a Hash
+        #        with keys `:glotpress` and `:android` containing the respective locale codes.
+        #
+        def self.download_from_glotpress(res_dir:, glotpress_project_url:, glotpress_filters: { status: 'current' }, locales_map:)
+          glotpress_filters = [glotpress_filters] unless glotpress_filters.is_a?(Array)
+
+          attributes_to_copy = %w[formatted] # Attributes that we want to replicate into translated `string.xml` files
+          orig_file = File.join(res_dir, 'values', 'strings.xml')
+          orig_xml = File.open(orig_file) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
+          orig_attributes = orig_xml.xpath('//string').map { |tag| [tag['name'], tag.attributes.select { |k, _| attributes_to_copy.include?(k) }] }.to_h
+
+          locales_map.each do |lang_codes|
+            all_xml_documents = glotpress_filters.map do |filters|
+              UI.message "Downloading translations for '#{lang_codes[:android]}' from GlotPress (#{lang_codes[:glotpress]}) [#{filters}]..."
+              download_glotpress_export_file(project_url: glotpress_project_url, locale: lang_codes[:glotpress], filters: filters)
+            end.compact
+            next if all_xml_documents.empty?
+
+            # Merge all XMLs together
+            merged_xml = merge_xml_documents(all_xml_documents)
+
+            # Process XML (text substitutions, replicate attributes, quick-lint string)
+            merged_xml.xpath('//string').each do |string_tag|
+              apply_substitutions(string_tag)
+              orig_attributes[string_tag['name']]&.each { |k, v| string_tag[k] = v }
+              quick_lint(string_tag, lang_codes[:android])
+            end
+            merged_xml.xpath('//string-array/item').each { |item_tag| apply_substitutions(item_tag) }
+
+            # Save
+            lang_dir = File.join(res_dir, "values-#{lang_codes[:android]}")
+            FileUtils.mkdir(lang_dir) unless Dir.exist?(lang_dir)
+            lang_file = File.join(lang_dir, 'strings.xml')
+            File.open(lang_file, 'w') { |f| merged_xml.write_to(f, encoding: Encoding::UTF_8.to_s, indent: 4) }
+          end
+        end
+
+        #####################
+        # Private Helpers
+        #####################
+
+        # 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.
+        # @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' }`.
+        # @return [Nokogiri::XML] the download XML document, parsed as a Nokogiri::XML object
+        #
+        def self.download_glotpress_export_file(project_url:, locale:, filters:)
+          query_params = filters.transform_keys { |k| "filters[#{k}]" }.merge(format: 'android')
+          uri = URI.parse("#{project_url.chomp('/')}/#{locale}/default/export-translations?#{URI.encode_www_form(query_params)}")
+          begin
+            uri.open { |f| Nokogiri::XML(f.read.gsub("\t", '    '), nil, Encoding::UTF_8.to_s) }
+          rescue StandardError => e
+            UI.error "Error downloading #{locale} - #{e.message}"
+            return nil
+          end
+        end
+        private_class_method :download_glotpress_export_file
+
+        # Merge multiple Nokogiri::XML `strings.xml` documents together
+        #
+        # @param [Array<Nokogiri::XML::Document>] all_xmls Array of the Nokogiri XML documents to merge together
+        # @return [Nokogiri::XML::Document] The merged document.
+        #
+        # @note The first document in the array is used as starting point. Then string/resources from other docs are merged into it.
+        #       If a string/resource with a given `name` is present in multiple documents, the node of the last one wins.
+        #
+        def self.merge_xml_documents(all_xmls)
+          return all_xmls.first if all_xmls.count <= 1
+
+          merged_xml = all_xmls.first.dup # Use the first XML as starting point
+          resources_node = merged_xml.xpath('/resources').first
+          # For each other XML, find all the nodes with a name attribute, and merge them in
+          all_xmls.drop(1).each do |other_xml|
+            other_xml.xpath('/resources/*[@name]').each do |other_node|
+              existing_node = merged_xml.xpath("//#{other_node.name}[@name='#{other_node['name']}']").first
+              if existing_node.nil?
+                resources_node << '    ' << other_node << "\n"
+              else
+                existing_node.replace(other_node)
+              end
+            end
+          end
+          merged_xml
+        end
+        private_class_method :merge_xml_documents
+
+        # Apply some common text substitutions to tag contents
+        #
+        # @param [Nokogiri::XML::Node] tag The XML tag/node to apply substitutions to
+        #
+        def self.apply_substitutions(tag)
+          tag.content = tag.content.gsub('...', '…')
+        end
+        private_class_method :apply_substitutions
+
+        # Perform some quick basic checks about an individual `<string>` tag and print warnings accordingly
+        #
+        # @param [Nokogiri::XML::Node] string_tag The XML tag/node to check
+        # @param [String] lang The language we are currently processing. Used for providing context during logging / warning message
+        #
+        def self.quick_lint(string_tag, lang)
+          if string_tag['formatted'] == 'false' && string_tag.content.include?('%%')
+            UI.important "Warning: [#{lang}] translation for '#{string_tag['name']}' has attribute formatted=false, but still contains escaped '%%' in translation."
+          end
+        end
+        private_class_method :quick_lint
+
+        # @!endgroup
+      end
+    end
+  end
+end
+
+# Source: https://stackoverflow.com/questions/7825258/determine-if-two-nokogiri-nodes-are-equivalent?rq=1
+# There may be better solutions now that Ruby supports canonicalization.
+module Nokogiri
+  module XML
+    class Node
+      # Return true if this node is content-equivalent to other, false otherwise
+      def =~(other)
+        return true if self == other
+        return false unless name == other.name
+
+        stype = node_type
+        otype = other.node_type
+        return false unless stype == otype
+
+        sa = attributes
+        oa = other.attributes
+        return false unless sa.length == oa.length
+
+        sa = sa.sort.map { |n, a| [n, a.value, a.namespace && a.namespace.href] }
+        oa = oa.sort.map { |n, a| [n, a.value, a.namespace && a.namespace.href] }
+        return false unless sa == oa
+
+        skids = children
+        okids = other.children
+        return false unless skids.length == okids.length
+        return false if stype == TEXT_NODE && (content != other.content)
+
+        sns = namespace
+        ons = other.namespace
+        return false if !sns ^ !ons
+        return false if sns && (sns.href != ons.href)
+
+        skids.to_enum.with_index.all? { |ski, i| ski =~ okids[i] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,475 @@
+module Fastlane
+  module Helper
+    module Android
+      # A module containing helper methods to manipulate/extract/bump Android version strings in gradle files
+      #
+      module VersionHelper
+        # The key used in internal version Hash objects to hold the versionName value
+        VERSION_NAME = 'name'
+        # The key used in internal version Hash objects to hold the versionCode value
+        VERSION_CODE = 'code'
+        # 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 prefix used in front of the versionName for alpha versions
+        ALPHA_PREFIX = 'alpha-'
+        # The suffix used in the versionName for RC (beta) versions
+        RC_SUFFIX = '-rc'
+
+        # Returns the public-facing version string.
+        #
+        # @example
+        #    "1.2" # Assuming build.gradle contains versionName "1.2"
+        #    "1.2" # Assuming build.gradle contains versionName "1.2.0"
+        #    "1.2.3" # Assuming build.gradle contains versionName "1.2.3"
+        #
+        # @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
+          version = get_release_version
+          vp = get_version_parts(version[VERSION_NAME])
+          return "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}" unless is_hotfix?(version)
+
+          "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}"
+        end
+
+        # Extract the version name and code from the `vanilla` flavor of the `$PROJECT_NAME/build.gradle file`
+        #   or for the defaultConfig if `HAS_ALPHA_VERSION` is not defined.
+        #
+        # @env HAS_ALPHA_VERSION If set (with any value), indicates that the project uses `vanilla` flavor.
+        #
+        # @return [Hash] A hash with 2 keys "name" and "code" containing the extracted version name and code, respectively
+        #
+        def self.get_release_version
+          section = ENV['HAS_ALPHA_VERSION'].nil? ? 'defaultConfig' : 'vanilla {'
+          gradle_path = self.gradle_path
+          name = get_version_name_from_gradle_file(gradle_path, section)
+          code = get_version_build_from_gradle_file(gradle_path, section)
+          return { VERSION_NAME => name, VERSION_CODE => code }
+        end
+
+        # Extract the version name and code from the `defaultConfig` of the `$PROJECT_NAME/build.gradle` file
+        #
+        # @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
+          return nil if ENV['HAS_ALPHA_VERSION'].nil?
+
+          section = 'defaultConfig'
+          gradle_path = self.gradle_path
+          name = get_version_name_from_gradle_file(gradle_path, section)
+          code = get_version_build_from_gradle_file(gradle_path, section)
+          return { VERSION_NAME => name, VERSION_CODE => code }
+        end
+
+        # Determines if a version name corresponds to an alpha version (starts with `"alpha-"`` prefix)
+        #
+        # @param [String] version The version name to check
+        #
+        # @return [Bool] true if the version name starts with the `ALPHA_PREFIX`, false otherwise.
+        #
+        # @private
+        #
+        def self.is_alpha_version?(version)
+          version[VERSION_NAME].start_with?(ALPHA_PREFIX)
+        end
+
+        # Check if this versionName corresponds to a beta, i.e. contains some `-rc` suffix
+        #
+        # @param [String] version The versionName string to check for
+        #
+        # @return [Bool] True if the version string contains `-rc`, indicating it is a beta version.
+        #
+        def self.is_beta_version?(version)
+          version[VERSION_NAME].include?(RC_SUFFIX)
+        end
+
+        # Returns the version name and code to use for the final release.
+        #
+        # - The final version name corresponds to the beta's versionName, without the `-rc` suffix
+        # - The final version code corresponds to the versionCode for the alpha (or for the beta if alpha_version is nil) incremented by one.
+        #
+        # @param [Hash] beta_version The version hash for the beta (vanilla flavor), containing values for keys "name" and "code"
+        # @param [Hash] alpha_version The version hash for the alpha (defaultConfig), containing values for keys "name" and "code",
+        #                             or `nil` if no alpha version to consider.
+        #
+        # @return [Hash] A version hash with keys "name" and "code", containing the version name and code to use for final release.
+        #
+        def self.calc_final_release_version(beta_version, alpha_version)
+          version_name = beta_version[VERSION_NAME].split('-')[0]
+          version_code = alpha_version.nil? ? beta_version[VERSION_CODE] + 1 : alpha_version[VERSION_CODE] + 1
+
+          { VERSION_NAME => version_name, VERSION_CODE => version_code }
+        end
+
+        # Returns the version name and code to use for the next alpha.
+        #
+        # - The next version name corresponds to the `alpha_version`'s name incremented by one (alpha-42 => alpha-43)
+        # - The next version code corresponds to the `version`'s code incremented by one.
+        #
+        # @param [Hash] version The version hash for the current beta or release, containing values for keys "name" and "code"
+        # @param [Hash] alpha_version The version hash for the current alpha (defaultConfig), containing values for keys "name" and "code"
+        #
+        # @return [Hash] A version hash with keys "name" and "code", containing the version name and code to use for final release.
+        #
+        def self.calc_next_alpha_version(version, alpha_version)
+          # Bump alpha name
+          alpha_number = alpha_version[VERSION_NAME].sub(ALPHA_PREFIX, '')
+          alpha_name = "#{ALPHA_PREFIX}#{alpha_number.to_i() + 1}"
+
+          # Bump alpha code
+          alpha_code = version[VERSION_CODE] + 1
+
+          { VERSION_NAME => alpha_name, VERSION_CODE => alpha_code }
+        end
+
+        # Compute the version name and code to use for the next beta (`X.Y.Z-rc-N`).
+        #
+        # - The next version name corresponds to the `version`'s name with the value after the `-rc-` suffix incremented by one,
+        #     or with `-rc-1` added if there was no previous rc suffix (if `version` was not a beta but a release)
+        # - The next version code corresponds to the `alpha_version`'s (or `version`'s if `alpha_version` is nil) code, incremented by one.
+        #
+        # @example
+        #   calc_next_beta_version({"name": "1.2.3", "code": 456}) #=> {"name": "1.2.3-rc-1", "code": 457}
+        #   calc_next_beta_version({"name": "1.2.3-rc-2", "code": 456}) #=> {"name": "1.2.3-rc-3", "code": 457}
+        #   calc_next_beta_version({"name": "1.2.3", "code": 456}, {"name": "alpha-1.2.3", "code": 457}) #=> {"name": "1.2.3-rc-1", "code": 458}
+        #
+        # @param [Hash] version The version hash for the current beta or release, containing values for keys "name" and "code"
+        # @param [Hash] alpha_version The version hash for the alpha, containing values for keys "name" and "code",
+        #                             or `nil` if no alpha version to consider.
+        #
+        # @return [Hash] A hash with keys `"name"` and `"code"` containing the next beta version name and code.
+        #
+        def self.calc_next_beta_version(version, alpha_version = nil)
+          # Bump version name
+          beta_number = is_beta_version?(version) ? version[VERSION_NAME].split('-')[2].to_i + 1 : 1
+          version_name = "#{version[VERSION_NAME].split('-')[0]}#{RC_SUFFIX}-#{beta_number}"
+
+          # Bump version code
+          version_code = alpha_version.nil? ? version[VERSION_CODE] + 1 : alpha_version[VERSION_CODE] + 1
+          { VERSION_NAME => version_name, VERSION_CODE => version_code }
+        end
+
+        # Compute the version name to use for the next release (`"X.Y"`).
+        #
+        # @param [String] version The version name (string) to increment
+        #
+        # @return [String] The version name for the next release
+        #
+        def self.calc_next_release_short_version(version)
+          v = self.calc_next_release_base_version(VERSION_NAME => version, VERSION_CODE => nil)
+          return v[VERSION_NAME]
+        end
+
+        # Compute the next release version name for the given version, without incrementing the version code
+        #
+        #  - The version name sees its minor version part incremented by one (and carried to next major if it reaches 10)
+        #  - The version code is unchanged. This method is intended to be called internally by other methods taking care of the version code bump.
+        #
+        # @param [Hash] version A version hash, with keys `"name"` and `"code"`, containing the version to increment
+        #
+        # @return [Hash] Hash containing the next release version name ("X.Y") and code.
+        #
+        def self.calc_next_release_base_version(version)
+          version_name = remove_beta_suffix(version[VERSION_NAME])
+          vp = get_version_parts(version_name)
+          vp[MINOR_NUMBER] += 1
+          if vp[MINOR_NUMBER] == 10
+            vp[MAJOR_NUMBER] += 1
+            vp[MINOR_NUMBER] = 0
+          end
+
+          { VERSION_NAME => "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}", VERSION_CODE => version[VERSION_CODE] }
+        end
+
+        # Compute the name of the next version to use after code freeze, by incrementing the current version name and making it a `-rc-1`
+        #
+        # @example
+        #   calc_next_release_version({"name": "1.2", "code": 456}) #=> {"name":"1.3-rc-1", "code": 457}
+        #   calc_next_release_version({"name": "1.2.3", "code": 456}) #=> {"name":"1.3-rc-1", "code": 457}
+        #   calc_next_release_version({"name": "1.2", "code": 456}, {"name":"alpha-1.2", "code": 457}) #=> {"name":"1.3-rc-1", "code": 458}
+        #
+        # @param [Hash] version The current version hash, with keys `"name"` and `"code"`
+        # @param [Hash] alpha_version The current alpha version hash, with keys `"name"` and `"code"`, or nil if no alpha version
+        #
+        # @return [Hash] The hash containing the version name and code to use after release cut
+        #
+        def self.calc_next_release_version(version, alpha_version = nil)
+          nv = calc_next_release_base_version(VERSION_NAME => version[VERSION_NAME], VERSION_CODE => alpha_version.nil? ? version[VERSION_CODE] : [version[VERSION_CODE], alpha_version[VERSION_CODE]].max)
+          calc_next_beta_version(nv)
+        end
+
+        # Compute the name and code of the next hotfix version.
+        #
+        # @param [String] hotfix_version_name The next version name we want for the hotfix
+        # @param [String] hotfix_version_code The next version code we want for the hotfix
+        #
+        # @return [Hash] The predicted next hotfix version, as a Hash containing the keys `"name"` and `"code"`
+        #
+        def self.calc_next_hotfix_version(hotfix_version_name, hotfix_version_code)
+          { VERSION_NAME => hotfix_version_name, VERSION_CODE => hotfix_version_code }
+        end
+
+        # Compute the name of the previous release version, by decrementing the minor version number
+        #
+        # @example
+        #    calc_prev_release_version("1.2") => "1.1"
+        #    calc_prev_release_version("1.2.3") => "1.1"
+        #    calc_prev_release_version("3.0") => "2.9"
+        #
+        # @param [String] version The version string to decrement
+        #
+        # @return [String] A 2-parts version string "X.Y" corresponding to the guessed previous release version.
+        #
+        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
+
+        # Determines if a version name 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)
+          return false if is_alpha_version?(version)
+
+          vp = get_version_parts(version[VERSION_NAME])
+          return (vp.length > 2) && (vp[HOTFIX_NUMBER] != 0)
+        end
+
+        # Prints the current and next release version names to stdout, then returns the next release version
+        #
+        # @return [String] The next release version name to use after bumping the currently used release version.
+        #
+        def self.bump_version_release
+          # Bump release
+          current_version = 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]}")
+          verified_version = verify_version(new_version[VERSION_NAME])
+
+          return verified_version
+        end
+
+        # Update the `build.gradle` file with new `versionName` and `versionCode` values, both or the `defaultConfig` and `vanilla` flavors
+        #
+        # @param [Hash] new_version_beta The version hash for the beta (vanilla flavor), containing values for keys "name" and "code"
+        # @param [Hash] new_version_alpha The version hash for the alpha (defaultConfig), containing values for keys "name" and "code"
+        # @env HAS_ALPHA_VERSION If set (with any value), indicates that the project uses `vanilla` flavor.
+        #
+        def self.update_versions(new_version_beta, new_version_alpha)
+          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?
+        end
+
+        # Compute the name of the previous hotfix version.
+        #
+        # @param [String] version_name The current version name 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, stripping it if it ends up being zero.
+        #
+        def self.calc_prev_hotfix_version_name(version_name)
+          vp = get_version_parts(version_name)
+          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
+
+        # Extract the value of a import key from build.gradle
+        #
+        # @param [String] import_key The key to look for
+        # @return [String] The value of the key, or nil if not found
+        #
+        def self.get_library_version_from_gradle_config(import_key:)
+          gradle_file_path = File.join(ENV['PROJECT_ROOT_FOLDER'] || '.', 'build.gradle')
+
+          return nil unless File.exist?(gradle_file_path)
+
+          File.open(gradle_file_path, 'r') do |f|
+            text = f.read
+            text.match(/^\s*(?:\w*\.)?#{Regexp.escape(import_key)}\s*=\s*['"](.*?)["']/m)&.captures&.first
+          end
+        end
+
+        #----------------------------------------
+        private
+
+        # Remove the beta suffix (part after the `-`) from a version string
+        #
+        # @param [String] version The version string to remove the suffix from
+        #
+        # @return [String] The part of the version string without the beta suffix, i.e. the part before the first dash.
+        #
+        # @example remove_beta_suffix("1.2.3-rc.4") => "1.2.3"
+        #
+        def self.remove_beta_suffix(version)
+          version.split('-')[0]
+        end
+
+        # Split a version string into its individual integer parts
+        #
+        # @param [String] version The version string to split, e.g. "1.2.3.4"
+        #
+        # @return [Array<Int>] An array of integers containing the individual integer parts of the version.
+        #                      Always contains 3 items at minimum (0 are added to the end if the original string contains less than 3 parts)
+        #
+        def self.get_version_parts(version)
+          parts = version.split('.').map(&:to_i)
+          parts.fill(0, parts.length...3) # add 0 if needed to ensure array has at least 3 components
+          return parts
+        end
+
+        # Extract the versionName from a build.gradle file
+        #
+        # @param [String] file_path The path to the `.gradle` file
+        # @param [String] section The name of the section we expect the keyword to be in, e.g. "defaultConfig" or "vanilla"
+        #
+        # @return [String] The value of the versionName attribute as found in the build.gradle file and for this section.
+        #
+        def self.get_version_name_from_gradle_file(file_path, section)
+          res = get_keyword_from_gradle_file(file_path, section, 'versionName')
+          res = res.tr('\"', '') unless res.nil?
+          return res
+        end
+
+        # Extract the versionCode rom a build.gradle file
+        #
+        # @param [String] file_path The path to the `.gradle` file
+        # @param [String] section The name of the section we expect the keyword to be in, e.g. "defaultConfig" or "vanilla"
+        #
+        # @return [String] The value of the versionCode attribute as found in the build.gradle file and for this section.
+        #
+        def self.get_version_build_from_gradle_file(file_path, section)
+          res = get_keyword_from_gradle_file(file_path, section, 'versionCode')
+          return res.to_i
+        end
+
+        # Extract the value for a specific keyword in a specific section of a `.gradle` file
+        #
+        # @todo: This implementation is very fragile. This should be done parsing the file in a proper way.
+        #        Leveraging gradle itself is probably the easiest way.
+        #
+        # @param [String] file_path The path of the `.gradle` file to extract the value from
+        # @param [String] section The name of the section from which we want to extract this keyword from. For example `defaultConfig` or `myFlavor`
+        # @param [String] keyword The keyword (key name) we want the value for
+        #
+        # @return [String] Returns the value for that keyword in the section of the `.gradle` file, or nil if not found.
+        #
+        def self.get_keyword_from_gradle_file(file_path, section, keyword)
+          found_section = false
+          File.open(file_path, 'r') do |file|
+            file.each_line do |line|
+              if !found_section
+                found_section = true if line.include?(section)
+              else
+                return line.split(' ')[1] if line.include?(keyword) && !line.include?("\"#{keyword}\"") && !line.include?("P#{keyword}")
+              end
+            end
+          end
+          return nil
+        end
+
+        # Ensure that a version string is correctly formatted (that is, each of its parts is a number) and returns the 2-parts version number
+        #
+        # @param [String] version The version string to verify
+        #
+        # @return [String] The "major.minor" version string, only with the first 2 components
+        # @raise [UserError] If any of the parts of the version string is not a number
+        #
+        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]}"
+        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
+
+        # The path to the build.gradle file for the project.
+        #
+        # @env PROJECT_ROOT_FOLDER The path to the root of the project (the folder containing the `.git` directory).
+        # @env PROJECT_NAME The name of the project, i.e. the name of the subdirectory containing the project's `build.gradle` file.
+        #
+        # @return [String] The path of the `build.gradle` file inside the project subfolder in the project's repo
+        #
+        def self.gradle_path
+          UI.user_error!("You need to set the \`PROJECT_ROOT_FOLDER\` environment variable to the path to the project's root") if ENV['PROJECT_ROOT_FOLDER'].nil?
+          UI.user_error!("You need to set the \`PROJECT_NAME\` environment variable to the relative path to the project subfolder name") if ENV['PROJECT_NAME'].nil?
+          File.join(ENV['PROJECT_ROOT_FOLDER'], ENV['PROJECT_NAME'], 'build.gradle')
+        end
+
+        # Update both the versionName and versionCode of the build.gradle file to the specified version.
+        #
+        # @param [Hash] version The version hash, containing values for keys "name" and "code"
+        # @param [String] section The name of the section to update in the build.gradle file, e.g. "defaultConfig" or "vanilla"
+        #
+        # @todo This implementation is very fragile. This should be done parsing the file in a proper way.
+        #       Leveraging gradle itself is probably the easiest way.
+        #
+        def self.update_version(version, section)
+          gradle_path = self.gradle_path
+          temp_file = Tempfile.new('fastlaneIncrementVersion')
+          found_section = false
+          version_updated = 0
+          File.open(gradle_path, 'r') do |file|
+            file.each_line do |line|
+              if !found_section
+                temp_file.puts line
+                found_section = true if line.include? section
+              else
+                if version_updated < 2
+                  if line.include?('versionName') && !line.include?('"versionName"') && !line.include?('PversionName')
+                    version_name = line.split(' ')[1].tr('\"', '')
+                    line.sub!(version_name, version[VERSION_NAME].to_s)
+                    version_updated = version_updated + 1
+                  end
+
+                  if line.include? 'versionCode'
+                    version_code = line.split(' ')[1]
+                    line.sub!(version_code, version[VERSION_CODE].to_s)
+                    version_updated = version_updated + 1
+                  end
+                end
+                temp_file.puts line
+              end
+            end
+            file.close
+          end
+          temp_file.rewind
+          temp_file.close
+          FileUtils.mv(temp_file.path, gradle_path)
+          temp_file.unlink
+        end
+      end
+    end
+  end
+end