create_github_release 1.0.0 → 1.2.0

data/lib/create_github_release/command_line/options.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'forwardable'
+
+module CreateGithubRelease
+  module CommandLine
+    # Stores and validates the command line options
+    #
+    # @example
+    #   options = CreateGithubRelease::CommandLine::Options.new
+    #   options.release_type = 'major'
+    #   options.valid? #=> true
+    #   options.errors #=> []
+    #
+    # @api public
+    #
+    class Options
+      CreateGithubRelease::CommandLine::ALLOWED_OPTIONS.each { |option| attr_accessor option }
+
+      # @attribute release_type [rw] the type of release to create
+      #
+      #   Must be one of the VALID_RELEASE_TYPES
+      #
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(release_type: 'major')
+      #     options.release_type #=> 'major'
+      #   @return [String]
+      #   @api public
+
+      # @attribute default_branch [rw] the default branch of the repository
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(default_branch: 'main')
+      #     options.default_branch #=> 'main'
+      #   @return [String]
+      #   @api public
+
+      # @attribute release_branch [rw] the branch use to create the release
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(release_branch: 'release-v1.0.0')
+      #     options.release_branch #=> 'release-v1.0.0'
+      #   @return [String]
+      #   @api public
+
+      # @attribute remote [rw] the name of the remote to use to access Github
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(remote: 'origin')
+      #     options.remote #=> 'origin'
+      #   @return [String]
+      #   @api public
+
+      # @attribute last_release_version [rw] the version of the last release
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(last_release_version: '0.1.1')
+      #     options.last_release_version #=> '0.1.1'
+      #   @return [String]
+      #   @api public
+
+      # @attribute next_release_version [rw] the version of the next release
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(next_release_version: '1.0.0')
+      #     options.next_release_version #=> '1.0.0'
+      #   @return [String]
+      #   @api public
+
+      # @attribute changelog_path [rw] the path to the changelog file
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(changelog_path: 'CHANGELOG.md')
+      #     options.changelog_path #=> 'CHANGELOG.md'
+      #   @return [String]
+      #   @api public
+
+      # @attribute quiet [rw] if `true`, suppresses all output
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(quiet: true)
+      #     options.quiet #=> true
+      #   @return [Boolean]
+      #   @api public
+
+      # @attribute verbose [rw] if `true`, enables verbose output
+      #   @example
+      #     options = CreateGithubRelease::CommandLine::Options.new(verbose: true)
+      #     options.verbose #=> true
+      #   @return [Boolean]
+      #   @api public
+
+      # Create a new instance of this class
+      #
+      # @example No arguments or block given
+      #   options = CreateGithubRelease::CommandLine::Options.new
+      #   options.release_type #=> nil
+      #   options.valid? #=> false
+      #   options.errors #=> ["--release-type must be given and be one of 'major', 'minor', 'patch'"]
+      #
+      # @example With keyword arguments
+      #   config = { release_type: 'major', default_branch: 'main', quiet: true }
+      #   options = CreateGithubRelease::CommandLine::Options.new(**config)
+      #   options.release_type #=> 'major'
+      #   options.default_branch #=> 'main'
+      #   options.quiet #=> true
+      #   options.valid? #=> true
+      #
+      # @example with a configuration block
+      #   options = CreateGithubRelease::CommandLine::Options.new do |o|
+      #     o.release_type = 'major'
+      #     o.default_branch = 'main'
+      #     o.quiet = true
+      #   end
+      #   options.release_type #=> 'major'
+      #   options.default_branch #=> 'main'
+      #   options.quiet #=> true
+      #   options.valid? #=> true
+      #
+      # @yield [self] an initialization block
+      # @yieldparam self [CreateGithubRelease::CommandLine::Options] the instance being initialized
+      # @yieldreturn [void] the return value is ignored
+      #
+      def initialize(**options)
+        assert_no_unknown_options(options)
+        options.each { |k, v| instance_variable_set("@#{k}", v) }
+
+        self.quiet ||= false
+        self.verbose ||= false
+        self.pre ||= false
+        @errors = []
+
+        yield(self) if block_given?
+
+        @validator = CommandLine::Validator.new(self)
+
+        valid?
+      end
+
+      extend Forwardable
+      def_delegators :@validator, :valid?, :errors
+
+      private
+
+      # Raise ArgumentError if options has a key not in ALLOWED_OPTIONS
+      # @return [void]
+      # @api private
+      def assert_no_unknown_options(options)
+        unknown_options = options.keys - ALLOWED_OPTIONS
+        return if unknown_options.empty?
+
+        message = "Unknown keywords: #{unknown_options.join(', ')}"
+        raise ArgumentError, message
+      end
+    end
+  end
+end

data/lib/create_github_release/command_line/parser.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'optparse'
+require 'create_github_release/command_line/options'
+
+module CreateGithubRelease
+  module CommandLine
+    # rubocop:disable Metrics/ClassLength
+
+    # Parses the options for this script
+    #
+    # @example Specify the release type
+    #   options = CommandLineParser.new.parse('major')
+    #   options.valid? # => true
+    #   options.release_type # => "major"
+    #   options.quiet # => false
+    #
+    # @example Specify the release type and the quiet option
+    #   parser = CommandLineParser.new
+    #   args = %w[minor --quiet]
+    #   options = parser.parse(*args)
+    #   options.release_type # => "minor"
+    #   options.quiet # => true
+    #
+    # @example Show the command line help
+    #   CommandLineParser.new.parse('--help')
+    #   parser.parse('--help')
+    #
+    # @api public
+    #
+    class Parser
+      # Create a new command line parser
+      #
+      # @example
+      #   parser = CommandLineParser.new
+      #
+      def initialize
+        @option_parser = OptionParser.new
+        define_options
+        @options = CreateGithubRelease::CommandLine::Options.new
+      end
+
+      # Parse the command line arguements returning the options
+      #
+      # @example
+      #   parser = CommandLineParser.new
+      #   options = parser.parse(['major'])
+      #
+      # @param args [Array<String>] the command line arguments
+      #
+      # @return [CreateGithubRelease::CommandLine::Options] the options
+      #
+      def parse(*args)
+        begin
+          option_parser.parse!(remaining_args = args.dup)
+        rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+          report_errors(e.message)
+        end
+        parse_remaining_args(remaining_args)
+        # puts options unless options.quiet
+        report_errors(*options.errors) unless options.valid?
+        options
+      end
+
+      private
+
+      # @!attribute [rw] options
+      #
+      # The options to used for the create-github-release script
+      #
+      # @example
+      #   parser = CommandLineParser.new
+      #   parser.parse(['major'])
+      #   options = parser.options
+      #   options.release_type # => 'major'
+      #
+      # @return [CreateGithubRelease::CommandLine::Options] the options
+      #
+      # @api private
+      #
+      attr_reader :options
+
+      # @!attribute [rw] option_parser
+      #
+      # The option parser
+      #
+      # @return [OptionParser] the option parser
+      #
+      # @api private
+      #
+      attr_reader :option_parser
+
+      # Parse non-option arguments (the release type)
+      # @return [void]
+      # @api private
+      def parse_remaining_args(remaining_args)
+        options.release_type = remaining_args.shift || nil
+        report_errors('Too many args') unless remaining_args.empty?
+      end
+
+      # An error message constructed from the given errors array
+      # @return [String]
+      # @api private
+      def error_message(errors)
+        <<~MESSAGE
+          #{errors.map { |e| "ERROR: #{e}" }.join("\n")}
+
+          Use --help for usage
+        MESSAGE
+      end
+
+      # Output an error message and useage to stderr and exit
+      # @return [void]
+      # @api private
+      def report_errors(*errors)
+        warn error_message(errors)
+        exit 1
+      end
+
+      # The command line template as a string
+      # @return [String]
+      # @api private
+      def command_template
+        <<~COMMAND
+          #{File.basename($PROGRAM_NAME)} --help | RELEASE_TYPE [options]
+        COMMAND
+      end
+
+      # Define the options for OptionParser
+      # @return [void]
+      # @api private
+      def define_options
+        # @sg-ignore
+        option_parser.banner = "Usage:\n#{command_template}"
+        option_parser.separator ''
+        option_parser.separator "RELEASE_TYPE must be 'major', 'minor', 'patch', 'pre', 'release', or 'first'"
+        option_parser.separator ''
+        option_parser.separator 'Options:'
+        %i[
+          define_help_option define_default_branch_option define_release_branch_option define_pre_option
+          define_pre_type_option define_remote_option define_last_release_version_option
+          define_next_release_version_option define_changelog_path_option define_quiet_option define_verbose_option
+        ].each { |m| send(m) }
+      end
+
+      # Define the pre option
+      # @return [void]
+      # @api private
+      def define_pre_option
+        option_parser.on('-p', '--pre', 'Create a pre-release') do |pre|
+          options.pre = pre
+        end
+      end
+
+      # Define the pre-type option
+      # @return [void]
+      # @api private
+      def define_pre_type_option
+        description = 'Type of pre-release to create (e.g. alpha, beta, etc.)'
+        option_parser.on('-t', '--pre-type=TYPE', description) do |pre_type|
+          options.pre_type = pre_type
+        end
+      end
+
+      # Define the quiet option
+      # @return [void]
+      # @api private
+      def define_quiet_option
+        option_parser.on('-q', '--[no-]quiet', 'Do not show output') do |quiet|
+          options.quiet = quiet
+        end
+      end
+
+      # Define the verbose option
+      # @return [void]
+      # @api private
+      def define_verbose_option
+        option_parser.on('-v', '--[no-]verbose', 'Show extra output') do |verbose|
+          options.verbose = verbose
+        end
+      end
+
+      # Define the help option
+      # @return [void]
+      # @api private
+      def define_help_option
+        option_parser.on_tail('-h', '--help', 'Show this message') do
+          puts option_parser
+          exit 0
+        end
+      end
+
+      # Define the default_branch option which requires a value
+      # @return [void]
+      # @api private
+      def define_default_branch_option
+        option_parser.on('--default-branch=BRANCH_NAME', 'Override the default branch') do |name|
+          options.default_branch = name
+        end
+      end
+
+      # Define the release_branch option which requires a value
+      # @return [void]
+      # @api private
+      def define_release_branch_option
+        option_parser.on('--release-branch=BRANCH_NAME', 'Override the release branch to create') do |name|
+          options.release_branch = name
+        end
+      end
+
+      # Define the remote option which requires a value
+      # @return [void]
+      # @api private
+      def define_remote_option
+        option_parser.on('--remote=REMOTE_NAME', "Use this remote name instead of 'origin'") do |name|
+          options.remote = name
+        end
+      end
+
+      # Define the last_release_version option which requires a value
+      # @return [void]
+      # @api private
+      def define_last_release_version_option
+        option_parser.on('--last-release-version=VERSION', 'Use this version instead `semverify current`') do |version|
+          options.last_release_version = version
+        end
+      end
+
+      # Define the next_release_version option which requires a value
+      # @return [void]
+      # @api private
+      def define_next_release_version_option
+        option_parser.on(
+          '--next-release-version=VERSION',
+          'Use this version instead `semverify next-RELEASE_TYPE`'
+        ) do |version|
+          options.next_release_version = version
+        end
+      end
+
+      # Define the changelog_path option which requires a value
+      # @return [void]
+      # @api private
+      def define_changelog_path_option
+        option_parser.on('--changelog-path=PATH', 'Use this file instead of CHANGELOG.md') do |name|
+          options.changelog_path = name
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/create_github_release/command_line/validations.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module CreateGithubRelease
+  module CommandLine
+    # Module containing all option validations
+    #
+    # All validation classes must inherit from `CreateGithubRelease::Validations::Base`
+    # and implement the `#valid?` and `#error` methods.
+    #
+    # All validation classes must be named `Validate*` and must be defined in the
+    # `CreateGithubRelease::Validations` namespace. Classes that follow this convention
+    # are automatically run by `CreateGithubRelease::CommandLine::OptionsValidator`.
+    #
+    # @api private
+    #
+    module Validations
+      # All validation classes inherit this classes initializer and options reader
+      # @api public
+      class Base
+        # Create a new validation object with the given options
+        #
+        # @example
+        #  class ValidatePreFlag < Base
+        #    def validate
+        #      options.pre == false || %w[major minor patch].include?(options.release_type)
+        #    end
+        #  end
+        #
+        # @param options [CreateGithubRelease::CommandLine::Options] the options to validate
+        #
+        def initialize(options)
+          @options = options
+        end
+
+        private
+
+        # The options to validate
+        # @return [CreateGithubRelease::CommandLine::Options]
+        # @api private
+        attr_reader :options
+
+        # Returns `true` if the given version is a valid gem version
+        # @return [Boolean]
+        # @api private
+        def valid_gem_version?(version)
+          Gem::Version.new(version)
+          true
+        rescue ArgumentError
+          false
+        end
+
+        # `true` if the given name is a valid git reference
+        # @return [Boolean]
+        # @api private
+        def valid_reference?(name)
+          VALID_REF_PATTERN.match?(name)
+        end
+
+        # Returns `true` if the given path is a valid path
+        # @param path [String] the path to validate
+        # @return [Boolean]
+        # @api private
+        def valid_path?(path)
+          File.expand_path(path)
+          true
+        rescue ArgumentError
+          false
+        end
+      end
+
+      # Validate that `pre` is unset or is set with the appropriate release types
+      # @api private
+      #
+      class ValidatePreFlag < Base
+        # Returns `true` if valid
+        # @return [Boolean]
+        # @api private
+        def valid?
+          options.pre == false || %w[major minor patch].include?(options.release_type)
+        end
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error
+          '--pre can only be given with a release type of major, minor, or patch'
+        end
+      end
+
+      # Validate if pre_type is nil or releast_type is 'pre' or the pre flag is set
+      # @api private
+      #
+      class ValidatePreType < Base
+        # Returns `true` if valid
+        # @return [Boolean]
+        # @api private
+        def valid?
+          options.pre_type.nil? ||
+            options.release_type == 'pre' ||
+            (%w[major minor patch].include?(options.release_type) && options.pre == true)
+        end
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error
+          if %w[major minor patch pre].include?(options.release_type)
+            '--pre must be given when --pre-type is given'
+          else
+            '--pre-type can only be given with a release type of major, minor, patch, or pre'
+          end
+        end
+      end
+
+      # Validate that the quiet flag is true or false
+      # @api private
+      class ValidateQuiet < Base
+        # Returns `true` if valid
+        # @return [Boolean]
+        # @api private
+        def valid?
+          options.quiet == true || options.quiet == false
+        end
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error
+          'quiet must be either true or false'
+        end
+      end
+
+      # Validate that the verbose flag is true or false
+      # @api private
+      class ValidateVerbose < Base
+        # Returns `true` if the `#verbose` is `true` or `false` and `false` otherwise
+        # @return [Boolean]
+        # @api private
+        def valid?
+          options.verbose == true || options.verbose == false
+        end
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error
+          'verbose must be either true or false'
+        end
+      end
+
+      # Validate that either quiet or verbose is given, but not both
+      # @api private
+      class ValidateOnlyQuietOrVerbose < Base
+        # Returns `true` if at most only one of `#quiet` or `#verbose` is `true`
+        # @return [Boolean]
+        # @api private
+        def valid? = !options.quiet || !options.verbose
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error = '--quiet and --verbose cannot be used together'
+      end
+
+      # Validates that a release type is given
+      # @api private
+      class ValidateReleaseTypeGiven < Base
+        # Returns `true` if the `#release_type` is not nil
+        # @return [Boolean]
+        # @api private
+        def valid? = !options.release_type.nil?
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error
+          valid_release_types = "'#{VALID_RELEASE_TYPES.join("', '")}'"
+          "RELEASE_TYPE must be given.  Must be one of #{valid_release_types}"
+        end
+      end
+
+      # Validates that the given release type is valid
+      # @api private
+      class ValidateReleaseType < Base
+        # Returns `true` if the `#release_type` is nil or a valid release type
+        # @return [Boolean]
+        # @api private
+        def valid? = options.release_type.nil? || VALID_RELEASE_TYPES.include?(options.release_type)
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error
+          valid_release_types = "'#{VALID_RELEASE_TYPES.join("', '")}'"
+          "RELEASE_TYPE '#{options.release_type}' is not valid. Must be one of #{valid_release_types}"
+        end
+      end
+
+      # Validates the default branch (if given) a valid Git reference
+      # @api private
+      class ValidateDefaultBranch < Base
+        # Returns `true` if the `#default_branch` is nil or is a valid git reference
+        # @return [Boolean]
+        # @api private
+        def valid? = options.default_branch.nil? || valid_reference?(options.default_branch)
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error = "--default-branch='#{options.default_branch}' is not valid"
+      end
+
+      # Validates the release branch (if given) a valid Git reference
+      # @api private
+      class ValidateReleaseBranch < Base
+        # Returns `true` if the `#release_branch` is nil or is a valid git reference
+        # @return [Boolean]
+        # @api private
+        def valid? = options.release_branch.nil? || valid_reference?(options.release_branch)
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error = "--release-branch='#{options.release_branch}' is not valid"
+      end
+
+      # Validate that the remote (if given) is a valid Git reference
+      # @api private
+      class ValidateRemote < Base
+        # Returns `true` if the `#remote` is nil or is a valid git reference
+        # @return [Boolean]
+        # @api private
+        def valid? = options.remote.nil? || valid_reference?(options.remote)
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error = "--remote='#{options.remote}' is not valid"
+      end
+
+      # Validate that the last release version (if given) is a valid gem version
+      # @api private
+      class ValidateLastReleaseVersion < Base
+        # Returns `true` if the `#last_release_version` is nil or is a valid gem version
+        # @return [Boolean]
+        # @api private
+        def valid? = options.last_release_version.nil? || valid_gem_version?(options.last_release_version)
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error = "--last-release-version='#{options.last_release_version}' is not valid"
+      end
+
+      # Validate that the next release version (if given) is a valid gem version
+      # @api private
+      class ValidateNextReleaseVersion < Base
+        # Returns `true` if the `#next_release_version` is nil or is a valid gem version
+        # @return [Boolean]
+        # @api private
+        def valid? = options.next_release_version.nil? || valid_gem_version?(options.next_release_version)
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error = "--next-release-version='#{options.next_release_version}' is not valid"
+      end
+
+      # Validate that the change log path (if given) is a valid path
+      # @api private
+      class ValidateChangelogPath < Base
+        # Returns `true` if `#changelog_path` is nil or is a valid regular file path
+        # @return [Boolean]
+        # @api private
+        def valid?
+          options.changelog_path.nil? ||
+            (valid_path?(options.changelog_path) && File.file?(File.expand_path(options.changelog_path)))
+        end
+
+        # Called when valid? is `false` to return the error messages
+        # @return [String, Array<String>]
+        # @api private
+        def error
+          if valid_path?(options.changelog_path)
+            "The change log path '#{options.changelog_path}' is not a regular file"
+          else
+            "The change log path '#{options.changelog_path}' is not a valid path"
+          end
+        end
+      end
+    end
+  end
+end