fastlane-plugin-wpmreleasetoolkit 9.0.0 → 9.1.0

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.0'
+    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