fastlane-plugin-wpmreleasetoolkit 9.0.1 → 9.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 982e123d25f4bc8ee55dfc605e8e6873c0365d4d75f4eabce7884a4de01649e4
-  data.tar.gz: 462ba969f7790d6aabf6201e5bae1e4df4ac0512c8ef42955247a3319e891827
+  metadata.gz: e26f9a48b802c79f4ac19eafc0f3da18b717202ab42d01ca2b2735df4b4abd5d
+  data.tar.gz: ee567a664e7831629f4a0886fc574eec192ef214c47468211a99aa679e98685b
 SHA512:
-  metadata.gz: 10433f33f1af9890023113464a26c5ff5ed29df4388f11248d6afb5cd85bc83622d4511c4f8e4279cde75fbcaa0605f6487aee6267042fcdd897c3a0036404f6
-  data.tar.gz: ce0e3fc971589f2f5a750c23e2acf78ae4bba2637d133717d361ee3bc5778e6f37b5d3f1f2455c9a9024454e7f443d3ce27b5c034eea41de61aed72e422532ab
+  metadata.gz: 993ef98974907a12d687e1558f9134038bf9e746a24c98e35dec4d230c87971e3342cd485d398b80076a20d03626ae4bf3b4c8b09f8f4fed316fc4ec7dcd0f8c
+  data.tar.gz: 3c6bebdb6b77966315088ea774e9a9275035b35abf87fcbf53b3ddfdadcdbd604c59a3ea2fe0d63082a6e572ead59e96cef851c0ec3c8d6187ed6f36326fb6e4

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

@@ -0,0 +1,80 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class CopyBranchProtectionAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        from_branch = params[:from_branch]
+        to_branch = params[:to_branch]
+
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+
+        response = begin
+          github_helper.get_branch_protection(
+            repository: repository,
+            branch: from_branch
+          )
+        rescue Octokit::NotFound
+          UI.user_error!("Branch `#{from_branch}` of repository `#{repository}` was not found.")
+        end
+        UI.user_error!("Branch `#{from_branch}` does not have any branch protection set up.") if response.nil?
+        settings = Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(response)
+
+        response = begin
+          github_helper.set_branch_protection(
+            repository: repository,
+            branch: to_branch,
+            **settings
+          )
+        rescue Octokit::NotFound
+          UI.user_error!("Branch `#{to_branch}` of repository `#{repository}` was not found.")
+        end
+
+        Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(response)
+      end
+
+      def self.description
+        'Copies the branch protection settings of one branch onto another branch'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.return_value
+        'The hash corresponding to the response returned by the API request, and containing the applied protection settings'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       env_name: 'GHHELPER_REPOSITORY',
+                                       description: 'The remote path of the GH repository on which we work',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :from_branch,
+                                       env_name: 'GHHELPER_FROM_BRANCH',
+                                       description: 'The branch to copy the protection settings from',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :to_branch,
+                                       env_name: 'GHHELPER_TO_BRANCH',
+                                       description: 'The branch to copy the protection settings to',
+                                       optional: false,
+                                       type: String),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
+        ]
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/{removebranchprotection_action.rb → remove_branch_protection_action.rb}

@@ -3,42 +3,34 @@ require_relative '../../helper/github_helper'
 
 module Fastlane
   module Actions
-    class RemovebranchprotectionAction < Action
+    class RemoveBranchProtectionAction < Action
       def self.run(params)
         repository = params[:repository]
         branch_name = params[:branch]
 
-        branch_url = "https://api.github.com/repos/#{repository}/branches/#{branch_name}"
-        restrictions = { url: "#{branch_url}/protection/restrictions", users_url: "#{branch_url}/protection/restrictions/users", teams_url: "#{branch_url}/protection/restrictions/teams", users: [], teams: [] }
-        required_pull_request_reviews = { url: "#{branch_url}/protection/required_pull_request_reviews", dismiss_stale_reviews: false, require_code_owner_reviews: false }
-
         github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
         github_helper.remove_branch_protection(
           repository: repository,
-          branch: branch_name,
-          restrictions: restrictions,
-          enforce_admins: nil,
-          required_pull_request_reviews: required_pull_request_reviews
+          branch: branch_name
         )
+      rescue Octokit::NotFound
+        UI.user_error!("Branch `#{branch_name}` of repository `#{repository}` was not found.")
+      rescue Octokit::BranchNotProtected
+        UI.message("Note: Branch `#{branch_name}` was not protected in the first place.")
       end
 
       def self.description
-        "Removes the 'release branch' protection state for the specified branch"
+        'Removes the protection settings for the specified branch'
       end
 
-      def self.authors
-        ['Automattic']
+      def self.details
+        description
       end
 
       def self.return_value
         # If your method provides a return value, you can describe here what it does
       end
 
-      def self.details
-        # Optional:
-        "Sets the 'release branch' protection state for the specified branch"
-      end
-
       def self.available_options
         [
           FastlaneCore::ConfigItem.new(key: :repository,
@@ -55,9 +47,24 @@ module Fastlane
         ]
       end
 
+      def self.authors
+        ['Automattic']
+      end
+
       def self.is_supported?(platform)
         true
       end
     end
+
+    # For backwards compatibility
+    class RemovebranchprotectionAction < RemoveBranchProtectionAction
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        "This action has been renamed `#{superclass.action_name}`"
+      end
+    end
   end
 end

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

@@ -0,0 +1,153 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class SetBranchProtectionAction < Action
+      def self.run(params)
+        repository = params[:repository]
+        branch_name = params[:branch]
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+
+        settings = if params[:keep_existing_settings_unchanged]
+                     Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(
+                       github_helper.get_branch_protection(repository: repository, branch: branch_name)
+                     )
+                   else
+                     {}
+                   end
+
+        # `required_status_checks` field — only override existing `checks` subfield if param provided
+        unless params[:required_ci_checks].nil?
+          if params[:required_ci_checks].empty?
+            settings[:required_status_checks] = nil # explicitly completely delete existing check requirement
+          else
+            settings[:required_status_checks] ||= { strict: false }
+            settings[:required_status_checks][:checks] = params[:required_ci_checks].map { |ctx| { context: ctx } }
+          end
+        end
+
+        # `enforce_admins` field — only override existing value if param provided
+        if params[:enforce_admins].nil?
+          settings[:enforce_admins] ||= nil # parameter is required to be provided, even if nil (aka false) value
+        else
+          settings[:enforce_admins] = params[:enforce_admins]
+        end
+
+        # `required_pull_request_reviews` field — only override `required_approving_review_count` subfield if param provided
+        settings[:required_pull_request_reviews] ||= {
+          dismiss_stale_reviews: false,
+          require_code_owner_reviews: false
+        }
+        unless params[:required_approving_review_count].nil?
+          settings[:required_pull_request_reviews][:required_approving_review_count] = params[:required_approving_review_count]
+        end
+
+        # `restrictions` field
+        settings[:restrictions] ||= { users: [], teams: [] }
+
+        # `allow_force_pushes` field — only override existing value if param provided
+        unless params[:allow_force_pushes].nil?
+          settings[:allow_force_pushes] = params[:allow_force_pushes]
+        end
+
+        # `lock_branch` field — only override existing value if param provided
+        unless params[:lock_branch].nil?
+          settings[:lock_branch] = params[:lock_branch]
+        end
+
+        # API Call - See https://docs.github.com/en/rest/branches/branch-protection#update-branch-protection
+        response = github_helper.set_branch_protection(
+          repository: repository,
+          branch: branch_name,
+          **settings
+        )
+
+        Fastlane::Helper::GithubHelper.branch_protection_api_response_to_normalized_hash(response)
+      rescue Octokit::NotFound => e
+        UI.user_error!("Branch `#{branch_name}` of repository `#{repository}` was not found.\n#{e.message}")
+      end
+
+      def self.description
+        'Sets the protection state for the specified branch'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.return_value
+        'The hash corresponding to the response returned by the API request, and containing the applied protection settings'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository,
+                                       env_name: 'GHHELPER_REPOSITORY',
+                                       description: 'The slug of the GH repository on which we work',
+                                       optional: false,
+                                       type: String),
+          # NOTE: GitHub branch protection API doesn't allow wildcard characters for the branch parameter
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       env_name: 'GHHELPER_BRANCH',
+                                       description: 'The branch to protect',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :keep_existing_settings_unchanged,
+                                       description: 'If set to true, will only change the settings that are explicitly provided to the action, ' \
+                                       + 'while keeping the values of other existing protection settings (if any) unchanged. If false, it will ' \
+                                       + 'discard any existing branch protection setting if any before setting just the ones provided ' \
+                                       + '(and leaving the rest with default GitHub values)',
+                                       default_value: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :required_ci_checks,
+                                       description: 'If provided, specifies the list of CI status checks to mark as required. If not provided (nil), will keep existing ones',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :required_approving_review_count,
+                                       description: 'If not nil, change the number of approving reviews required to merge the PR. ' \
+                                       + 'Acceptable values are `nil` (do not change), 0 (disable) or a number between 1–6',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :enforce_admins,
+                                       description: 'If provided, will update the setting of whether admins can bypass restrictions (false) or not (true)',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :allow_force_pushes,
+                                       description: 'If provided, will update the setting of whether to allow force pushes on the branch',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :lock_branch,
+                                       description: 'If provided, will update the locked (aka readonly) state of the branch',
+                                       optional: true,
+                                       default_value: nil,
+                                       type: Boolean),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
+        ]
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+
+    # For backwards compatibility
+    class SetbranchprotectionAction < SetBranchProtectionAction
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        "This action has been renamed `#{superclass.action_name}`"
+      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.1.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

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

@@ -0,0 +1,64 @@
+require 'xcodeproj'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `IOSVersionFile` class takes in an .xcconfig file path and reads/writes values to/from the file.
+      class IOSVersionFile
+        attr_reader :xcconfig_path
+
+        # Initializes a new instance of IOSVersionFile with the specified .xcconfig file path.
+        #
+        # @param [String] xcconfig_path The path to the .xcconfig file.
+        #
+        def initialize(xcconfig_path:)
+          UI.user_error!(".xcconfig file not found at this path: #{xcconfig_path}") unless File.exist?(xcconfig_path)
+
+          @xcconfig_path = xcconfig_path
+        end
+
+        # Reads the release version from the .xcconfig file and returns it as a String.
+        #
+        # @return [String] The release version.
+        #
+        def read_release_version
+          config = Xcodeproj::Config.new(xcconfig_path)
+          config.attributes['VERSION_SHORT']
+        end
+
+        # Reads the build code from the .xcconfig file and returns it String.
+        #
+        # Some apps store the build code in the VERSION_LONG attribute, while others store it in the BUILD_NUMBER attribute.
+        #
+        # @param [String] attribute_name The name of the attribute to read.
+        #
+        # @return [String] The build code.
+        #
+        def read_build_code(attribute_name:)
+          UI.user_error!('attribute_name must be `VERSION_LONG` or `BUILD_NUMBER`') unless attribute_name.eql?('VERSION_LONG') || attribute_name.eql?('BUILD_NUMBER')
+
+          config = Xcodeproj::Config.new(xcconfig_path)
+          config.attributes[attribute_name]
+        end
+
+        # Writes the provided version numbers to the .xcconfig file.
+        #
+        # @param [String, nil] version_short The short version string (optional).
+        # @param [String, nil] version_long The long version string (optional).
+        # @param [String, nil] build_number The build number (optional).
+        #
+        # version_long is optional because there are times when it won't be updated, such as a new beta build.
+        # version_short is optional because some apps (such as Day One iOS/Mac or Simplenote Mac) don't use it.
+        # build_number is optional because some apps (such as WP/JP iOS or WCiOS) don't use it.
+        #
+        def write(version_short: nil, version_long: nil, build_number: nil)
+          config = Xcodeproj::Config.new(xcconfig_path)
+          config.attributes['VERSION_SHORT'] = version_short.to_s unless version_short.nil?
+          config.attributes['VERSION_LONG'] = version_long.to_s unless version_long.nil?
+          config.attributes['BUILD_NUMBER'] = build_number.to_s unless build_number.nil?
+          config.save_as(Pathname.new(xcconfig_path))
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/abstract_version_formatter.rb

@@ -0,0 +1,27 @@
+require_relative '../calculators/abstract_version_calculator'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `VersionFormatter` class is a generic version formatter that can be used as a base class
+      # for formatting version objects used by for different platforms. It contains formatting methods that
+      # are shared by all platforms. It has the abstract suffix because it should not be instantiated directly.
+      class AbstractVersionFormatter
+        # Get the release version string for the app.
+        #
+        # This method constructs the release version string based on the major, minor, and
+        # patch components of the provided `@version`. If the patch component is zero, it returns
+        # a version string in the format "major.minor" (e.g., '1.2'). Otherwise, it returns a
+        # version string in the format "major.minor.patch" (e.g., '1.2.3').
+        #
+        # @param [AppVersion] version The version object to format
+        #
+        # @return [String] The formatted release version string.
+        #
+        def release_version(version)
+          version.patch.zero? ? "#{version.major}.#{version.minor}" : "#{version.major}.#{version.minor}.#{version.patch}"
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/derived_build_code_formatter.rb

@@ -0,0 +1,33 @@
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `DerivedBuildCodeFormatter` class is a specialized build code formatter for derived build codes.
+      # It takes in an AppVersion object and derives a build code from it.
+      class DerivedBuildCodeFormatter
+        # Calculate the next derived build code.
+        #
+        # This method derives a new build code from the given AppVersion object by concatenating the digit 1,
+        # the major version, the minor version, the patch version, and the build number.
+        #
+        # @param [AppVersion] version The AppVersion object to derive the next build code from.
+        #
+        # @param [BuildCode] build_code A BuildCode object. This parameter is ignored but is included
+        # to have a consistent signature with other build code formatters.
+        #
+        # @return [String] The formatted build code string.
+        #
+        def build_code(build_code = nil, version:)
+          format(
+            # 1 is appended to the beginning of the string in case there needs to be additional platforms or
+            # extensions that could then use a different digit prefix such as 2, etc.
+            '1%<major>.2i%<minor>.2i%<patch>.2i%<build_number>.2i',
+            major: version.major,
+            minor: version.minor,
+            patch: version.patch,
+            build_number: version.build_number
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/four_part_build_code_formatter.rb

@@ -0,0 +1,22 @@
+require_relative '../formatters/four_part_version_formatter'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `FourPartBuildCodeFormatter` is a specialized build code formatter for apps that use
+      # build codes in the format of `major.minor.patch.build_number`.
+      class FourPartBuildCodeFormatter
+        # @param [AppVersion] version The AppVersion object to format
+        #
+        # @param [BuildCode] build_code A BuildCode object. This parameter is ignored but is included
+        # to have a consistent signature with other build code formatters.
+        #
+        # @return [String] The formatted build code string.
+        #
+        def build_code(build_code = nil, version:)
+          FourPartVersionFormatter.new.to_s(version)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/four_part_version_formatter.rb

@@ -0,0 +1,35 @@
+require_relative 'abstract_version_formatter'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `FourPartVersionFormatter` class  extends the `VersionFormatter` class. It is a specialized version formatter for
+      # apps that use versions in the format of `1.2.3.4`.
+      class FourPartVersionFormatter < AbstractVersionFormatter
+        # Parse the version string into an AppVersion instance
+        #
+        # @param [String] version The version string to parse
+        #
+        # @return [AppVersion] The parsed version
+        #
+        def parse(version)
+          # Split the version string into its components
+          components = version.split('.').map(&:to_i)
+
+          # Create a new AppVersion instance from the version string components
+          Fastlane::Models::AppVersion.new(*components)
+        end
+
+        # Return the formatted version string
+        #
+        # @param [AppVersion] version The version object to format
+        #
+        # @return [String] The formatted version string
+        #
+        def to_s(version)
+          "#{version.major}.#{version.minor}.#{version.patch}.#{version.build_number}"
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/rc_notation_version_formatter.rb

@@ -0,0 +1,65 @@
+require_relative 'abstract_version_formatter'
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `RCNotationVersionFormatter` class extends the `VersionFormatter` class. It is a specialized version
+      # formatter for apps that may use versions in the format of `1.2.3-rc-4`.
+      class RCNotationVersionFormatter < AbstractVersionFormatter
+        # The string identifier used for beta versions in Android.
+        RC_SUFFIX = 'rc'.freeze
+
+        # Parse the version string into an AppVersion instance
+        #
+        # @param [String] version_name The version string to parse
+        #
+        # @return [AppVersion] The parsed version
+        #
+        def parse(version_name)
+          # Set the build number to 0 by default so that it will be set correctly for non-beta version numbers
+          build_number = 0
+
+          if version_name.include?(RC_SUFFIX)
+            # Extract the build number from the version name
+            build_number = version_name.split('-')[2].to_i
+            # Extract the version name without the build number and drop the RC suffix
+            version_name = version_name.split(RC_SUFFIX)[0]
+          end
+
+          # Split the version name into its components
+          version_number_parts = version_name.split('.').map(&:to_i)
+          # Fill the array with 0 if needed to ensure array has at least 3 components
+          version_number_parts.fill(0, version_number_parts.length...3)
+
+          # Map version_number_parts to AppVersion model
+          major = version_number_parts[0]
+          minor = version_number_parts[1]
+          patch = version_number_parts[2]
+
+          # Create an AppVersion object
+          Fastlane::Models::AppVersion.new(major, minor, patch, build_number)
+        end
+
+        # Get the formatted beta version of the Android app
+        #
+        # This method constructs a beta version string by combining the release version
+        # with the beta identifier and the build number. It ensures that the build number is
+        # 1 or higher, as beta versions must have a build number greater than or equal to 1.
+        #
+        # @param [AppVersion] version The version object to format
+        #
+        # @return [String] The formatted beta version of the Android app
+        #
+        # @raise [UI::Error] If the build number of the beta version is not 1 or higher
+        #
+        def beta_version(version)
+          # Ensure that the build number is 1 or higher for a beta version
+          UI.user_error!('The build number of a beta version must be 1 or higher') unless version.build_number.positive?
+
+          # Construct and return the formatted beta version string.
+          "#{release_version(version)}-#{RC_SUFFIX}-#{version.build_number}"
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/simple_build_code_formatter.rb

@@ -0,0 +1,20 @@
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # The `IntegerBuildCodeFormatter` is a specialized build code formatter for apps that use simple
+      # integer build codes in the format of `build_number`.
+      class SimpleBuildCodeFormatter
+        # @param version [AppVersion] An AppVersion object. This parameter is ignored but is included
+        # to have a consistent signature with other build code formatters.
+        #
+        # @param [BuildCode] build_code The BuildCode object to format
+        #
+        # @return [String] The formatted build code string.
+        #
+        def build_code(version = nil, build_code:)
+          build_code.to_s
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit.rb

@@ -4,7 +4,7 @@ module Fastlane
   module Wpmreleasetoolkit
     # Return all .rb files inside the "actions", "helper" and "models" directories
     def self.all_classes
-      Dir[File.expand_path('**/{actions,helper,models}/**/*.rb', File.dirname(__FILE__))]
+      Dir[File.expand_path('**/{actions,helper,models,versioning}/**/*.rb', File.dirname(__FILE__))]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 9.0.1
+  version: 9.1.0
 platform: ruby
 authors:
 - Automattic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-05 00:00:00.000000000 Z
+date: 2023-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: java-properties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -426,6 +440,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/circleci_trigger_job_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/close_milestone_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/comment_on_pr.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/copy_branch_protection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_new_milestone_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_release_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/extract_release_notes_for_version_action.rb
@@ -436,8 +451,8 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/gp_update_metadata_source.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/promo_screenshots_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/prototype_build_details_comment_action.rb
-- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/removebranchprotection_action.rb
-- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/setbranchprotection_action.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/remove_branch_protection_action.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/set_branch_protection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/setfrozentag_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_to_s3.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/configure/configure_add_files_to_copy_action.rb
@@ -506,6 +521,8 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/promo_screenshots_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/release_notes_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/user_agent.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/models/app_version.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/models/build_code.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/models/configuration.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/models/file_reference.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/models/firebase_account.rb
@@ -513,6 +530,20 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/models/firebase_test_lab_result.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/models/firebase_test_runner.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/version.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/abstract_version_calculator.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/date_build_code_calculator.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/date_version_calculator.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/marketing_version_calculator.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/semantic_version_calculator.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/calculators/simple_build_code_calculator.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/files/android_version_file.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/files/ios_version_file.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/abstract_version_formatter.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/derived_build_code_formatter.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/four_part_build_code_formatter.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/four_part_version_formatter.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/rc_notation_version_formatter.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/simple_build_code_formatter.rb
 homepage: https://github.com/wordpress-mobile/release-toolkit
 licenses:
 - MIT

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

@@ -1,63 +0,0 @@
-require 'fastlane/action'
-require_relative '../../helper/github_helper'
-
-module Fastlane
-  module Actions
-    class SetbranchprotectionAction < Action
-      def self.run(params)
-        repository = params[:repository]
-        branch_name = params[:branch]
-
-        branch_url = "https://api.github.com/repos/#{repository}/branches/#{branch_name}"
-        restrictions = { url: "#{branch_url}/protection/restrictions", users_url: "#{branch_url}/protection/restrictions/users", teams_url: "#{branch_url}/protection/restrictions/teams", users: [], teams: [] }
-        required_pull_request_reviews = { url: "#{branch_url}/protection/required_pull_request_reviews", dismiss_stale_reviews: false, require_code_owner_reviews: false }
-
-        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
-        github_helper.set_branch_protection(
-          repository: repository,
-          branch: branch_name,
-          restrictions: restrictions,
-          enforce_admins: nil,
-          required_pull_request_reviews: required_pull_request_reviews
-        )
-      end
-
-      def self.description
-        "Sets the 'release branch' protection state for the specified branch"
-      end
-
-      def self.authors
-        ['Automattic']
-      end
-
-      def self.return_value
-        # If your method provides a return value, you can describe here what it does
-      end
-
-      def self.details
-        # Optional:
-        "Sets the 'release branch' protection state for the specified branch"
-      end
-
-      def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(key: :repository,
-                                       env_name: 'GHHELPER_REPOSITORY',
-                                       description: 'The remote path of the GH repository on which we work',
-                                       optional: false,
-                                       type: String),
-          FastlaneCore::ConfigItem.new(key: :branch,
-                                       env_name: 'GHHELPER_BRANCH',
-                                       description: 'The branch to protect',
-                                       optional: false,
-                                       type: String),
-          Fastlane::Helper::GithubHelper.github_token_config_item,
-        ]
-      end
-
-      def self.is_supported?(platform)
-        true
-      end
-    end
-  end
-end