version_boss 0.1.0

data/lib/version_boss/gem/command_line.rb

@@ -0,0 +1,443 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module VersionBoss
+  module Gem
+    # rubocop:disable Metrics/ClassLength
+
+    # The version_boss cli
+    #
+    # @example
+    #   require 'version_boss'
+    #
+    #   VersionBoss::CommandLine.start(ARGV)
+    #
+    # @api private
+    #
+    class CommandLine < Thor
+      # Tell Thor to exit with a non-zero status code if a command fails
+      def self.exit_on_failure? = true
+
+      desc 'current [-q]', 'Show the current gem version'
+
+      long_desc <<-LONG_DESC
+      Output the current gem version from the file that stores the gem version.
+
+      The command fails if the gem version could not be found or is invalid.
+
+      Use `--quiet` to ensure that a gem version could be found and is valid without producing any output.
+      LONG_DESC
+
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the current version to stdout'
+
+      # Show the current gem version
+      # @return [void]
+      def current
+        version_file = VersionBoss::Gem::VersionFileFactory.find
+
+        if version_file.nil?
+          warn 'version file not found or is not valid' unless options[:quiet]
+          exit 1
+        end
+
+        puts version_file.version unless options[:quiet]
+      end
+
+      desc 'file [-q]', 'Show the path to the file containing the gem version'
+
+      long_desc <<-LONG_DESC
+      Output the relative path to the file that stores the gem version.
+
+      The command fails if the gem version could not be found.
+
+      Use `--quiet` to ensure that a gem version could be found without producing any output.
+      LONG_DESC
+
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the version file path to stdout'
+
+      # Show the gem's version file
+      # @return [void]
+      def file
+        version_file = VersionBoss::Gem::VersionFileFactory.find
+
+        if version_file.nil?
+          warn 'version file not found or is not valid' unless options[:quiet]
+          exit 1
+        end
+
+        puts version_file.path unless options[:quiet]
+      end
+
+      desc 'next-major [VERSION] [-p [-t TYPE]] [-n] [-q]', "Increment the version's major part"
+
+      long_desc <<-LONG_DESC
+      Increase the current gem version to the next major version, update the
+      file that stores the version, and output the resulting version to stdout.
+
+      Increments 1.x.y to 2.0.0.
+
+      The command fails if the current gem version file could not be found or
+      if the version is not valid.
+
+      If VERSION is given, use that instead of the current gem version. Giving
+      VERSION implies --dry-run. The command fails if VERSION is not valid.
+
+      --pre can be used to specify that the version should be incremented AND
+      given a pre-release part. For instance:
+
+      $ version_boss next-major --pre
+
+      increments '1.2.3' to '2.0.0.pre.1'.
+
+      By default, the pre-release type is 'pre'. --pre-type=TYPE can be used with
+      --pre to specify a different pre-release type such as alpha, beta, rc, etc.
+      For instance:
+
+      $ version_boss next-major --pre --pre-type=alpha
+
+      increments '1.2.3' to '2.0.0-alpha.1'.
+
+      The command fails if the existing pre-release type is not lexically less than or
+      equal to TYPE. For example, it the current version is '1.2.3-beta.1' and TYPE
+      is 'alpha', the the command will fail since the new version would sort before the
+      existing version ('beta' is not less than or equal to 'alpha').
+
+      Use --dry-run to run this command without updating the version file.
+
+      Use --quiet to increment the version without producing any output.
+      LONG_DESC
+
+      option :pre, type: :boolean, aliases: '-p', desc: 'Create a pre-release version'
+      option :'pre-type', type: :string, aliases: '-t', default: 'pre', banner: 'TYPE',
+                          desc: 'The type of pre-release version (alpha, beta, etc.)'
+      option :'dry-run', type: :boolean, aliases: '-n', desc: 'Do not write the new version to the version file'
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the new version to stdout'
+
+      # Increment the gem version's major part
+      # @param version [String, nil] The version to increment or nil to use the version
+      #   from the gem's version file
+      # @return [void]
+      def next_major(version = nil)
+        increment_core_version(:next_major, version)
+      end
+
+      desc 'next-minor [VERSION] [-p [-t TYPE]] [-n] [-q]', "Increment the version's minor part"
+
+      long_desc <<-LONG_DESC
+      Increase the current gem version to the next minor version, update the
+      file that stores the version, and output the resulting version to stdout.
+
+      Increments 1.2.y to 1.3.0.
+
+      The command fails if the current gem version file could not be found or
+      if the version is not valid.
+
+      If VERSION is given, use that instead of the current gem version. Giving
+      VERSION implies --dry-run. The command fails if VERSION is not valid.
+
+      --pre can be used to specify that the version should be incremented AND
+      given a pre-release part. For instance:
+
+      $ version_boss next-minor --pre
+
+      increments '1.2.3' to '2.0.0.pre.1'.
+
+      By default, the pre-release type is 'pre'. --pre-type=TYPE can be used with
+      --pre to specify a different pre-release type such as alpha, beta, rc, etc.
+      For instance:
+
+      $ version_boss next-patch --pre --pre-type=alpha
+
+      increments '1.2.3' to '1.2.4-alpha.1'.
+
+      The command fails if the existing pre-release type is not lexically less than or
+      equal to TYPE. For example, it the current version is '1.2.3-beta.1' and TYPE
+      is 'alpha', the the command will fail since the new version would sort before the
+      existing version ('beta' is not less than or equal to 'alpha').
+
+      Use --dry-run to run this command without updating the version file.
+
+      Use --quiet to increment the version without producing any output.
+      LONG_DESC
+
+      option :pre, type: :boolean, aliases: '-p', desc: 'Create a pre-release version'
+      option :'pre-type', type: :string, aliases: '-t', default: 'pre', banner: 'TYPE',
+                          desc: 'The type of pre-release version (alpha, beta, etc.)'
+      option :'dry-run', type: :boolean, aliases: '-n', desc: 'Do not write the new version to the version file'
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the new version to stdout'
+
+      # Increment the gem version's minor part
+      # @param version [String, nil] The version to increment or nil to use the version
+      #   from the gem's version file
+      # @return [void]
+      def next_minor(version = nil)
+        increment_core_version(:next_minor, version)
+      end
+
+      desc 'next-patch [VERSION] [-p [-t TYPE]] [-n] [-q]', "Increment the version's patch part"
+
+      long_desc <<-LONG_DESC
+      Increase the current gem version to the next patch version, update the
+      file that stores the version, and output the resulting version to stdout.
+
+      Increments 1.2.3 to 1.2.4.
+
+      The command fails if the current gem version file could not be found or
+      if the version is not valid.
+
+      If VERSION is given, use that instead of the current gem version. Giving
+      VERSION implies --dry-run. The command fails if VERSION is not valid.
+
+      --pre can be used to specify that the version should be incremented AND
+      given a pre-release part. For instance:
+
+      $ version_boss next-patch --pre
+
+      increments '1.2.3' to '1.2.4.pre.1'.
+
+      By default, the pre-release type is 'pre'. --pre-type=TYPE can be used with
+      --pre to specify a different pre-release type such as alpha, beta, rc, etc.
+      For instance:
+
+      $ version_boss next-patch --pre --pre-type=alpha
+
+      increments '1.2.3' to '1.2.4-alpha.1'.
+
+      The command fails if the existing pre-release type is not lexically less than or
+      equal to TYPE. For example, it the current version is '1.2.3-beta.1' and TYPE
+      is 'alpha', the the command will fail since the new version would sort before the
+      existing version ('beta' is not less than or equal to 'alpha').
+
+      Use --dry-run to run this command without updating the version file.
+
+      Use --quiet to increment the version without producing any output.
+      LONG_DESC
+
+      option :pre, type: :boolean, aliases: '-p', desc: 'Create a pre-release version'
+      option :'pre-type', type: :string, aliases: '-t', default: 'pre', banner: 'TYPE',
+                          desc: 'The type of pre-release version (alpha, beta, etc.)'
+      option :'dry-run', type: :boolean, aliases: '-n', desc: 'Do not write the new version to the version file'
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the new version to stdout'
+
+      # Increment the gem version's patch part
+      # @param version [String, nil] The version to increment or nil to use the version
+      #   from the gem's version file
+      # @return [void]
+      def next_patch(version = nil)
+        increment_core_version(:next_patch, version)
+      end
+
+      desc 'next-pre [VERSION] [-t TYPE] [-n] [-q]', "Increment the version's pre-release part"
+
+      long_desc <<-LONG_DESC
+      Increase the current gem version to the next pre-release version, update the
+      file that stores the version, and output the resulting version to stdout.
+
+      The command fails if  the current gem version file could not be found or
+      the version is not a valid pre-release version.
+
+      If VERSION is given, use that instead of the current gem version. Giving
+      VERSION implies --dry-run. The command fails if VERSION is not a valid
+      pre-release version.
+
+      By default, the existing pre-release type is preserved. For instance:
+
+      $ version_boss next-pre
+
+      Increments 1.2.3-alpha.1 to 1.2.3-alpha.2.
+
+      --pre-type=TYPE can be used to change the pre-release type to TYPE (typical
+      examples include alpha, beta, rc, etc.). If the pre-release type is changed,
+      the pre-release number is reset to 1.
+
+      For example, if the version starts as 1.2.3-alpha.4, then:
+
+      $ version_boss current
+      1.2.3-alpha.4
+      $ semver next-pre --pre-type=beta
+      1.2.3-beta.1
+      $ semver next-pre --pre-type=beta
+      1.2.3-beta.2
+      $ semver next-pre --pre-type=rc
+      1.2.3-rc.1
+      $ version_boss next-release
+      1.2.3
+
+      The command fails if the existing pre-release type is not lexically less than or
+      equal to TYPE. For example, it the current version is '1.2.3-beta.1' and the TYPE
+      given type is 'alpha', then the command will fail since the new version would sort
+      before the existing version (since 'beta' is not <= 'alpha').
+
+      Use --dry-run to run this command without updating the version file.
+
+      Use --quiet to increment the version without producing any output.
+      LONG_DESC
+
+      option :'pre-type', type: :string, aliases: '-t', banner: 'TYPE',
+                          desc: 'The type of pre-release version (alpha, beta, etc.)'
+      option :'dry-run', type: :boolean, aliases: '-n', desc: 'Do not write the new version to the version file'
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the new version to stdout'
+
+      # Increment the gem version's pre-release part
+      # @param version [String, nil] The version to increment or nil to use the version
+      #   from the gem's version file
+      # @return [void]
+      def next_pre(version = nil)
+        args = {}
+        args[:pre_type] = options[:'pre-type'] if options[:'pre-type']
+
+        new_version = increment_version(:next_pre, args, version)
+
+        puts new_version unless options[:quiet]
+      end
+
+      desc 'next-release [VERSION] [-n] [-q]', 'Increment a pre-release version to the release version'
+
+      long_desc <<-LONG_DESC
+      Increase the current gem version to the next release version, update the
+      file that stores the version, and output the resulting version to stdout.
+
+      Increments 1.2.3-rc.4 to 1.2.3.
+
+      The command fails if the current gem version file could not be found or
+      the version is not a valid pre-release version.
+
+      If VERSION is given, use that instead of the current gem version. Giving
+      VERSION implies --dry-run. The command fails if VERSION is not a valid
+      pre-release version.
+
+      Use --dry-run to run this command without updating the version file.
+
+      Use --quiet to increment the version without producing any output.
+      LONG_DESC
+
+      option :'dry-run', type: :boolean, aliases: '-n', desc: 'Do not write the new version to the version file'
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the new version to stdout'
+
+      # Increment the gem's pre-release version to a release version
+      # @param version [String, nil] The version to increment or nil to use the version
+      #   from the gem's version file
+      # @return [void]
+      def next_release(version = nil)
+        args = {}
+        new_version = increment_version(:next_release, args, version)
+
+        puts new_version unless options[:quiet]
+      end
+
+      desc 'validate VERSION [-q]', 'Validate the given version'
+
+      long_desc <<-LONG_DESC
+      Validate and output the given gem version.
+
+      The command fails if the gem version is not valid.
+
+      Use `--quiet` to validate the gem version without producing any output.
+      LONG_DESC
+
+      option :quiet, type: :boolean, aliases: '-q', desc: 'Do not print the given version to stdout'
+
+      # Validate that the give version is a valid IncrementableSemver version
+      # @param version [String] The version to validate
+      # @return [void]
+      #
+      def validate(version)
+        VersionBoss::Gem::IncrementableVersion.new(version)
+      rescue VersionBoss::Error => e
+        warn e.message unless options[:quiet]
+        exit 1
+      else
+        puts version unless options[:quiet]
+      end
+
+      private
+
+      # Build a hash of arguments to pass to the IncrementableSemver methods
+      #
+      # These arguments are specificly for the #next_major, #next_minor, and
+      # #next_patch method.
+      #
+      # @return [Hash]
+      #
+      def core_args
+        {}.tap do |args|
+          args[:pre] = options[:pre] if options[:pre]
+          args[:pre_type] = options[:'pre-type'] if options[:'pre-type']
+        end
+      end
+
+      # Increment the gem's major, minor, or patch version
+      #
+      # @param method [Symbol] The method to call on the IncrementableSemver object
+      # @param version [String, nil] The version to increment or nil to use the version
+      #  from the gem's version file
+      #
+      # @return [Void]
+      #
+      def increment_core_version(method, version)
+        new_version = increment_version(method, core_args, version)
+
+        puts new_version unless options[:quiet]
+      end
+
+      # Increment the gem's version
+      #
+      # @param method [Symbol] The method to call on the IncrementableSemver object
+      #
+      #   The method can bee one of: :next_major, :next_minor, :next_patch, :next_pre, :next_release
+      #
+      # @param args [Hash] The arguments to pass to the method
+      #
+      # @param version [String, nil] The version to increment or nil to use the version
+      #
+      # @return [Void]
+      #
+      def increment_version(method, args, version)
+        if version
+          increment_literal_version(method, args, version)
+        else
+          increment_gem_version(method, args)
+        end
+      rescue VersionBoss::Error => e
+        warn e.message unless options[:quiet]
+        exit 1
+      end
+
+      # Increment a literal version from a string
+      #
+      # @param method [Symbol] The method to call on the IncrementableSemver object
+      # @param args [Hash] The arguments to pass to the method
+      # @param version [String] The version to increment
+      #
+      # @return [VersionBoss::IncrementableRubyVersion] the incremented version
+      # @raise [VersionBoss::Error] if the version is not a valid IncrementableSemver version
+      #
+      def increment_literal_version(method, args, version)
+        VersionBoss::Gem::IncrementableVersion.new(version).send(method, **args)
+      end
+
+      # Increment the gem's version from the gem's version file
+      #
+      # @param method [Symbol] The method to call on the IncrementableSemver object
+      # @param args [Hash] The arguments to pass to the method
+      #
+      # @return [VersionBoss::IncrementableRubyVersion] the incremented version
+      # @raise [VersionBoss::Error] if the version is not a valid IncrementableSemver version
+      #
+      def increment_gem_version(method, args)
+        version_file = VersionBoss::Gem::VersionFileFactory.find
+
+        if version_file.nil?
+          warn 'version file not found or is not valid' unless options[:quiet]
+          exit 1
+        end
+
+        version_file&.version.send(method, **args).tap do |new_version|
+          version_file.version = new_version unless options[:'dry-run']
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/version_boss/gem/incrementable_version.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+
+module VersionBoss
+  module Gem
+    # A VersionBoss::Semver with additional constraints on the pre-release part of the version
+    #
+    # A IncrementableVersion is valid if one of the two following conditions is met:
+    #   1. The pre-release part is empty
+    #   2. The pre-release part is composed of two dot-separated identifiers:
+    #     * the first being a String representing the pre-release type (e.g. 'alpha',
+    #       'beta', etc.). The default pre-release type is 'pre'
+    #     * the second being an Integer representing the pre-release sequence number
+    #       (starting at 1)
+    #
+    # Valid versions with pre-release parts: `1.2.3.alpha.1`, `1.2.3.beta.2`, `1.2.3.pre.3`
+    #
+    # @api public
+    #
+    class IncrementableVersion < Version
+      # Create a new IncrementableVersion object
+      #
+      # @example
+      #   VersionBoss::Semver.new('1.2.3').valid? # => true
+      #   VersionBoss::Semver.new('1.2.3-alpha.1+build.001').valid? # => true
+      #   VersionBoss::Semver.new('1.2.3-alpha').valid? # => raise VersionBoss::Error
+      #   VersionBoss::Semver.new('1.2.3-alpha.1.2').valid? # => raise VersionBoss::Error
+      #   VersionBoss::Semver.new('1.2.3-alpha.one').valid? # => raise VersionBoss::Error
+      #
+      # @return [Boolean] true if the version string is a valid semver and meets the conditions above
+      #
+      def valid?
+        super && (
+          pre_release.empty? ||
+          (
+            pre_release_identifiers.size == 2 &&
+            pre_type.is_a?(String) &&
+            pre_number.is_a?(Integer)
+          )
+        )
+      end
+
+      # The default pre-release identifier
+      DEFAULT_PRE_TYPE = 'pre'
+
+      # Increment the major version
+      #
+      # @example
+      #   VersionBoss::IncrementableVersion.new('1.2.3').next_major # =>
+      #     VersionBoss::IncrementableVersion.new('2.0.0')
+      #
+      # @return [IncrementableVersion] a new IncrementableVersion object with the major version incremented
+      #
+      def next_major(pre: false, pre_type: DEFAULT_PRE_TYPE)
+        version_string = "#{major.to_i + 1}.0.0"
+        version_string += ".#{pre_type}1" if pre
+        IncrementableVersion.new(version_string)
+      end
+
+      # Increment the minor version
+      #
+      # @example
+      #   VersionBoss::IncrementableVersion.new('1.2.3').next_minor # =>
+      #     VersionBoss::IncrementableVersion.new('1.3.0')
+      #
+      # @return [IncrementableVersion] a new IncrementableVersion object with the major version incremented
+      #
+      def next_minor(pre: false, pre_type: DEFAULT_PRE_TYPE)
+        version_string = "#{major}.#{minor.to_i + 1}.0"
+        version_string += ".#{pre_type}1" if pre
+        IncrementableVersion.new(version_string)
+      end
+
+      # Increment the patch version
+      #
+      # @example
+      #   VersionBoss::IncrementableVersion.new('1.2.3').next_patch # =>
+      #     VersionBoss::IncrementableVersion.new('1.2.1')
+      #
+      # @return [IncrementableVersion] a new IncrementableVersion object with the patch part incremented
+      #
+      def next_patch(pre: false, pre_type: DEFAULT_PRE_TYPE)
+        version_string = "#{major}.#{minor}.#{patch.to_i + 1}"
+        version_string += ".#{pre_type}1" if pre
+        IncrementableVersion.new(version_string)
+      end
+
+      # Increment the pre_release part of the version
+      #
+      # @example
+      #   VersionBoss::IncrementableVersion.new('1.2.3.pre.1').next_patch.to_s # => '1.2.3.pre.2'
+      #
+      # @return [IncrementableVersion] a new object with the pre_release part incremented
+      #
+      def next_pre(pre_type: nil)
+        assert_is_a_pre_release_version
+        version_string = "#{major}.#{minor}.#{patch}"
+        version_string += next_pre_part(pre_type)
+        IncrementableVersion.new(version_string)
+      end
+
+      # Drop the pre-release part of the version
+      #
+      # @example
+      #   VersionBoss::IncrementableVersion.new('1.2.3.pre.1').next_release.to_s # => '1.2.3'
+      #
+      # @return [IncrementableVersion] a new IncrementableVersion object with the pre_release part dropped
+      # @raise [VersionBoss::Error] if the version is not a pre-release version
+      #
+      def next_release
+        assert_is_a_pre_release_version
+        version_string = "#{major}.#{minor}.#{patch}"
+        IncrementableVersion.new(version_string)
+      end
+
+      # The pre-release type (for example, 'alpha', 'beta', 'pre', etc.)
+      #
+      # @example
+      #   VersionBoss::IncrementableVersion.new('1.2.3.pre1').pre_type # => 'pre'
+      #
+      # @return [String]
+      #
+      def pre_type
+        pre_release_identifiers[0].identifier
+      end
+
+      # Returns the prefix of the pre-release type
+      #
+      # Ruby Gem versions can optionally prefix the pre-release type with a period.
+      #
+      # @example
+      #   VersionBoss::GemVersion.new('1.2.3.pre1').pre_type_prefix # => '-'
+      # Semver requires a hyphen prefix.
+      #
+      # @example
+      #   VersionBoss::IncrementableVersion.new('1.2.3.pre1').pre_type # => 'pre'
+      #
+      # @return ['.', '']
+      #
+      def pre_type_prefix
+        pre_release_identifiers[0].prefix
+      end
+
+      # The pre-release sequence number
+      #
+      # The pre-release sequence number starts at 1 for each pre-release type.
+      #
+      # @example
+      #   IncrementableVersion.new('1.2.3.pre.1').pre_number # => 1
+      #
+      # @return [Integer]
+      #
+      def pre_number
+        pre_release_identifiers[1].identifier
+      end
+
+      # The pre-release sequence number
+      #
+      # The pre-release identifier can optionally prefix the pre-release sequence number with a period.
+      #
+      # @example
+      #   IncrementableVersion.new('1.2.3.pre.1').pre_number_prefix # => '.'
+      #   IncrementableVersion.new('1.2.3.pre1').pre_number_prefix # => ''
+      #
+      # @return [String]
+      #
+      def pre_number_prefix
+        pre_release_identifiers[1].prefix
+      end
+
+      private
+
+      # Raise an error if the version is not a pre-release version
+      #
+      # @return [void]
+      # @raise [VersionBoss::Error] if the version is not a pre-release version
+      # @api private
+      def assert_is_a_pre_release_version
+        return unless pre_release.empty?
+
+        raise VersionBoss::Error, 'Cannot increment the pre-release part of a release version'
+      end
+
+      # Raise an error if new pre-release type is less than the old pre-release type
+      #
+      # If the new pre-release type is lexically less than the old pre-release type,
+      # then raise an error because the resulting error would sort before the existing
+      # version.
+      #
+      # @return [void]
+      # @raise [VersionBoss::Error] if the pre-release type is not valid
+      # @api private
+      def assert_pre_type_is_valid(pre_type)
+        return if self.pre_type <= pre_type
+
+        message = 'Cannot increment the pre-release identifier ' \
+                  "from '#{self.pre_type}' to '#{pre_type}' " \
+                  "because '#{self.pre_type}' is lexically less than '#{pre_type}'"
+
+        raise VersionBoss::Error, message
+      end
+
+      # Return the next pre-release part
+      # @param pre_type [String, nil] the given pre-release type or nil to use the existing pre-release type
+      # @return [String]
+      # @api private
+      def next_pre_part(pre_type)
+        pre_type ||= self.pre_type
+        assert_pre_type_is_valid(pre_type)
+        next_pre_number = self.pre_type == pre_type ? (pre_number + 1) : 1
+        "#{pre_type_prefix}#{pre_type}#{pre_number_prefix}#{next_pre_number}"
+      end
+    end
+  end
+end

data/lib/version_boss/gem/regexp.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module VersionBoss
+  module Gem
+    # Match a gem_version within a string
+    REGEXP = /
+      (?<gem_version>
+        (?<major>0|[1-9]\d*)
+        \.
+        (?<minor>0|[1-9]\d*)
+        \.
+        (?<patch>0|[1-9]\d*)
+        (?<pre_release>
+          (?:
+            \.?
+            [a-z]+
+            (?:
+              \.?
+              (?:[a-z]+|\d+)
+            )*
+          )?
+        )
+      )
+    /x
+
+    # Match a gem_version to the full string
+    REGEXP_FULL = /\A#{REGEXP.source}\z/x
+  end
+end