ruby-gem-release 0.4.0 → 0.5.0

data/lib/ruby-gem-release/semantic_release/git_history.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative 'decision'
+
+module RubyGemRelease
+  class SemanticRelease
+    class GitHistory
+      def read(head:)
+        check_head!(head)
+        last_release = last_release(head)
+        range = last_release ? "#{last_release.fetch('commit')}..#{head}" : head
+        entries = run('log', '--reverse', '-z', '--format=%H%x00%B', range, '--').split("\0")
+        commits = entries.each_slice(2).map { |sha, message| { 'sha' => sha, 'message' => message } }
+        { last_release: last_release, commits: commits }
+      end
+
+      private
+
+      def check_head!(head)
+        raise ArgumentError, 'semantic history requires the captured commit SHA' unless head.is_a?(String) && Decision::SHA.match?(head)
+        raise ArgumentError, 'semantic releases require a complete checkout; fetch full history and tags' if run('rev-parse', '--is-shallow-repository').strip == 'true'
+        raise ArgumentError, 'checkout changed before semantic analysis' unless run('rev-parse', 'HEAD').strip == head
+      end
+
+      def last_release(head)
+        tags = run('tag', '--merged', head).lines.map(&:strip)
+        tags.select! { |tag| tag.start_with?('v') && Version::RubyConstant::PATTERN.match?(tag.delete_prefix('v')) }
+        tag = tags.max_by { |candidate| Gem::Version.new(candidate.delete_prefix('v')) }
+        return unless tag
+
+        { 'tag' => tag, 'version' => tag.delete_prefix('v'), 'commit' => run('rev-parse', "refs/tags/#{tag}^{commit}").strip }
+      end
+
+      def run(*)
+        output, error, status = Open3.capture3('git', *)
+        raise "Semantic history Git command failed: #{error.strip}" unless status.success?
+
+        output
+      end
+    end
+  end
+end

data/lib/ruby-gem-release/semantic_release/release_notes.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'conventional_commits'
+
+module RubyGemRelease
+  class SemanticRelease
+    class ReleaseNotes
+      GROUPS = { 'feat' => 'Features', 'fix' => 'Bug Fixes', 'perf' => 'Performance Improvements' }.freeze
+
+      def generate(commits:, **)
+        parsed = ConventionalCommits.new.parsed(commits)
+        sections = []
+        breaking = breaking_section(parsed)
+        sections << breaking if breaking
+        sections.concat(change_sections(parsed))
+        sections.empty? ? 'Explicit version release.' : sections.join("\n\n")
+      end
+
+      private
+
+      def breaking_section(commits)
+        notes = commits.flat_map { |commit| commit[:notes] }
+        "### Breaking Changes\n\n#{notes.map { |note| "- #{note}" }.join("\n")}" unless notes.empty?
+      end
+
+      def change_sections(commits)
+        commits.group_by { |commit| GROUPS.fetch(commit[:type], 'Other Changes') }.map do |title, group|
+          entries = group.map { |commit| "- #{description(commit)} (#{commit[:sha][0, 7]})" }
+          "### #{title}\n\n#{entries.join("\n")}"
+        end
+      end
+
+      def description(commit)
+        subject = commit[:subject].gsub(/([\\`*_\[\]<>])/, '\\\\\1')
+        scope = commit[:scope]&.gsub(/([\\`*_\[\]<>])/, '\\\\\1')
+        scope ? "**#{scope}:** #{subject}" : subject
+      end
+    end
+  end
+end

data/lib/ruby-gem-release/semantic_release/version_selector.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'decision'
+
+module RubyGemRelease
+  class SemanticRelease
+    class VersionSelector
+      def initialize(first_version: '1.0.0')
+        validate(first_version)
+        @first_version = first_version.dup.freeze
+      end
+
+      def select(last_release:, release_type:, explicit_version: nil)
+        explicit_version = nil if explicit_version == ''
+        validate_options(last_release, release_type, explicit_version)
+        version = explicit_version || increment(last_release, release_type)
+        raise ArgumentError, 'selected version must exceed the last release' if version && last_release && Gem::Version.new(version) <= Gem::Version.new(last_release)
+
+        version
+      end
+
+      private
+
+      def validate_options(last_release, type, explicit)
+        validate(last_release) if last_release
+        validate(explicit) if explicit
+        raise ArgumentError, 'unsupported release type' unless type.nil? || Decision::TYPES.include?(type)
+      end
+
+      def increment(version, type)
+        return unless type
+        return @first_version unless version
+
+        parts = version.split('.').map(&:to_i)
+        index = { 'major' => 0, 'minor' => 1, 'patch' => 2 }.fetch(type)
+        parts[index] += 1
+        ((index + 1)..2).each { |position| parts[position] = 0 }
+        parts.join('.')
+      end
+
+      def validate(version)
+        return if version.is_a?(String) && Version::RubyConstant::PATTERN.match?(version)
+
+        raise ArgumentError, 'semantic versions must be MAJOR.MINOR.PATCH without leading zeros'
+      end
+    end
+  end
+end

data/lib/ruby-gem-release/semantic_release.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'semantic_release/git_history'
+require_relative 'semantic_release/conventional_commits'
+require_relative 'semantic_release/version_selector'
+require_relative 'semantic_release/release_notes'
+
+module RubyGemRelease
+  class SemanticRelease
+    def initialize(history: GitHistory.new, analyzer: ConventionalCommits.new, selector: VersionSelector.new, notes: ReleaseNotes.new)
+      @history = history
+      @analyzer = analyzer
+      @selector = selector
+      @notes = notes
+    end
+
+    def analyze(head:, explicit_version: nil)
+      explicit_version = nil if explicit_version == ''
+      history = @history.read(head: head)
+      type = @analyzer.analyze(history.fetch(:commits))
+      last_release = history.fetch(:last_release)
+      version = @selector.select(last_release: last_release&.fetch('version'), release_type: type, explicit_version: explicit_version)
+      notes = @notes.generate(commits: history.fetch(:commits), version: version, last_release: last_release) if version
+      Decision.new(head: head, last_release: last_release, commits: history.fetch(:commits),
+                   release_type: type, version: version, notes: notes, explicit_version: explicit_version)
+    end
+  end
+end

data/lib/ruby-gem-release/source_control/git/preparation.rb

@@ -20,7 +20,7 @@ module RubyGemRelease
 
         def stage_changes!
           if block_given?
-            check_clean!
+            verify!
             yield
           end
           paths = changed_paths

data/lib/ruby-gem-release/source_control/git.rb

@@ -11,10 +11,11 @@ module RubyGemRelease
       def initialize(branch: nil, remote: 'origin', directory: nil)
         @remote = remote
         @branch = branch || ENV.fetch('DEFAULT_BRANCH', nil)
-        @directory = directory || ENV['RUNNER_TEMP'] || Dir.mktmpdir('ruby-gem-release-git-')
+        directory ||= ENV.fetch('RELEASE_DATA_DIR', nil)
+        @directory = directory.to_s.empty? ? Dir.mktmpdir('ruby-gem-release-git-') : directory
       end
 
-      def configure!(name: 'github-actions[bot]', email: 'github-actions[bot]@users.noreply.github.com')
+      def configure!(name: 'ruby-gem-release', email: 'ruby-gem-release@localhost')
         [name, email].each do |value|
           raise ArgumentError, 'Git identity must be nonempty and contain no line breaks' unless value.is_a?(String) && !value.strip.empty? && !value.match?(/[\r\n]/)
         end
@@ -26,15 +27,13 @@ module RubyGemRelease
         run('rev-parse', 'HEAD').strip
       end
 
-      def check_tag!(version)
-        output, _error, status = Open3.capture3('git', 'show-ref', '--verify', '--quiet', "refs/tags/v#{version}")
-        raise "Release tag already exists: v#{version}" if status.success?
-        raise "Cannot check release tag: #{output}" unless status.exitstatus == 1
+      def timestamp(commit)
+        run('show', '-s', '--format=%ct', commit).strip
       end
 
-      def check_current!(_release, expected: head)
+      def check_current!(expected: head, allow_ancestor: false)
         run('fetch', @remote, branch, '--tags')
-        raise 'Default branch advanced; start a new release' unless remote_head == expected
+        raise 'Default branch advanced; start a new release' unless remote_head == expected || (allow_ancestor && ancestor?(expected, remote_head))
       end
 
       def check_clean!
@@ -47,7 +46,11 @@ module RubyGemRelease
 
       def commit!(release)
         @release = release
-        @initial_commit = ENV['RELEASE_INITIAL_COMMIT'] || head
+        @next_commit_parent = nil
+        @source_commit = ENV['SOURCE_COMMIT'] || head
+        existing = tag_commit(release.version)
+        return reuse_release!(existing) if existing
+
         commit_changes("Prepare release #{release.version}", required: false)
       end
 
@@ -56,33 +59,126 @@ module RubyGemRelease
 
         @release = release
         @next_commit_parent = head
+        existing = next_iteration(release)
+        return reuse_iteration!(existing, release) if existing
+
         commit_changes("Prepare next development iteration, #{release.next_version}", required: true)
       end
 
       def tag!(release)
         @release = release
         ensure_clean!
-        check_current!(release, expected: @initial_commit || ENV.fetch('RELEASE_INITIAL_COMMIT'))
-        check_tag!(release.version)
-        run('tag', "v#{release.version}")
-        FileUtils.mkdir_p(@directory)
-        run('bundle', 'create', File.join(@directory, 'release.bundle'), 'HEAD', "refs/tags/v#{release.version}")
+        fetch!
+        existing = tag_commit(release.version)
+        raise "Release tag already exists at another commit: v#{release.version}" if existing && existing != head
+
+        raise 'Default branch advanced; start a new release' unless release_current?(existing)
+
+        run('tag', "v#{release.version}") unless existing
+        write_bundle(release)
       end
 
       def push!(release = @release)
         raise ArgumentError, 'a release context is required before pushing' unless release
 
-        if @next_commit_parent
-          check_current!(release, expected: @next_commit_parent)
-          run('push', @remote, "HEAD:refs/heads/#{branch}")
-        else
-          check_current!(release, expected: @initial_commit || ENV.fetch('RELEASE_INITIAL_COMMIT'))
-          run('push', '--atomic', @remote, "HEAD:refs/heads/#{branch}", "refs/tags/v#{release.version}")
-        end
+        fetch!
+        @next_commit_parent ? push_iteration! : push_release!(release)
+      end
+
+      def fetch!
+        run('fetch', @remote, branch, '--tags')
+      end
+
+      def tag_commit(version)
+        ref = "refs/tags/v#{version}"
+        _output, error, status = Open3.capture3('git', 'show-ref', '--verify', '--quiet', ref)
+        return if status.exitstatus == 1
+        raise "Cannot inspect release tag: #{error}" unless status.success?
+
+        run('rev-parse', "#{ref}^{commit}").strip
+      end
+
+      def next_iteration(release)
+        fetch!
+        released = tag_commit(release.version)
+        return unless released && ancestor?(released, remote_head)
+
+        candidate = iteration_after(released)
+        return unless candidate
+
+        version = run('log', '-1', '--format=%s', candidate)[/\APrepare next development iteration, (\d+\.\d+\.\d+)\n?\z/, 1]
+        { commit: candidate, version: version, tree: run('rev-parse', "#{candidate}^{tree}").strip } if version
       end
 
       private
 
+      def reuse_release!(existing)
+        preparation.verify!
+        raise 'Existing release tag differs from the intended tree' unless run('write-tree').strip == run('rev-parse', "#{existing}^{tree}").strip
+
+        run('update-ref', 'HEAD', existing, head)
+        preparation.clear!
+        head
+      end
+
+      def reuse_iteration!(existing, release)
+        preparation.verify!
+        raise 'Existing development iteration differs from the intended changes' unless existing.fetch(:version) == release.next_version && existing.fetch(:tree) == run('write-tree').strip
+
+        run('update-ref', 'HEAD', existing.fetch(:commit), head)
+        preparation.clear!
+        head
+      end
+
+      def release_current?(existing)
+        expected = @source_commit || ENV.fetch('SOURCE_COMMIT')
+        remote_head == expected || (existing && ancestor?(head, remote_head))
+      end
+
+      def write_bundle(release)
+        FileUtils.mkdir_p(@directory)
+        run('bundle', 'create', File.join(@directory, 'release.bundle'), 'HEAD', "refs/tags/v#{release.version}")
+      end
+
+      def push_iteration!
+        return if ancestor?(head, remote_head)
+
+        check_current!(expected: @next_commit_parent)
+        run('push', @remote, "HEAD:refs/heads/#{branch}")
+      end
+
+      def push_release!(release)
+        return push_missing_tag(release) if ancestor?(head, remote_head)
+
+        check_current!(expected: @source_commit || ENV.fetch('SOURCE_COMMIT'))
+        run('push', '--atomic', @remote, "HEAD:refs/heads/#{branch}", "refs/tags/v#{release.version}")
+      end
+
+      def iteration_after(released)
+        candidate = run('rev-list', '--first-parent', '--reverse', "#{released}..#{remote_head}").lines.first&.strip
+        candidate if candidate && run('rev-list', '--parents', '-n', '1', candidate).split == [candidate, released]
+      end
+
+      def ancestor?(commit, descendant)
+        _output, error, status = Open3.capture3('git', 'merge-base', '--is-ancestor', commit, descendant)
+        raise "Cannot inspect Git ancestry: #{error}" unless [0, 1].include?(status.exitstatus)
+
+        status.success?
+      end
+
+      def remote_tag(version)
+        output = run('ls-remote', '--tags', @remote, "refs/tags/v#{version}", "refs/tags/v#{version}^{}")
+        entries = output.lines.map(&:split).to_h { |sha, ref| [ref, sha] }
+        entries["refs/tags/v#{version}^{}"] || entries["refs/tags/v#{version}"]
+      end
+
+      def push_missing_tag(release)
+        existing = remote_tag(release.version)
+        raise 'Remote release tag points at another commit' if existing && existing != head
+
+        run('push', @remote, "refs/tags/v#{release.version}") unless existing
+      end
+
       def branch
         @branch ||= run('symbolic-ref', "refs/remotes/#{@remote}/HEAD").strip.delete_prefix("refs/remotes/#{@remote}/")
       end

data/lib/ruby-gem-release/tasks.rb

@@ -2,40 +2,60 @@
 
 require 'rake'
 require_relative 'release'
+require_relative 'release_failure'
+require_relative 'execution_provider'
 require_relative 'version/ruby_constant'
-require_relative 'workflow/context'
+require_relative 'workflow/environment'
+require_relative 'workflow/failure'
 require_relative 'workflow/ruby_gems_credentials'
+require_relative 'destination/ruby_gems'
 
 module RubyGemRelease
   class Tasks
     include Rake::DSL
 
-    def self.install
-      instance = new
+    def self.install(workflow: nil, package: nil, destination: Destination::RubyGems.new, provider: ExecutionProvider.current)
+      instance = new(workflow: workflow, package: package, destination: destination, provider: provider)
       yield instance if block_given?
       instance.install
     end
 
+    def initialize(workflow: nil, package: nil, destination: Destination::RubyGems.new, provider: ExecutionProvider.current)
+      @workflow = workflow
+      @package = package
+      @destination = destination
+      @provider = provider
+    end
+
     def install
       namespace :release do
+        install_validate_task
         install_callback_tasks
         install_publish_task
+        install_result_tasks
         install_workflow_tasks
       end
     end
 
-    def before_release(&block)
-      raise ArgumentError, 'before_release requires a block' unless block
-      raise ArgumentError, 'before_release already configured' if @before_release
+    def validate(&block)
+      raise ArgumentError, 'validate requires a block' unless block
+      raise ArgumentError, 'validate already configured' if @validate
 
-      @before_release = block
+      @validate = block
     end
 
-    def after_release(&block)
-      raise ArgumentError, 'after_release requires a block' unless block
-      raise ArgumentError, 'after_release already configured' if @after_release
+    def prepare(&block)
+      raise ArgumentError, 'prepare requires a block' unless block
+      raise ArgumentError, 'prepare already configured' if @prepare
 
-      @after_release = block
+      @prepare = block
+    end
+
+    def bump(&block)
+      raise ArgumentError, 'bump requires a block' unless block
+      raise ArgumentError, 'bump already configured' if @bump
+
+      @bump = block
     end
 
     def publish(&block)
@@ -45,50 +65,188 @@ module RubyGemRelease
       @publish = block
     end
 
+    def success(&block)
+      raise ArgumentError, 'success requires a block' unless block
+      raise ArgumentError, 'success already configured' if @success
+
+      @success = block
+    end
+
+    def failure(&block)
+      raise ArgumentError, 'failure requires a block' unless block
+      raise ArgumentError, 'failure already configured' if @failure
+
+      @failure = block
+    end
+
     private
 
+    def install_validate_task
+      desc 'Validate release preconditions'
+      task :validate do
+        with_failure_capture('release:validate') { validate_release }
+      end
+    end
+
+    def validate_release
+      raise ArgumentError, 'Release validation failed: callback returned false' if @validate && @validate.call(context('release:validate', preparing: true)) == false
+
+      puts 'Release validation passed.'
+    end
+
     def install_workflow_tasks
       namespace :workflow do
-        task(:configure) { Workflow::Context.new.configure! }
-        task(:capture) { Workflow::Context.new.capture! }
-        task(:resolve) { Workflow::Context.new.resolve! }
-        task(:credentials) { Workflow::RubyGemsCredentials.new(owner: ENV.fetch('RUBYGEMS_OWNER')).configure! }
+        install_workflow_context_tasks
+        task(:failure_phase) { Workflow::Failure.phase!(provider: @provider) }
+        task(:credentials) do
+          with_failure_capture('release:workflow:credentials') do
+            Workflow::RubyGemsCredentials.new(owner: @provider.fetch('RUBYGEMS_OWNER_ID', ''), provider: @provider).configure!
+          end
+        end
+      end
+    end
+
+    def install_workflow_context_tasks
+      install_checkpoint_task
+      task(:configure) { with_failure_capture('release:workflow:configure') { Workflow::Environment.new(provider: @provider).configure! } }
+      task(:capture) { with_failure_capture('release:workflow:capture') { Workflow::Environment.new(provider: @provider).capture!(package: @package) } }
+      task(:resolve) do
+        with_failure_capture('release:workflow:resolve') do
+          Workflow::Environment.new(provider: @provider).resolve!(package: @package, destination: @destination, analysis: state.analysis)
+        end
+      end
+    end
+
+    def install_checkpoint_task
+      task(:checkpoint) do
+        with_failure_capture('release:workflow:checkpoint') do
+          raise 'Workflow must implement checkpoint! before publication' unless @workflow
+
+          @workflow.checkpoint!(context('release:workflow:checkpoint'))
+        end
       end
     end
 
     def install_publish_task
       desc 'Run the release publication callback'
       task :publish do
-        @publish&.call(context)
+        with_failure_capture('release:publish') do
+          next unless @publish
+
+          ctx = context('release:publish')
+          @destination.authenticate!(provider: @provider) unless @workflow&.published?(ctx.release)
+          @publish.call(ctx)
+        end
+      end
+    end
+
+    def install_result_tasks
+      desc 'Run the release success callback'
+      task :success do
+        with_failure_capture('release:success') { @success&.call(context('release:success')) }
+      end
+      desc 'Run the release failure callback'
+      task :failure do
+        @failure&.call(failure_context)
       end
     end
 
     def install_callback_tasks
-      desc 'Run the before-release callback'
-      task(:before_release) do
-        release = context(before_release: true)
-        @before_release&.call(release)
+      install_prepare_task
+      install_bump_task
+    end
+
+    def install_prepare_task
+      desc 'Run the release preparation callback'
+      task(:prepare) do
+        with_failure_capture('release:prepare') do
+          execution = context('release:prepare', preparing: true)
+          @prepare&.call(execution)
+        end
       end
+    end
+
+    def install_bump_task
       desc 'Run the next development iteration preparation callback'
-      task(:after_release) do
-        release = context
-        @after_release&.call(release)
+      task(:bump) do
+        with_failure_capture('release:bump') do
+          execution = context('release:bump')
+          @bump&.call(execution)
+        end
+      end
+    end
+
+    def context(task, preparing: false)
+      snapshot = state.snapshot
+      release = release_context(preparing: preparing, **snapshot, validating: task == 'release:validate')
+      @provider.context(release: release, task: task, state: state, workflow: @workflow, analysis: snapshot.fetch(:analysis))
+    end
+
+    def state
+      path = @provider.fetch('RELEASE_STATE_FILE', nil)
+      if !defined?(@state) || @state_path != path
+        @state_path = path
+        @state = Workflow::State.new(path: path)
       end
+      @state
     end
 
-    def context(before_release: false)
-      previous_version = ENV.fetch('RELEASE_PREVIOUS_VERSION')
-      version = before_release ? preparation_version(previous_version) : ENV.fetch('RELEASE_VERSION')
-      date = ENV.fetch('RELEASE_DATE')
-      validate_context_versions(version, previous_version)
+    def release_context(preparing: false, analysis: nil, next_version: nil, validating: false)
+      gemspec_version = @provider.fetch('GEMSPEC_VERSION')
+      version = preparing ? preparation_version(gemspec_version, analysis: analysis, validating: validating) : @provider.fetch('RELEASE_VERSION')
+      date = @provider.fetch('RELEASE_DATE')
+      analysis&.check!(head: @provider.fetch('SOURCE_COMMIT'), explicit_version: @provider.fetch('INPUT_VERSION', ''), version: validating ? nil : version)
+      validate_context_versions(version, gemspec_version)
       raise ArgumentError, 'release date is required in YYYY-MM-DD format' unless date.match?(/\A\d{4}-\d{2}-\d{2}\z/)
 
-      Release.new(version: version, previous_version: previous_version, date: Date.iso8601(date))
+      Release.new(version: version, gemspec_version: gemspec_version, date: Date.iso8601(date), next_version: next_version, notes: analysis&.notes)
+    end
+
+    def preparation_version(gemspec_version, analysis: nil, validating: false)
+      if analysis
+        return analysis.version if analysis.release?
+        return gemspec_version if validating
+
+        raise ArgumentError, 'semantic analysis selected no release'
+      end
+      selected = @provider.fetch('INPUT_VERSION', '')
+      selected.empty? ? gemspec_version : selected
+    end
+
+    def failure_context
+      phase = @provider.fetch('RELEASE_FAILED_STEP_ID', 'unknown')
+      error = Workflow::Failure.error_for(phase, provider: @provider) unless phase == 'unknown'
+      safe_state, snapshot = failure_snapshot
+      execution = @provider.context(release: failure_release_context(**snapshot), task: 'release:failure', state: safe_state, workflow: @workflow, analysis: snapshot.fetch(:analysis))
+      ReleaseFailure.new(phase: phase, error: error, context: execution)
+    end
+
+    def failure_release_context(analysis: nil, next_version: nil)
+      gemspec_version = @provider.fetch('GEMSPEC_VERSION', nil)
+      date = @provider.fetch('RELEASE_DATE', '')
+      return unless gemspec_version && date.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+
+      version = @provider.fetch('RELEASE_VERSION', '')
+      version = preparation_version(gemspec_version, analysis: analysis) if version.empty?
+      validate_context_versions(version, gemspec_version)
+      Release.new(version: version, gemspec_version: gemspec_version, date: Date.iso8601(date), next_version: next_version, notes: analysis&.notes)
+    rescue ArgumentError
+      nil
+    end
+
+    def failure_snapshot
+      [state, state.snapshot]
+    rescue ArgumentError, JSON::ParserError, SystemCallError => e
+      warn "Unable to read release state for failure callback: #{e.message}"
+      safe_state = Workflow::State.new
+      [safe_state, safe_state.snapshot]
     end
 
-    def preparation_version(previous_version)
-      selected = ENV.fetch('INPUT_VERSION', '')
-      selected.empty? ? previous_version : selected
+    def with_failure_capture(task)
+      yield
+    rescue StandardError => e
+      Workflow::Failure.capture!(@provider.step_id(task), e, provider: @provider)
+      raise
     end
 
     def validate_context_versions(*versions)

data/lib/ruby-gem-release/version/ruby_constant.rb

@@ -27,14 +27,18 @@ module RubyGemRelease
         value
       end
 
-      def increment!(part: :patch)
-        parts = parse(read)
+      def increment!(part: :patch, from: read)
+        set!(next_version(part: part, from: from))
+      end
+
+      def next_version(part: :patch, from: read)
+        parts = parse(from)
         index = { 'major' => 0, 'minor' => 1, 'patch' => 2 }.fetch(part.to_s) do
           raise ArgumentError, 'bump part must be major, minor, or patch'
         end
         parts[index] += 1
         ((index + 1)...parts.size).each { |i| parts[i] = 0 }
-        set!(parts.join('.'))
+        parts.join('.')
       end
 
       private

data/lib/ruby-gem-release/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyGemRelease
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end