ruby-gem-release 0.4.0 → 0.5.0

data/lib/ruby-gem-release/workflow/environment.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative '../package/ruby_gem'
+require_relative '../destination/ruby_gems'
+require_relative '../source_control/git'
+require_relative '../release'
+require_relative '../version/ruby_constant'
+require_relative 'state'
+require_relative '../execution_provider'
+
+module RubyGemRelease
+  module Workflow
+    class Environment
+      def initialize(provider: ExecutionProvider.current)
+        @provider = provider
+      end
+
+      def configure!
+        names = %w[INPUT_VERSION INPUT_GEMSPEC_PATH DEFAULT_BRANCH GIT_USER_NAME GIT_USER_EMAIL RUBYGEMS_OWNER_ID]
+        timezone = @provider.fetch('TZ', 'UTC')
+        validate_timezone(timezone)
+        @provider.export(names.to_h { |name| [name, @provider.fetch(name)] }.merge('TZ' => timezone))
+      end
+
+      def capture!(package: nil)
+        check_branch
+        validate_timezone(@provider.fetch('TZ', 'UTC'))
+        git = configured_git
+        git.check_clean!
+        package ||= Package::RubyGem.new(gemspec: @provider.fetch('INPUT_GEMSPEC_PATH', @provider.fetch('GEMSPEC_PATH', '')) || '', directory: @provider.directory)
+        release = initial_release(package)
+        git.check_current!(allow_ancestor: true)
+        @provider.export(captured_values(package, git, release))
+      end
+
+      def resolve!(package: nil, destination: Destination::RubyGems.new, analysis: State.new(path: @provider.fetch('RELEASE_STATE_FILE', nil)).analysis)
+        package ||= Package::RubyGem.new(gemspec: @provider.fetch('GEMSPEC_PATH', @provider.fetch('INPUT_GEMSPEC_PATH', '')) || '', directory: @provider.directory)
+        authentication = authentication_for(destination)
+        version = prepared_version(package, analysis)
+        git = SourceControl::Git.new(directory: @provider.directory)
+        git.stage_changes!
+        @provider.export('RELEASE_VERSION' => version, 'RELEASE_AUTH_MODE' => authentication)
+      end
+
+      private
+
+      def authentication_for(destination)
+        authentication = destination.authentication
+        raise ArgumentError, 'unsupported destination authentication' unless [nil, 'rubygems'].include?(authentication)
+
+        authentication.to_s
+      end
+
+      def captured_values(package, git, release)
+        commit = git.head
+        state = State.create!(directory: @provider.directory) if @provider.directory
+        { 'TZ' => @provider.fetch('TZ', 'UTC'), 'GEMSPEC_PATH' => package.respond_to?(:gemspec) ? package.gemspec.to_s : '', 'GEMSPEC_VERSION' => release.version,
+          'RELEASE_DATA_DIR' => @provider.directory.to_s,
+          'RELEASE_DATE' => release.date.iso8601, 'SOURCE_COMMIT' => commit, 'RELEASE_STATE_FILE' => state.to_s,
+          'SOURCE_DATE_EPOCH' => source_date_epoch(git, commit) }
+      end
+
+      def source_date_epoch(git, commit)
+        value = @provider.fetch('SOURCE_DATE_EPOCH', '').strip
+        value.empty? ? git.timestamp(commit) : value
+      end
+
+      def prepared_version(package, analysis)
+        version = package.version
+        validate_version(version)
+        analysis&.check!(head: @provider.fetch('SOURCE_COMMIT'), explicit_version: @provider.fetch('INPUT_VERSION', ''), version: version)
+        selected = analysis ? analysis.version : @provider.fetch('INPUT_VERSION', '')
+        raise "Prepared version #{version} does not match selected version #{selected}" unless selected.empty? || version == selected
+
+        version
+      end
+
+      def initial_release(package)
+        version = package.version
+        validate_version(version)
+        validate_version(@provider.fetch('INPUT_VERSION')) unless @provider.fetch('INPUT_VERSION', '').empty?
+        Release.new(version: version, gemspec_version: version, date: release_date)
+      end
+
+      def release_date
+        (@provider.fetch('TZ', nil) ? Time.now.getlocal : Time.now.utc).to_date
+      end
+
+      def validate_timezone(timezone)
+        valid = %r{\A[A-Za-z0-9_+-]+(?:/[A-Za-z0-9_+-]+)*\z}.match?(timezone) &&
+                File.file?(File.join('/usr/share/zoneinfo', timezone))
+        raise ArgumentError, 'timezone must identify an installed timezone, such as UTC or America/New_York' unless valid
+      end
+
+      def configured_git
+        SourceControl::Git.new(directory: @provider.directory).tap { |git| git.configure!(**@provider.git_identity) }
+      end
+
+      def check_branch
+        return if @provider.ref == "refs/heads/#{@provider.fetch('DEFAULT_BRANCH')}"
+
+        raise 'Releases must run from the default branch'
+      end
+
+      def validate_version(version)
+        raise ArgumentError, 'Version must be MAJOR.MINOR.PATCH without leading zeros' unless Version::RubyConstant::PATTERN.match?(version)
+      end
+    end
+  end
+end

data/lib/ruby-gem-release/workflow/failure.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../release_failure'
+require_relative '../execution_provider'
+
+module RubyGemRelease
+  module Workflow
+    class Failure
+      class << self
+        def phase!(provider: ExecutionProvider.current)
+          failed = provider.failed_steps
+          phase = failed.find { |step| error_for(step, provider: provider) } || failed.first || 'unknown'
+          provider.export('RELEASE_FAILED_STEP_ID' => phase)
+        end
+
+        def capture!(phase, error, provider: ExecutionProvider.current)
+          return unless provider.directory
+
+          captured_error = ReleaseFailure::CapturedError.capture(error)
+          File.open(failure_file(provider), 'w', 0o600) do |file|
+            file.write(JSON.generate('phase' => phase, 'error' => captured_error.to_h))
+          end
+        rescue StandardError => e
+          warn "Unable to capture release error details: #{e.message}"
+        end
+
+        def error_for(phase, provider: ExecutionProvider.current)
+          return unless provider.directory
+
+          failure = JSON.parse(File.read(failure_file(provider)))
+          return unless failure.fetch('phase') == phase
+
+          ReleaseFailure::CapturedError.from_h(failure.fetch('error'))
+        rescue Errno::ENOENT
+          nil
+        end
+
+        private
+
+        def failure_file(provider)
+          File.join(provider.directory, 'ruby-gem-release-failure.json')
+        end
+      end
+    end
+  end
+end

data/lib/ruby-gem-release/workflow/ruby_gem.rb

@@ -2,33 +2,68 @@
 
 require_relative '../tasks'
 require_relative '../package/ruby_gem'
+require_relative '../destination/ruby_gems'
 require_relative '../source_control/git'
 require_relative '../hosting/github_release'
 
 module RubyGemRelease
   module Workflow
     class RubyGem
-      def initialize(version:, changelog:, package: Package::RubyGem.new, git: SourceControl::Git.new, hosting: Hosting::GitHubRelease.new)
+      attr_reader :version, :changelog, :package, :destination, :git, :hosting, :provider
+
+      def initialize(version:, changelog:, provider: ExecutionProvider.current,
+                     package: Package::RubyGem.new(gemspec: provider.fetch('GEMSPEC_PATH', provider.fetch('INPUT_GEMSPEC_PATH', '')) || '', directory: provider.directory),
+                     destination: Destination::RubyGems.new,
+                     git: SourceControl::Git.new(directory: provider.directory), hosting: Hosting::GitHubRelease.new,
+                     validate: nil, success: nil, failure: nil)
         @version = version
         @changelog = changelog
         @package = package
+        @destination = destination
         @git = git
         @hosting = hosting
+        @provider = provider
+        @validate = validate
+        @success = success
+        @failure = failure
       end
 
       def install_tasks
-        Tasks.install do |tasks|
-          tasks.before_release { |release| prepare_release(release) }
-          tasks.publish { |release| publish(release) }
-          tasks.after_release { |release| prepare_next(release) }
+        Tasks.install(workflow: self, package: @package, destination: @destination, provider: @provider) do |tasks|
+          install_callbacks(tasks)
         end
       end
 
+      def checkpoint!(context)
+        prepare_publication(context.release)
+      end
+
+      def published?(release)
+        @package.respond_to?(:built?) && @package.built?(release) && @destination.published?(release, package: @package)
+      end
+
       private
 
+      def install_callbacks(tasks)
+        tasks.validate { |ctx| validate_release(ctx) }
+        tasks.prepare { |ctx| prepare_release(ctx.release) }
+        tasks.publish { |ctx| publish(ctx.release) }
+        tasks.bump { |ctx| prepare_next(ctx) }
+        tasks.success(&@success) if @success
+        tasks.failure(&@failure) if @failure
+      end
+
+      def validate_release(ctx)
+        return @validate.call(ctx) if @validate
+
+        return if @changelog.nil? || @changelog.released?(ctx.release.version) || @changelog.pending?
+
+        raise ArgumentError, 'Nothing to release: no pending changelog notes'
+      end
+
       def prepare_release(release)
         @git.stage_changes! do
-          select_version!(release.version) unless ENV.fetch('INPUT_VERSION', '').empty?
+          select_version!(release.version) unless @provider.fetch('INPUT_VERSION', '').empty?
           @changelog&.release!(release.with_version(@version.read))
         end
       end
@@ -39,24 +74,33 @@ module RubyGemRelease
         @version.set!(version)
       end
 
-      def publish(release)
-        @package.check_version!(release.version)
+      def prepare_publication(release)
         @git.commit!(release)
         @package.build!(release)
         @git.tag!(release)
-        @package.publish!(release)
+      end
+
+      def publish(release)
+        prepare_publication(release)
+        @destination.publish!(release, package: @package)
         @git.push!(release)
         @hosting&.publish!(release, package: @package)
       end
 
-      def prepare_next(release)
+      def prepare_next(ctx)
+        next_release = stage_next!(ctx.release)
+        @git.commit_next!(next_release)
+        @git.push!
+        ctx.record_next_version!(next_release.next_version)
+      end
+
+      def stage_next!(release)
         next_release = nil
         @git.stage_changes! do
-          next_release = release.with_next_version(@version.increment!)
+          next_release = release.with_next_version(@version.increment!(from: release.version))
           @changelog&.prepare_next!(next_release)
         end
-        @git.commit_next!(next_release)
-        @git.push!
+        next_release
       end
     end
   end

data/lib/ruby-gem-release/workflow/ruby_gems_credentials.rb

@@ -3,45 +3,36 @@
 require 'net/http'
 require 'json'
 require 'uri'
+require_relative '../execution_provider'
 
 module RubyGemRelease
   module Workflow
     class RubyGemsCredentials
-      def initialize(owner:)
-        raise ArgumentError, 'RubyGems owner must be a positive numeric account ID' unless /\A[1-9]\d*\z/.match?(owner.to_s)
-
+      def initialize(owner: nil, provider: ExecutionProvider.current)
         @owner = owner.to_s
+        raise ArgumentError, 'RubyGems owner must be a positive numeric account ID' unless @owner.empty? || /\A[1-9]\d*\z/.match?(@owner)
+
+        @provider = provider
       end
 
       def configure!
-        token = oidc_token
-        mask(token)
+        token = @provider.oidc_token(audience: 'rubygems.org')
+        @provider.mask(token)
         key = exchange_token(token)
-        mask(key)
-        File.open(ENV.fetch('GITHUB_ENV'), 'a') do |file|
-          %w[RUBYGEMS_API_KEY BUNDLE_GEM__PUSH_KEY GEM_HOST_API_KEY].each { |name| file.puts "#{name}=#{key}" }
-        end
+        @provider.mask(key)
+        @provider.export(%w[RUBYGEMS_API_KEY BUNDLE_GEM__PUSH_KEY GEM_HOST_API_KEY].to_h { |name| [name, key] })
       end
 
       private
 
-      def oidc_token
-        uri = URI(ENV.fetch('ACTIONS_ID_TOKEN_REQUEST_URL'))
-        raise ArgumentError, 'OIDC request URL must use HTTPS' unless uri.is_a?(URI::HTTPS)
-
-        query = URI.decode_www_form(uri.query || '').reject { |name, _value| name == 'audience' } # rubocop:disable Style/HashExcept -- Query pairs may contain duplicate keys.
-        uri.query = URI.encode_www_form(query + [['audience', 'rubygems.org']])
-        request = Net::HTTP::Get.new(uri)
-        request['Authorization'] = "Bearer #{ENV.fetch('ACTIONS_ID_TOKEN_REQUEST_TOKEN')}"
-        credential(response(uri, request), 'value')
-      end
-
       def exchange_token(token)
         uri = URI('https://rubygems.org/api/v1/oidc/trusted_publisher/exchange_token')
         request = Net::HTTP::Post.new(uri)
         request['Content-Type'] = 'application/json'
         request['Accept'] = 'application/json'
-        request.body = JSON.generate(jwt: token, owner: @owner)
+        body = { jwt: token }
+        body[:owner] = @owner unless @owner.empty?
+        request.body = JSON.generate(body)
         credential(response(uri, request), 'rubygems_api_key')
       end
 
@@ -49,7 +40,7 @@ module RubyGemRelease
         result = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 30, max_retries: 0) do |http|
           http.request(request)
         end
-        raise "Credential request failed (HTTP #{result.code}); verify owner ID and pending trusted publisher" unless result.is_a?(Net::HTTPSuccess)
+        raise "Credential request failed (HTTP #{result.code}); verify trusted publisher configuration and owner ID if supplied" unless result.is_a?(Net::HTTPSuccess)
 
         JSON.parse(result.body)
       rescue JSON::ParserError
@@ -62,10 +53,6 @@ module RubyGemRelease
 
         value
       end
-
-      def mask(value)
-        puts "::add-mask::#{value.gsub('%', '%25')}"
-      end
     end
   end
 end

data/lib/ruby-gem-release/workflow/semantic_ruby_gem.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'ruby_gem'
+require_relative '../semantic_release'
+require_relative '../changelog/generated'
+
+module RubyGemRelease
+  module Workflow
+    class SemanticRubyGem < RubyGem
+      attr_reader :semantic_release
+
+      def initialize(semantic_release: SemanticRelease.new, changelog: Changelog::Generated.new, bump: false, **)
+        raise ArgumentError, 'bump must be true or false' unless [true, false].include?(bump)
+
+        @semantic_release = semantic_release
+        @bump = bump
+        super(changelog: changelog, **)
+      end
+
+      private
+
+      def install_callbacks(tasks)
+        tasks.validate { |ctx| validate_release(ctx) }
+        tasks.prepare { |ctx| prepare_semantic_release(ctx) }
+        install_result_callbacks(tasks)
+        tasks.failure(&@failure) if @failure
+      end
+
+      def install_result_callbacks(tasks)
+        tasks.publish { |ctx| with_decision(ctx) { publish(ctx.release) } }
+        tasks.bump { |ctx| with_decision(ctx) { prepare_next(ctx) if @bump } }
+        tasks.success { |ctx| with_decision(ctx) { @success&.call(ctx) } }
+      end
+
+      def with_decision(ctx)
+        checked_decision(ctx)
+        yield
+      end
+
+      def validate_release(ctx)
+        decision = ctx.analysis || @semantic_release.analyze(head: @provider.fetch('SOURCE_COMMIT'), explicit_version: @provider.fetch('INPUT_VERSION', ''))
+        ctx.record_analysis!(decision) unless ctx.analysis
+        raise ArgumentError, 'Nothing to release: no release-eligible commits' unless decision.release?
+
+        @validate&.call(ctx)
+      end
+
+      def checked_decision(ctx)
+        raise ArgumentError, 'semantic release requires a persisted release decision' unless ctx.analysis&.release?
+
+        ctx.analysis.check!(head: @provider.fetch('SOURCE_COMMIT'), explicit_version: @provider.fetch('INPUT_VERSION', ''), version: ctx.release.version)
+        ctx.analysis
+      end
+
+      def prepare_semantic_release(ctx)
+        checked_decision(ctx)
+        @git.stage_changes! do
+          select_version!(ctx.release.version)
+          @changelog&.release!(ctx.release)
+        end
+      end
+    end
+  end
+end

data/lib/ruby-gem-release/workflow/state.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tempfile'
+require_relative '../version/ruby_constant'
+require_relative '../semantic_release/decision'
+
+module RubyGemRelease
+  module Workflow
+    class State
+      def self.create!(directory:)
+        file = Tempfile.create(['ruby-gem-release-state-', '.json'], directory)
+        file.write(JSON.generate('next_version' => nil, 'analysis' => nil))
+        file.path
+      ensure
+        file&.close
+      end
+
+      def initialize(path: nil)
+        @path = path unless path.to_s.empty?
+        @next_version = nil
+        @analysis = nil
+      end
+
+      def next_version
+        snapshot.fetch(:next_version)
+      end
+
+      def analysis
+        snapshot.fetch(:analysis)
+      end
+
+      def snapshot
+        return { next_version: @next_version, analysis: @analysis }.freeze unless @path
+
+        values, analysis = read_state
+        { next_version: values.fetch('next_version')&.freeze, analysis: analysis }.freeze
+      end
+
+      def record_analysis!(decision)
+        raise ArgumentError, 'analysis must be a semantic release decision' unless decision.is_a?(SemanticRelease::Decision)
+        raise ArgumentError, 'semantic analysis is already recorded' if analysis
+
+        if @path
+          persist(attributes.merge('analysis' => decision.to_h))
+        else
+          @analysis = decision
+        end
+        decision
+      end
+
+      def record_next_version!(version)
+        validate_version(version)
+        if @path
+          persist(attributes.merge('next_version' => version))
+        else
+          @next_version = version.dup.freeze
+        end
+        version
+      end
+
+      private
+
+      def attributes
+        read_state.first
+      end
+
+      def read_state
+        values = JSON.parse(File.read(@path))
+        valid = values.is_a?(Hash) && values.keys.sort == %w[analysis next_version]
+        raise ArgumentError, 'unsupported release state' unless valid
+
+        validate_version(values['next_version']) unless values['next_version'].nil?
+        raw_analysis = values['analysis']
+        analysis = SemanticRelease::Decision.from_h(raw_analysis) unless raw_analysis.nil?
+        [values, analysis]
+      end
+
+      def persist(values)
+        Tempfile.create(['.release-state-', '.json'], File.dirname(@path)) do |file|
+          file.write(JSON.generate(values))
+          file.close
+          File.rename(file.path, @path)
+        end
+      end
+
+      def validate_version(version)
+        return if version.is_a?(String) && Version::RubyConstant::PATTERN.match?(version)
+
+        raise ArgumentError, 'next version must be MAJOR.MINOR.PATCH'
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-gem-release
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Daniel Doubrovkine
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commonmarker
@@ -50,19 +50,41 @@ files:
 - lib/ruby-gem-release.rb
 - lib/ruby-gem-release/changelog.rb
 - lib/ruby-gem-release/changelog/base.rb
+- lib/ruby-gem-release/changelog/generated.rb
 - lib/ruby-gem-release/changelog/intridea.rb
 - lib/ruby-gem-release/changelog/keep_a_changelog.rb
+- lib/ruby-gem-release/destination.rb
+- lib/ruby-gem-release/destination/ruby_gems.rb
+- lib/ruby-gem-release/execution_context.rb
+- lib/ruby-gem-release/execution_context/github.rb
+- lib/ruby-gem-release/execution_context/github/run.rb
+- lib/ruby-gem-release/execution_context/github/step.rb
+- lib/ruby-gem-release/execution_context/step.rb
+- lib/ruby-gem-release/execution_provider.rb
+- lib/ruby-gem-release/execution_provider/github.rb
+- lib/ruby-gem-release/github_api.rb
 - lib/ruby-gem-release/hosting/github_release.rb
+- lib/ruby-gem-release/hosting/github_release/existing.rb
 - lib/ruby-gem-release/package/ruby_gem.rb
 - lib/ruby-gem-release/release.rb
+- lib/ruby-gem-release/release_failure.rb
+- lib/ruby-gem-release/semantic_release.rb
+- lib/ruby-gem-release/semantic_release/conventional_commits.rb
+- lib/ruby-gem-release/semantic_release/decision.rb
+- lib/ruby-gem-release/semantic_release/git_history.rb
+- lib/ruby-gem-release/semantic_release/release_notes.rb
+- lib/ruby-gem-release/semantic_release/version_selector.rb
 - lib/ruby-gem-release/source_control/git.rb
 - lib/ruby-gem-release/source_control/git/preparation.rb
 - lib/ruby-gem-release/tasks.rb
 - lib/ruby-gem-release/version.rb
 - lib/ruby-gem-release/version/ruby_constant.rb
-- lib/ruby-gem-release/workflow/context.rb
+- lib/ruby-gem-release/workflow/environment.rb
+- lib/ruby-gem-release/workflow/failure.rb
 - lib/ruby-gem-release/workflow/ruby_gem.rb
 - lib/ruby-gem-release/workflow/ruby_gems_credentials.rb
+- lib/ruby-gem-release/workflow/semantic_ruby_gem.rb
+- lib/ruby-gem-release/workflow/state.rb
 homepage: https://github.com/dblock/ruby-gem-release
 licenses:
 - MIT

data/lib/ruby-gem-release/workflow/context.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../package/ruby_gem'
-require_relative '../source_control/git'
-require_relative '../release'
-require_relative '../version/ruby_constant'
-
-module RubyGemRelease
-  module Workflow
-    class Context
-      def configure!
-        names = %w[INPUT_VERSION INPUT_GEMSPEC DEFAULT_BRANCH GIT_USER_NAME GIT_USER_EMAIL RUBYGEMS_OWNER]
-        timezone = ENV.fetch('TZ', 'UTC')
-        validate_timezone(timezone)
-        export(names.to_h { |name| [name, ENV.fetch(name)] }.merge('TZ' => timezone))
-      end
-
-      def capture!
-        check_branch
-        validate_timezone(ENV.fetch('TZ', 'UTC'))
-        git = configured_git
-        git.check_clean!
-        package = Package::RubyGem.new(gemspec: ENV.fetch('INPUT_GEMSPEC', nil))
-        release = initial_release(package)
-        git.check_current!(release)
-        export('TZ' => ENV.fetch('TZ', 'UTC'), 'GEMSPEC' => package.gemspec, 'RELEASE_PREVIOUS_VERSION' => release.version,
-               'RELEASE_DATE' => release.date.iso8601, 'RELEASE_INITIAL_COMMIT' => git.head)
-      end
-
-      def resolve!
-        package = Package::RubyGem.new
-        version = prepared_version(package)
-        git = SourceControl::Git.new
-        git.check_tag!(version)
-        package.check_version!(version)
-        git.stage_changes!
-        export('RELEASE_VERSION' => version)
-      end
-
-      private
-
-      def prepared_version(package)
-        version = package.version
-        validate_version(version)
-        selected = ENV.fetch('INPUT_VERSION', '')
-        raise "Prepared version #{version} does not match selected version #{selected}" unless selected.empty? || version == selected
-
-        version
-      end
-
-      def initial_release(package)
-        version = package.version
-        validate_version(version)
-        validate_version(ENV.fetch('INPUT_VERSION')) unless ENV.fetch('INPUT_VERSION', '').empty?
-        Release.new(version: version, previous_version: version, date: release_date)
-      end
-
-      def release_date
-        (ENV.key?('TZ') ? Time.now.getlocal : Time.now.utc).to_date
-      end
-
-      def validate_timezone(timezone)
-        valid = %r{\A[A-Za-z0-9_+-]+(?:/[A-Za-z0-9_+-]+)*\z}.match?(timezone) &&
-                File.file?(File.join('/usr/share/zoneinfo', timezone))
-        raise ArgumentError, 'timezone must identify an installed timezone, such as UTC or America/New_York' unless valid
-      end
-
-      def configured_git
-        SourceControl::Git.new.tap do |git|
-          git.configure!(name: ENV.fetch('GIT_USER_NAME', 'github-actions[bot]'),
-                         email: ENV.fetch('GIT_USER_EMAIL', 'github-actions[bot]@users.noreply.github.com'))
-        end
-      end
-
-      def check_branch
-        return if ENV.fetch('GITHUB_REF') == "refs/heads/#{ENV.fetch('DEFAULT_BRANCH')}"
-
-        raise 'Releases must run from the default branch'
-      end
-
-      def validate_version(version)
-        raise ArgumentError, 'Version must be MAJOR.MINOR.PATCH without leading zeros' unless Version::RubyConstant::PATTERN.match?(version)
-      end
-
-      def export(values)
-        raise ArgumentError, 'Workflow values cannot contain line breaks' if values.values.any? { |value| value.match?(/[\r\n]/) }
-
-        File.open(ENV.fetch('GITHUB_ENV'), 'a') do |file|
-          values.each do |key, value|
-            file.puts "#{key}=#{value}"
-          end
-        end
-      end
-    end
-  end
-end