fastlane-plugin-wpmreleasetoolkit 9.0.1 → 9.2.0

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

@@ -30,8 +30,11 @@ module Fastlane
         #         - 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
+        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)
 
@@ -42,33 +45,28 @@ module Fastlane
         #
         # @return [Hash] A hash with 2 keys "name" and "code" containing the extracted version name and code, respectively
         #
-        def self.get_release_version
-          return get_version_from_properties if File.exist?(version_properties_file)
+        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 = 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)
+          name = get_version_name_from_gradle_file(build_gradle_path, section)
+          code = get_version_build_from_gradle_file(build_gradle_path, section)
           return { VERSION_NAME => name, VERSION_CODE => code }
         end
 
-        def self.version_properties_file
-          File.join(ENV['PROJECT_ROOT_FOLDER'] || '.', 'version.properties')
-        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(is_alpha: false)
-          return nil unless File.exist?(version_properties_file)
+        def self.get_version_from_properties(version_properties_path:, is_alpha: false)
+          return nil unless File.exist?(version_properties_path)
 
           version_name_key = is_alpha ? 'alpha.versionName' : 'versionName'
           version_code_key = is_alpha ? 'alpha.versionCode' : 'versionCode'
 
-          text = File.read(version_properties_file)
+          text = File.read(version_properties_path)
           name = text.match(/#{version_name_key}=(\S*)/m)&.captures&.first
           code = text.match(/#{version_code_key}=(\S*)/m)&.captures&.first
 
@@ -80,15 +78,14 @@ module Fastlane
         # @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 get_version_from_properties(is_alpha: true) if File.exist?(version_properties_file)
+        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)
 
           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)
+          name = get_version_name_from_gradle_file(build_gradle_path, section)
+          code = get_version_build_from_gradle_file(build_gradle_path, section)
           return { VERSION_NAME => name, VERSION_CODE => code }
         end
 
@@ -280,9 +277,12 @@ module Fastlane
         #
         # @return [String] The next release version name to use after bumping the currently used release version.
         #
-        def self.bump_version_release
+        def self.bump_version_release(build_gradle_path:, version_properties_path:)
           # Bump release
-          current_version = self.get_release_version
+          current_version = self.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]}")
@@ -296,21 +296,21 @@ module Fastlane
         # @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)
-          if File.exist?(version_properties_file)
+        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_file)
+            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_file, content)
+            File.write(version_properties_path, content)
           else
             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?
@@ -337,12 +337,10 @@ module Fastlane
         # @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')
+        def self.get_library_version_from_gradle_config(build_gradle_path:, import_key:)
+          return nil unless File.exist?(build_gradle_path)
 
-          return nil unless File.exist?(gradle_file_path)
-
-          File.open(gradle_file_path, 'r') do |f|
+          File.open(build_gradle_path, 'r') do |f|
             text = f.read
             text.match(/^\s*(?:\w*\.)?#{Regexp.escape(import_key)}\s*=\s*['"](.*?)["']/m)&.captures&.first
           end
@@ -456,19 +454,6 @@ module Fastlane
           return nil
         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"
@@ -477,12 +462,11 @@ module Fastlane
         # @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
+        def self.update_version(version, section, build_gradle_path:)
           temp_file = Tempfile.new('fastlaneIncrementVersion')
           found_section = false
           version_updated = 0
-          File.open(gradle_path, 'r') do |file|
+          File.open(build_gradle_path, 'r') do |file|
             file.each_line do |line|
               if found_section
                 if version_updated < 2
@@ -508,7 +492,7 @@ module Fastlane
           end
           temp_file.rewind
           temp_file.close
-          FileUtils.mv(temp_file.path, gradle_path)
+          FileUtils.mv(temp_file.path, build_gradle_path)
           temp_file.unlink
         end
       end

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

@@ -0,0 +1,46 @@
+module Fastlane
+  module Helper
+    # A helper class to store deprecated methods and actions
+    class Deprecated
+      # Creates a project_root_folder Fastlane ConfigItem
+      #
+      # @return [FastlaneCore::ConfigItem] The Fastlane ConfigItem for the `PROJECT_ROOT_FOLDER` environment variable
+      #
+      def self.project_root_folder_config_item
+        verify_block = proc do
+          UI.deprecated('DEPRECATED: The PROJECT_ROOT_FOLDER environment variable and config item are deprecated and will be removed in a future version of the Release Toolkit. Please provide a full path instead.')
+        end
+
+        FastlaneCore::ConfigItem.new(
+          key: :project_root_folder,
+          env_name: 'PROJECT_ROOT_FOLDER',
+          description: 'The path to the project root folder',
+          deprecated: true,
+          optional: true,
+          verify_block: verify_block,
+          type: String
+        )
+      end
+
+      # Creates a project_root_folder Fastlane ConfigItem
+      #
+      # @return [FastlaneCore::ConfigItem] The Fastlane ConfigItem for the `PROJECT_ROOT_FOLDER` environment variable
+      #
+      def self.project_name_config_item
+        verify_block = proc do
+          UI.deprecated('DEPRECATED: The PROJECT_NAME environment variable and config item are deprecated and will be removed in a future version of the Release Toolkit. Please provide a full path instead.')
+        end
+
+        FastlaneCore::ConfigItem.new(
+          key: :project_name,
+          env_name: 'PROJECT_NAME',
+          description: 'The app project name',
+          deprecated: true,
+          optional: true,
+          verify_block: verify_block,
+          type: String
+        )
+      end
+    end
+  end
+end

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

@@ -244,11 +244,20 @@ module Fastlane
       #
       # @param [String] repository The repository name (including the organization)
       # @param [String] branch The branch name
-      # @param [Hash] options A customizable set of options.
-      # @see https://docs.github.com/en/rest/branches/branch-protection#update-branch-protection
+      # @see https://docs.github.com/en/rest/branches/branch-protection#delete-branch-protection
+      #
+      def remove_branch_protection(repository:, branch:)
+        client.unprotect_branch(repository, branch)
+      end
+
+      # Get the list of branch protection settings for a given branch of a repository
       #
-      def remove_branch_protection(repository:, branch:, **options)
-        client.unprotect_branch(repository, branch, options)
+      # @param [String] repository The repository name (including the organization)
+      # @param [String] branch The branch name
+      # @see https://docs.github.com/en/rest/branches/branch-protection#get-branch-protection
+      #
+      def get_branch_protection(repository:, branch:, **options)
+        client.branch_protection(repository, branch)
       end
 
       # Protects a single branch from a repository
@@ -262,6 +271,42 @@ module Fastlane
         client.protect_branch(repository, branch, options)
       end
 
+      # Convert a response from the `/branch-protection` API endpoint into a Hash
+      # suitable to be returned and/or reused to pass to a subsequent `/branch-protection` API request
+      # @param [Sawyer::Resource] response The API response returned by `#get_branch_protection` or `#set_branch_protection`
+      # @return [Hash] A hash representation of the API response—or an empty Hash if `response` was `nil`—
+      #                with Boolean values normalized to true/false, and any extra values that would be refused
+      #                if used in a subsequent API request (like legacy vs new key) removed.
+      # @see https://docs.github.com/en/rest/branches/branch-protection
+      #
+      def self.branch_protection_api_response_to_normalized_hash(response)
+        return {} if response.nil?
+
+        normalize_values = lambda do |hash|
+          hash.each do |k, v|
+            # Boolean values appear as { "enabled" => true/false } in the Response, while they must appear as true/false in Request
+            hash[k] = v[:enabled] if v.is_a?(Hash) && v.key?(:enabled)
+            # References to :users, :teams and :apps are expanded as Objects in the Response, while they must just be the login or slug in Request
+            hash[k] = v.map { |item| item[:login] } if k == :users && v.is_a?(Array)
+            hash[k] = v.map { |item| item[:slug] } if %i[teams apps].include?(k) && v.is_a?(Array)
+            # Response contains lots of `*url` keys that are useless in practice and makes the returned hash harder to parse visually
+            hash.delete(k) if k.to_s == 'url' || k.to_s.end_with?('_url')
+
+            # Recurse into Hashes and Array of Hashes
+            normalize_values.call(v) if v.is_a?(Hash)
+            v.each { |item| normalize_values.call(item) if item.is_a?(Hash) } if v.is_a?(Array)
+          end
+        end
+
+        hash = response.to_hash
+        normalize_values.call(hash)
+
+        # Response contains both (legacy) `:contexts` key and new `:checks` key, but only one of the two should be passed in Request
+        hash[:required_status_checks].delete(:contexts) unless hash.dig(:required_status_checks, :checks).nil?
+
+        hash
+      end
+
       # Creates a GithubToken Fastlane ConfigItem
       #
       # @return [FastlaneCore::ConfigItem] The Fastlane ConfigItem for GitHub OAuth access token

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

@@ -0,0 +1,36 @@
+module Fastlane
+  module Models
+    # The AppVersion model represents a version of an app with major, minor, patch, and build number components.
+    class AppVersion
+      attr_accessor :major, :minor, :patch, :build_number
+
+      # Initializes a new AppVersion instance.
+      #
+      # @param [Integer] major The major version number.
+      # @param [Integer] minor The minor version number.
+      # @param [Integer] patch The patch version number.
+      # @param [Integer] build_number The build number.
+      #
+      def initialize(major, minor, patch = 0, build_number = 0)
+        # Validate that the major and minor version numbers are not nil
+        UI.user_error!('Major version cannot be nil') if major.nil?
+        UI.user_error!('Minor version cannot be nil') if minor.nil?
+
+        @major = major
+        @minor = minor
+        @patch = patch
+        @build_number = build_number
+      end
+
+      # Converts the AppVersion object to a string representation.
+      # This should only be used for internal debugging/testing purposes, not to write versions in version files
+      # In order to format an `AppVersion` into a `String`, you should use the appropriate `VersionFormatter` for your project instead.
+      #
+      # @return [String] a string in the format "major.minor.patch.build_number".
+      #
+      def to_s
+        "#{@major}.#{@minor}.#{@patch}.#{@build_number}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fastlane
+  module Models
+    # The `BuildCode` model represents a build code for an app. This could be the Version Code for an Android app or
+    # the VERSION_LONG/BUILD_NUMBER for an iOS/Mac app.
+    class BuildCode
+      attr_accessor :build_code
+
+      # Initializes a new BuildCode instance with the provided build code value.
+      #
+      # @param build_code [String] The build code value.
+      #
+      def initialize(build_code)
+        UI.user_error!('Build code cannot be nil') if build_code.nil?
+
+        @build_code = build_code
+      end
+
+      # Returns the build code as a string.
+      #
+      # @return [String] The build code represented as a string.
+      #
+      def to_s
+        @build_code.to_s
+      end
+    end
+  end
+end

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

@@ -2,6 +2,6 @@
 
 module Fastlane
   module Wpmreleasetoolkit
-    VERSION = '9.0.1'
+    VERSION = '9.2.0'
   end
 end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/abstract_version_calculator.rb

@@ -0,0 +1,85 @@
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `AbstractVersionCalculator` class is responsible for performing version calculations and transformations. It can be used
+      # as a base class for version calculations that use different versioning schemes. It contains calculation and
+      # transformation methods that are shared by all platforms. It has the abstract suffix because it should not be
+      # instantiated directly.
+      class AbstractVersionCalculator
+        # This method increments the major version component and resets minor, patch, and build number
+        # components to zero.
+        #
+        # @param version [AppVersion] The version to calculate the next major version for.
+        #
+        # @return [AppVersion] The next major version.
+        #
+        def next_major_version(version:)
+          new_version = version.dup
+          new_version.major += 1
+          new_version.minor = 0
+          new_version.patch = 0
+          new_version.build_number = 0
+
+          new_version
+        end
+
+        # This method increments the minor version component and resets patch and build number components
+        # to zero.
+        #
+        # @param version [AppVersion] The version to calculate the next minor version for.
+        #
+        # @return [AppVersion] The next minor version.
+        #
+        def next_minor_version(version:)
+          new_version = version.dup
+          new_version.minor += 1
+          new_version.patch = 0
+          new_version.build_number = 0
+
+          new_version
+        end
+
+        # This method increments the patch version component and resets the build number component to zero.
+        #
+        # @param version [AppVersion] The version to calculate the next patch version for.
+        #
+        # @return [AppVersion] The next patch version.
+        #
+        def next_patch_version(version:)
+          new_version = version.dup
+          new_version.patch += 1
+          new_version.build_number = 0
+
+          new_version
+        end
+
+        # This method increments the build number component.
+        #
+        # @param version [AppVersion] The version to calculate the next build number for.
+        #
+        # @return [AppVersion] The next version with an incremented build number.
+        #
+        def next_build_number(version:)
+          new_version = version.dup
+          new_version.build_number += 1
+
+          new_version
+        end
+
+        # Calculate the previous patch version by decrementing the patch version if it's not zero.
+        #
+        # @param [AppVersion] version The version to calculate the previous patch version for.
+        #
+        # @return [AppVersion] The previous patch version.
+        #
+        def previous_patch_version(version:)
+          new_version = version.dup
+          new_version.patch -= 1 unless version.patch.zero?
+          new_version.build_number = 0
+
+          new_version
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/date_build_code_calculator.rb

@@ -0,0 +1,32 @@
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `DateBuildCodeCalculator` class is a build code calculator for apps that use date-based
+      # build codes.
+      class DateBuildCodeCalculator
+        # Calculate the next internal build code by setting the build number to the current date.
+        #
+        # @param [AppVersion] version The version to calculate the next internal version for.
+        #
+        # @return [AppVersion] The next version with the build number set to the current date.
+        #
+        def next_build_code(version:)
+          new_version = version.dup
+          new_version.build_number = today_date
+
+          new_version
+        end
+
+        private
+
+        # Get the current date in the format 'YYYYMMDD'.
+        #
+        # @return [String] The current date in 'YYYYMMDD' format.
+        #
+        def today_date
+          DateTime.now.strftime('%Y%m%d')
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/date_version_calculator.rb

@@ -0,0 +1,37 @@
+require_relative 'abstract_version_calculator'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `DateVersionCalculator` class is a specialized version calculator for date-based versions
+      # of an app, extending the `AbstractVersionCalculator` class.
+      class DateVersionCalculator < AbstractVersionCalculator
+        # Calculate the next date-based release version.
+        #
+        # If the current month is December, the method prompts the user to determine if the next
+        # release will be the first release of the next year. If so, it increments the major version
+        # and sets the minor version to 1, resetting the patch and build number components to zero.
+        # Otherwise, it calculates the next minor version.
+        #
+        # @param [AppVersion] version The version to calculate the next date-based release version for.
+        #
+        # @return [AppVersion] The next date-based release version.
+        #
+        def next_release_version(version:)
+          new_version = version.dup
+          first_release_of_year = FastlaneCore::UI.confirm('Is this release the first release of next year?') if Time.now.month == 12
+          if first_release_of_year
+            new_version.major += 1
+            new_version.minor = 1
+            new_version.patch = 0
+            new_version.build_number = 0
+
+            new_version
+          else
+            next_minor_version(version: version)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/marketing_version_calculator.rb

@@ -0,0 +1,26 @@
+require_relative 'abstract_version_calculator'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `MarketingVersionCalculator` class is a specialized version calculator for marketing versions
+      # of an app, extending the `AbstractVersionCalculator` class.
+      class MarketingVersionCalculator < AbstractVersionCalculator
+        # Calculate the next marketing release version.
+        #
+        # This method checks if the minor version is 9. If it is, it calculates the next major version.
+        # Otherwise, it calculates the next minor version. The patch and build number components are reset to zero.
+        #
+        # @param [AppVersion] version The version to calculate the next marketing release version for.
+        #
+        # @return [AppVersion] The next marketing release version.
+        #
+        def next_release_version(version:)
+          UI.user_error!('Marketing Versioning: The minor version cannot be greater than 9') if version.minor > 9
+
+          version.minor == 9 ? next_major_version(version: version) : next_minor_version(version: version)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/semantic_version_calculator.rb

@@ -0,0 +1,21 @@
+require_relative 'abstract_version_calculator'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `SemanticVersionCalculator` class is a specialized version calculator for semantic versions
+      # of an app, extending the `AbstractVersionCalculator` class.
+      class SemanticVersionCalculator < AbstractVersionCalculator
+        # Calculate the next semantic release version.
+        #
+        # @param [AppVersion] version The version to calculate the next semantic release version from.
+        #
+        # @return [AppVersion] The next semantic release version.
+        #
+        def next_release_version(version:)
+          next_minor_version(version: version)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/simple_build_code_calculator.rb

@@ -0,0 +1,22 @@
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `SimpleBuildCodeCalculator` class is a build code calculator for apps that use simple integer
+      # build codes.
+      class SimpleBuildCodeCalculator
+        # Calculate the next build code.
+        #
+        # This method increments the build code value by 1.
+        #
+        # @param [BuildCode] version The build code to increment.
+        #
+        # @return [BuildCode] The next build code.
+        #
+        def next_build_code(build_code:)
+          new_build_code = build_code.dup
+          new_build_code.build_code += 1
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/files/android_version_file.rb

@@ -0,0 +1,76 @@
+require 'java-properties'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `AndroidVersionFile` class takes in a version.properties file path and reads/writes values to/from the file.
+      class AndroidVersionFile
+        attr_reader :version_properties_path
+
+        # Initializes a new instance of AndroidVersionFile with the specified version.properties file path.
+        #
+        # @param [String] version_properties_path The path to the version.properties file.
+        #
+        def initialize(version_properties_path: 'version.properties')
+          UI.user_error!("version.properties not found at this path: #{version_properties_path}") unless File.exist?(version_properties_path)
+
+          @version_properties_path = version_properties_path
+        end
+
+        # Reads the version name from a version.properties file.
+        #
+        # @return [String] The version name read from the file.
+        #
+        # @raise [UI::Error] If the file_path is nil or the version name is not found.
+        #
+        def read_version_name
+          # Read the version name from the version.properties file
+          file_content = JavaProperties.load(version_properties_path)
+          version_name = file_content[:versionName]
+          UI.user_error!('Version name not found in version.properties') if version_name.nil?
+
+          version_name
+        end
+
+        # Reads the version code from a version.properties file.
+        #
+        # @param [String] file_path The path to the version.properties file.
+        #
+        # @return [BuildCode] An instance of `BuildCode` representing the version code read from the file.
+        #
+        # @raise [UI::Error] If the file_path is nil or the version code is not found.
+        #
+        def read_version_code
+          # Read the version code from the version.properties file
+          file_content = JavaProperties.load(version_properties_path)
+          version_code = file_content[:versionCode]
+          UI.user_error!('Version code not found in version.properties') if version_code.nil?
+
+          # Create a BuildCode object
+          Fastlane::Models::BuildCode.new(version_code.to_i)
+        end
+
+        # Writes the provided version name and version code to the version.properties file.
+        #
+        # @param [String] version_name The version name to write to the file.
+        # @param [String] version_code The version code to write to the file.
+        #
+        # @raise [UI::Error] If the version name or version code is nil.
+        #
+        def write_version(version_name:, version_code:)
+          # Create the version name and version code hash
+          version = {
+            versionName: version_name,
+            versionCode: version_code
+          }
+
+          # Write the version name and version code hash to the version.properties file
+          JavaProperties.write(
+            version,
+            version_properties_path
+          )
+        end
+      end
+    end
+  end
+end