fastlane-plugin-wpmreleasetoolkit 11.1.0 → 12.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f9d86b44058a8ff2f28f2c56bdb81230395e36eac41f6e4d0761140f9694177
-  data.tar.gz: cc234c6029919a63d4d9ed2114d390bb58ad79e67f7ae1650e94b23cfac92bc9
+  metadata.gz: 2f4bad14f2aca7e44fede245ed91674426c688395c9d6a5085a4d25a5e30e361
+  data.tar.gz: 66e0440a5340b12dff4a5e35c37759c48d04c8f157e83e4c57ca94cde2c4135e
 SHA512:
-  metadata.gz: e2e86d40c624300445ddc600e19b8b16a560e86725c82344719bbbadb69ad0c1552fff4f951cdb5411d892973fa37b524b47bcc99b0d14a23bff56607d44f676
-  data.tar.gz: faf08e93483cced02d83d705b9cff2843e07244c708312bdf8dfb86131b2990d4e5ba94397aa71aadd8a3cb6d485da2007b5743950e15486ff81243f8a956b35
+  metadata.gz: 1ed67cfa98a54dfe351d5e90ac318f97f1d40d777ac498f427b7c417f32651f16574eb441de44730ef5a7299edef57b096137b06ab64a4964aca56d072e7a0c0
+  data.tar.gz: a698dc1828a99415b4b88b373541ad20b264933cb2d13b0c65b2efd6c4608361b40bb0dca4756f9a518dee3a9e7fa4f8c43e142dfb3a50bba391398f76744bd5

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_create_xml_release_notes.rb

@@ -2,8 +2,6 @@ module Fastlane
   module Actions
     class AndroidCreateXmlReleaseNotesAction < Action
       def self.run(params)
-        require_relative '../../helper/android/android_git_helper'
-
         release_notes_path = "#{params[:download_path]}/release_notes.xml"
         open(release_notes_path, 'w') do |f|
           params[:locales].each do |loc|

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_current_branch_is_hotfix.rb

@@ -8,11 +8,9 @@ module Fastlane
       def self.run(params)
         require_relative '../../helper/android/android_version_helper'
 
-        build_gradle_path = params[:build_gradle_path]
         version_properties_path = params[:version_properties_path]
 
         version = Fastlane::Helper::Android::VersionHelper.get_release_version(
-          build_gradle_path: build_gradle_path,
           version_properties_path: version_properties_path
         )
         Fastlane::Helper::Android::VersionHelper.is_hotfix?(version)
@@ -32,16 +30,10 @@ module Fastlane
 
       def self.available_options
         [
-          FastlaneCore::ConfigItem.new(key: :build_gradle_path,
-                                       description: 'Path to the build.gradle file',
-                                       type: String,
-                                       optional: true,
-                                       conflicting_options: [:version_properties_path]),
           FastlaneCore::ConfigItem.new(key: :version_properties_path,
                                        description: 'Path to the version.properties file',
                                        type: String,
-                                       optional: true,
-                                       conflicting_options: [:build_gradle_path]),
+                                       optional: false),
         ]
       end
 

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

@@ -1,8 +1,6 @@
 require 'fastlane/action'
 require 'date'
 require_relative '../../helper/github_helper'
-require_relative '../../helper/ios/ios_version_helper'
-require_relative '../../helper/android/android_version_helper'
 module Fastlane
   module Actions
     class CloseMilestoneAction < Action

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/{create_release_action.rb → create_github_release_action.rb}

@@ -1,11 +1,9 @@
 require 'fastlane/action'
 require 'date'
 require_relative '../../helper/github_helper'
-require_relative '../../helper/ios/ios_version_helper'
-require_relative '../../helper/android/android_version_helper'
 module Fastlane
   module Actions
-    class CreateReleaseAction < Action
+    class CreateGithubReleaseAction < Action
       def self.run(params)
         repository = params[:repository]
         version = params[:version]

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

@@ -2,7 +2,6 @@ require 'fastlane/action'
 require 'date'
 require_relative '../../helper/github_helper'
 require_relative '../../helper/ios/ios_version_helper'
-require_relative '../../helper/android/android_version_helper'
 module Fastlane
   module Actions
     class CreateNewMilestoneAction < Action

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

@@ -103,7 +103,10 @@ module Fastlane
         # if there's a callback, make sure it didn't switch branches
         other_action.ensure_git_branch(branch: "^#{intermediate_branch}/") unless intermediate_branch_created_callback.nil?
 
-        if Fastlane::Helper::GitHelper.point_to_same_commit?(base_branch, head_branch)
+        base_branch_ref = base_branch.start_with?('origin/') ? base_branch : "origin/#{base_branch}"
+        head_branch_ref = head_branch.start_with?('origin/') ? head_branch : "origin/#{head_branch}"
+
+        if Fastlane::Helper::GitHelper.point_to_same_commit?(base_branch_ref, head_branch_ref)
           UI.error("No differences between #{head_branch} and #{base_branch}. Skipping PR creation.")
           return nil
         end

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

@@ -0,0 +1,63 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class PublishGithubReleaseAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        name = params[:name]
+        prerelease = params[:prerelease]
+
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+
+        url = github_helper.publish_release(
+          repository: repository,
+          name: name,
+          prerelease: prerelease == :unchanged ? nil : prerelease
+        )
+        UI.success("Successfully published GitHub Release #{name}. You can see it at '#{url}'")
+        url
+      end
+
+      def self.description
+        'Publish an existing GitHub Release still in draft mode'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.return_value
+        'The URL of the published GitHub Release'
+      end
+
+      def self.details
+        'Publish an existing GitHub Release still in draft mode'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       description: 'The slug (`<org>/<repo>`) of the GitHub repository we want to create the release on',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       description: 'The name (aka title) of the draft release to publish',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :prerelease,
+                                       description: 'True to publish as a pre-release. False to published as final. Don\'t provide a value to keep the same (non-)prerelease status as the one used in the Draft',
+                                       optional: true,
+                                       default_value: :unchanged,
+                                       type: Boolean),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -7,9 +7,6 @@ module Fastlane
       NON_STABLE_PODS_MESSAGE = "Please create a new stable version of those pods and update the Podfile to the newly released version before continuing with the code freeze:\n".freeze
 
       def self.run(params)
-        require_relative '../../helper/ios/ios_version_helper'
-        require_relative '../../helper/ios/ios_git_helper'
-
         yaml = YAML.load_file(params[:lockfile])
         non_stable_pods = {} # Key will be pod name, value will be reason for flagging
 

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

@@ -19,48 +19,11 @@ module Fastlane
         # The suffix used in the versionName for RC (beta) versions
         RC_SUFFIX = '-rc'.freeze
 
-        # 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(build_gradle_path:, version_properties_path:)
-          version = get_release_version(
-            build_gradle_path: build_gradle_path,
-            version_properties_path: version_properties_path
-          )
-          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 release version of the app from `version.properties file`
         #
         # @return [Hash] A hash with 2 keys "name" and "code" containing the extracted version name and code, respectively
         #
-        def self.get_release_version(build_gradle_path:, version_properties_path:)
-          return get_version_from_properties(version_properties_path: version_properties_path) if File.exist?(version_properties_path)
-
-          section = 'defaultConfig'
-          name = get_version_name_from_gradle_file(build_gradle_path, section)
-          code = get_version_build_from_gradle_file(build_gradle_path, section)
-          { VERSION_NAME => name, VERSION_CODE => code }
-        end
-
-        # Extract the version name and code from the `version.properties` file in the project root
-        #
-        # @param [Boolean] is_alpha true if the alpha version should be returned, false otherwise
-        #
-        # @return [Hash] A hash with 2 keys "name" and "code" containing the extracted version name and code, respectively
-        #
-        def self.get_version_from_properties(version_properties_path:, is_alpha: false)
+        def self.get_release_version(version_properties_path:, is_alpha: false)
           return nil unless File.exist?(version_properties_path)
 
           version_name_key = is_alpha ? 'alpha.versionName' : 'versionName'
@@ -73,107 +36,6 @@ module Fastlane
           name.nil? || code.nil? ? nil : { VERSION_NAME => name, VERSION_CODE => code.to_i }
         end
 
-        # Extract the version name and code from the `version.properties` file in the project root
-        #
-        # @return [Hash] A hash with 2 keys `"name"` and `"code"` containing the extracted version name and code, respectively
-        #
-        def self.get_alpha_version(build_gradle_path:, version_properties_path:)
-          return get_version_from_properties(version_properties_path: version_properties_path, is_alpha: true) if File.exist?(version_properties_path)
-
-          section = 'defaultConfig'
-          name = get_version_name_from_gradle_file(build_gradle_path, section)
-          code = get_version_build_from_gradle_file(build_gradle_path, section)
-          { 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, 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 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
@@ -206,57 +68,6 @@ module Fastlane
           { 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]).zero?
-            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
@@ -264,69 +75,12 @@ module Fastlane
         # @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)
+          return false if version[VERSION_NAME].start_with?(ALPHA_PREFIX)
 
           vp = get_version_parts(version[VERSION_NAME])
           (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(build_gradle_path:, version_properties_path:)
-          # Bump release
-          current_version = get_release_version(
-            build_gradle_path: build_gradle_path,
-            version_properties_path: version_properties_path
-          )
-          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]}")
-          verify_version(new_version[VERSION_NAME])
-        end
-
-        # Update the `version.properties` file with new `versionName` and `versionCode` values
-        #
-        # @param [Hash] new_version_beta The version hash for the beta, containing values for keys "name" and "code"
-        # @param [Hash] new_version_alpha The version hash for the alpha , containing values for keys "name" and "code"
-        #
-        def self.update_versions(new_version_beta, new_version_alpha, version_properties_path:)
-          if File.exist?(version_properties_path)
-            replacements = {
-              versionName: (new_version_beta || {})[VERSION_NAME],
-              versionCode: (new_version_beta || {})[VERSION_CODE],
-              'alpha.versionName': (new_version_alpha || {})[VERSION_NAME],
-              'alpha.versionCode': (new_version_alpha || {})[VERSION_CODE]
-            }
-            content = File.read(version_properties_path)
-            content.gsub!(/^(.*) ?=.*$/) do |line|
-              key = Regexp.last_match(1).to_sym
-              value = replacements[key]
-              value.nil? ? line : "#{key}=#{value}"
-            end
-            File.write(version_properties_path, content)
-          else
-            update_version(new_version_beta, 'defaultConfig')
-            update_version(new_version_alpha, 'defaultConfig') unless new_version_alpha.nil?
-          end
-        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]).zero?
-          return "#{vp[MAJOR_NUMBER]}.#{vp[MINOR_NUMBER]}.#{vp[HOTFIX_NUMBER]}" unless (vp[HOTFIX_NUMBER]).zero?
-
-          "#{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
@@ -367,131 +121,6 @@ module Fastlane
           parts.fill(0, parts.length...3) # add 0 if needed to ensure array has at least 3 components
           parts
         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 StandardError
-          false
-        end
-
-        #########
-        # Functions to support versioning through build.gradle - can be removed once all projects adopt version.properties
-        ########
-
-        # 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?
-          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')
-          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
-                return line.split[1] if line.include?(keyword) && !line.include?("\"#{keyword}\"") && !line.include?("P#{keyword}")
-              elsif line.include?(section)
-                found_section = true
-              end
-            end
-          end
-          nil
-        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, build_gradle_path:)
-          temp_file = Tempfile.new('fastlaneIncrementVersion')
-          found_section = false
-          version_updated = 0
-          File.open(build_gradle_path, 'r') do |file|
-            file.each_line do |line|
-              if found_section
-                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 += 1
-                  end
-
-                  if line.include? 'versionCode'
-                    version_code = line.split[1]
-                    line.sub!(version_code, version[VERSION_CODE].to_s)
-                    version_updated += 1
-                  end
-                end
-                temp_file.puts line
-              else
-                temp_file.puts line
-                found_section = true if line.include? section
-              end
-            end
-            file.close
-          end
-          temp_file.rewind
-          temp_file.close
-          FileUtils.mv(temp_file.path, build_gradle_path)
-          temp_file.unlink
-        end
       end
     end
   end

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

@@ -67,15 +67,6 @@ module Fastlane
         false
       end
 
-      # Update every submodule in the current git repository
-      #
-      # @deprecated This method is going to be removed soon. Fastlane has a built-in `git_submodule_update` action that can be used instead.
-      #
-      def self.update_submodules
-        UI.deprecated("The `update_submodules` method will soon be removed from `release-toolkit`. Please use fastlane's `git_submodule_update` action instead.")
-        Action.sh('git', 'submodule', 'update', '--init', '--recursive')
-      end
-
       # Create a new branch named `branch_name`, cutting it from branch/commit/tag `from`
       #
       # If the branch with that name already exists, it will instead switch to it and pull new commits.
@@ -188,8 +179,14 @@ module Fastlane
       #
       def self.point_to_same_commit?(ref1, ref2)
         git_repo = Git.open(Dir.pwd)
-        ref1_commit = git_repo.gcommit(ref1)
-        ref2_commit = git_repo.gcommit(ref2)
+
+        begin
+          ref1_commit = git_repo.gcommit(ref1)
+          ref2_commit = git_repo.gcommit(ref2)
+        rescue StandardError => e
+          puts "Error: #{e.message}"
+          return false
+        end
 
         ref1_commit.sha == ref2_commit.sha
       end
@@ -232,24 +229,6 @@ module Fastlane
         !Action.sh('git', 'ls-remote', '--heads', remote_name, branch_name).empty?
       end
 
-      # Ensure that we are on the expected branch, and abort if not.
-      #
-      # @param [String] branch_name The name of the branch we expect to be on
-      #
-      # @raise [UserError] Raises a user_error! and interrupts the lane if we are not on the expected branch.
-      #
-      # @deprecated This method is going to be removed soon. Fastlane has a built-in `ensure_git_branch` action that can be used instead.
-      #             After updating to Fastlane version `2.217.0` or later, the `FL_GIT_BRANCH_DONT_USE_ENV_VARS` environment
-      #             variable can be set to `true` to disable the use of environment variables for the `git_branch` action that
-      #             `ensure_git_branch` relies on. This will make `ensure_git_branch` work as expected in CI environments.
-      #             See https://github.com/fastlane/fastlane/pull/21597 for more details.
-      #
-      def self.ensure_on_branch!(branch_name)
-        UI.deprecated("The `ensure_on_branch!` method will soon be removed from `release-toolkit`. Please use fastlane's `ensure_git_branch` action (+ potentially set `FL_GIT_BRANCH_DONT_USE_ENV_VARS=true`) instead.")
-        current_branch_name = Action.sh('git', 'symbolic-ref', '-q', 'HEAD')
-        UI.user_error!("This command works only on #{branch_name} branch") unless current_branch_name.include?(branch_name)
-      end
-
       # Checks whether a given path is ignored by Git, relying on Git's `check-ignore` under the hood.
       #
       # @param [String] path The path to check against `.gitignore`