ruby-gem-release 0.4.0 → 0.5.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'execution_context'
+
+module RubyGemRelease
+  class ExecutionProvider
+    def self.current(environment: ENV)
+      return new(environment: environment) unless environment['GITHUB_ACTIONS'] == 'true'
+
+      require_relative 'execution_provider/github'
+      GitHub.new(environment: environment)
+    end
+
+    def initialize(environment: ENV)
+      @environment = environment
+    end
+
+    def fetch(name, *defaults)
+      @environment.fetch(name, *defaults)
+    end
+
+    def directory
+      value = fetch('RELEASE_DATA_DIR', nil)
+      value unless value.to_s.empty?
+    end
+
+    def ref
+      fetch('SOURCE_REF')
+    end
+
+    def git_identity
+      { name: fetch('GIT_USER_NAME', 'ruby-gem-release'), email: fetch('GIT_USER_EMAIL', 'ruby-gem-release@localhost') }
+    end
+
+    def export(values)
+      validate_values(values)
+      @environment.update(values)
+    end
+
+    def context(**attributes)
+      ExecutionContext.new(**attributes)
+    end
+
+    def step_id(task)
+      ExecutionContext.step_id(task)
+    end
+
+    def failed_steps
+      []
+    end
+
+    def oidc_token(audience:)
+      raise NotImplementedError, 'execution provider does not support OIDC'
+    end
+
+    def mask(_value); end
+
+    private
+
+    def validate_values(values)
+      raise ArgumentError, 'Workflow names must be identifiers' unless values.keys.all? { |name| name.is_a?(String) && /\A[A-Za-z_][A-Za-z0-9_]*\z/.match?(name) }
+      raise ArgumentError, 'Workflow values cannot contain line breaks' if values.values.any? { |value| value.match?(/[\r\n]/) }
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+module RubyGemRelease
+  class GitHubAPI
+    def initialize(repository: nil)
+      @repository = repository || '{owner}/{repo}'
+    end
+
+    def get(path)
+      output, error, status = Open3.capture3('gh', 'api', '--include', endpoint(path))
+      headers, body = output.split(/\r?\n\r?\n/, 2)
+      code = headers.to_s[%r{\AHTTP/[\d.]+ (\d{3})}, 1]
+      return if code == '404'
+      raise "GitHub API request failed (HTTP #{code || 'unknown'}): #{error.strip}" unless status.success? && code == '200'
+
+      JSON.parse(body)
+    end
+
+    def download(path)
+      output, error, status = Open3.capture3('gh', 'api', endpoint(path), '--header', 'Accept: application/octet-stream')
+      raise "GitHub asset download failed: #{error.strip}" unless status.success?
+
+      output
+    end
+
+    private
+
+    def endpoint(path)
+      "repos/#{@repository}/#{path}"
+    end
+  end
+end

data/lib/ruby-gem-release/hosting/github_release/existing.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'digest'
+require_relative '../../github_api'
+
+module RubyGemRelease
+  module Hosting
+    class GitHubRelease
+      class Existing
+        def initialize(repository:)
+          @api = GitHubAPI.new(repository: repository)
+        end
+
+        def missing(release, paths)
+          @attributes = @api.get("releases/tags/v#{release.version}")
+          return paths unless @attributes
+
+          validate_release(release)
+          paths.reject { |path| matching_asset?(path) }
+        end
+
+        def exists?
+          !@attributes.nil?
+        end
+
+        def url
+          @attributes.fetch('html_url')
+        end
+
+        def changed?(release)
+          expected = { 'name' => "v#{release.version}", 'draft' => false, 'prerelease' => false }
+          expected['body'] = release.notes if release.notes
+          expected.any? { |key, value| @attributes[key] != value }
+        end
+
+        private
+
+        def validate_release(release)
+          tag = "v#{release.version}"
+          valid = @attributes.is_a?(Hash) && @attributes['tag_name'] == tag && @attributes['assets'].is_a?(Array)
+          raise 'Existing GitHub Release conflicts with the intended release' unless valid
+        end
+
+        def matching_asset?(path)
+          matches = @attributes.fetch('assets').select { |asset| asset['name'] == File.basename(path) }
+          raise 'Existing GitHub Release has duplicate asset names' if matches.size > 1
+          return false if matches.empty?
+
+          asset_digest(matches.first) == Digest::SHA256.file(path).hexdigest
+        end
+
+        def asset_digest(asset)
+          digest = asset['digest']
+          return digest.delete_prefix('sha256:') if digest.is_a?(String) && /\Asha256:[0-9a-f]{64}\z/.match?(digest)
+
+          id = asset['id']
+          raise 'Existing GitHub asset cannot be verified' unless id.is_a?(Integer) && id.positive?
+
+          Digest::SHA256.hexdigest(@api.download("releases/assets/#{id}"))
+        end
+      end
+    end
+  end
+end

data/lib/ruby-gem-release/hosting/github_release.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'open3'
+require 'tempfile'
+require_relative 'github_release/existing'
 
 module RubyGemRelease
   module Hosting
@@ -13,12 +15,13 @@ module RubyGemRelease
       end
 
       def publish!(release, package: nil, artifacts: [])
-        version = release.version
-        raise ArgumentError, 'release version must be MAJOR.MINOR.PATCH' unless version.is_a?(String) && /\A(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\z/.match?(version)
+        paths = release_paths(release, package, artifacts)
+        existing = Existing.new(repository: @repository)
+        missing = existing.missing(release, paths)
+        return upload_missing(release, existing, missing) if existing.exists?
 
-        tag = "v#{version}"
-        paths = artifact_paths(package ? [package.artifact(release)] : artifacts)
-        output, error, status = Open3.capture3(*command(tag), *paths)
+        tag = "v#{release.version}"
+        output, error, status = create_release(tag, paths, release.notes)
         raise "GitHub Release creation failed: #{error.strip}" unless status.success?
 
         output.strip
@@ -26,10 +29,53 @@ module RubyGemRelease
 
       private
 
+      def release_paths(release, package, artifacts)
+        version = release.version
+        raise ArgumentError, 'release version must be MAJOR.MINOR.PATCH' unless version.is_a?(String) && /\A(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\z/.match?(version)
+        raise ArgumentError, 'release notes must not be empty' if release.notes && release.notes.strip.empty?
+
+        artifact_paths(package ? [package.artifact(release)] : artifacts)
+      end
+
+      def upload_missing(release, existing, paths)
+        edit_release(release) if existing.changed?(release)
+        unless paths.empty?
+          command = ['gh', 'release', 'upload', "v#{release.version}", '--clobber']
+          command.push('--repo', @repository) if @repository
+          _output, error, status = Open3.capture3(*command, *paths)
+          raise "GitHub asset upload failed: #{error.strip}" unless status.success?
+        end
+        existing.url
+      end
+
+      def create_release(tag, paths, notes)
+        arguments = command(tag)
+        arguments << '--generate-notes' if notes.nil?
+        run_with_notes(arguments, notes, paths)
+      end
+
+      def run_with_notes(arguments, notes, paths = [])
+        return Open3.capture3(*arguments, *paths) if notes.nil?
+
+        Tempfile.create(['ruby-gem-release-notes-', '.md']) do |file|
+          file.write(notes)
+          file.close
+          Open3.capture3(*arguments, '--notes-file', file.path, *paths)
+        end
+      end
+
+      def edit_release(release)
+        tag = "v#{release.version}"
+        arguments = ['gh', 'release', 'edit', tag, '--title', tag, '--draft=false', '--prerelease=false']
+        arguments.push('--repo', @repository) if @repository
+        _output, error, status = run_with_notes(arguments, release.notes)
+        raise "GitHub Release update failed: #{error.strip}" unless status.success?
+      end
+
       def command(tag)
         arguments = ['gh', 'release', 'create', tag]
         arguments.push('--repo', @repository) if @repository
-        arguments.push('--verify-tag', '--title', tag, '--generate-notes')
+        arguments.push('--verify-tag', '--title', tag)
       end
 
       def artifact_paths(artifacts)

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

@@ -6,8 +6,6 @@ require 'json'
 require 'digest'
 require 'fileutils'
 require 'tmpdir'
-require 'net/http'
-require 'uri'
 
 module RubyGemRelease
   module Package
@@ -15,29 +13,31 @@ module RubyGemRelease
       attr_reader :directory, :gemspec
 
       def initialize(gemspec: nil, directory: nil)
-        @gemspec = resolve_gemspec(gemspec || ENV.fetch('GEMSPEC', nil))
-        @directory = directory || ENV['RUNNER_TEMP'] || Dir.mktmpdir('ruby-gem-release-')
+        @gemspec = resolve_gemspec(gemspec || ENV.fetch('GEMSPEC_PATH', nil))
+        directory ||= ENV.fetch('RELEASE_DATA_DIR', nil)
+        @directory = directory.to_s.empty? ? Dir.mktmpdir('ruby-gem-release-') : directory
       end
 
       def version
-        specification.fetch('version')
-      end
-
-      def check_version!(version)
-        name = specification.fetch('name')
-        raise 'Invalid package name' unless name.is_a?(String) && /\A[A-Za-z0-9][A-Za-z0-9_.-]*\z/.match?(name)
-
-        check_published_version(name, version)
+        script = 'spec = Gem::Specification.load(ARGV.fetch(0)); abort "Cannot load gemspec" unless spec; puts JSON.generate(spec.version.to_s)'
+        JSON.parse(run(Gem.ruby, '-rrubygems', '-rjson', '-e', script, @gemspec))
       end
 
       def build!(release)
         FileUtils.mkdir_p(@directory)
-        run(Gem.ruby, '-S', 'gem', 'build', @gemspec, '--output', archive)
+        run({ 'SOURCE_DATE_EPOCH' => source_date_epoch }, Gem.ruby, '-S', 'gem', 'build', @gemspec, '--output', archive)
         @manifest = build_manifest(release)
         File.write(manifest_path, JSON.generate(@manifest))
         artifact(release)
       end
 
+      def built?(release)
+        return false unless File.exist?(archive) || File.exist?(manifest_path)
+
+        verified_manifest(release)
+        true
+      end
+
       def artifact(release)
         name = verified_manifest(release).fetch('name')
         raise 'Invalid package name' unless /\A[A-Za-z0-9][A-Za-z0-9_.-]*\z/.match?(name)
@@ -47,32 +47,11 @@ module RubyGemRelease
         path
       end
 
-      def publish!(release)
-        path = artifact(release)
-        check_published_version(verified_manifest(release).fetch('name'), release.version)
-        run(Gem.ruby, '-S', 'gem', 'push', path)
-      end
-
       private
 
-      def specification
-        script = 'spec = Gem::Specification.load(ARGV.fetch(0)); abort "Cannot load gemspec" unless spec; puts JSON.generate(name: spec.name, version: spec.version.to_s)'
-        JSON.parse(run(Gem.ruby, '-rrubygems', '-rjson', '-e', script, @gemspec))
-      end
-
-      def check_published_version(name, version)
-        response = version_response(name, version)
-        raise "#{name} #{version} is already published on RubyGems; do not republish it, see RELEASING.md for recovery" if response.code == '200'
-        return if response.code == '404'
-
-        raise "Cannot check RubyGems for #{name} #{version} (HTTP #{response.code}); verify RubyGems availability before retrying"
-      end
-
-      def version_response(name, version)
-        uri = URI("https://rubygems.org/api/v2/rubygems/#{URI.encode_www_form_component(name)}/versions/#{URI.encode_www_form_component(version)}.json")
-        Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 30, max_retries: 0) { |http| http.get(uri.request_uri) }
-      rescue Timeout::Error, SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError => e
-        raise "Cannot check RubyGems for #{name} #{version}: #{e.message}; verify connectivity before retrying"
+      def source_date_epoch
+        value = ENV.fetch('SOURCE_DATE_EPOCH', '').strip
+        value.empty? ? '315619200' : value
       end
 
       def build_manifest(release)
@@ -87,9 +66,15 @@ module RubyGemRelease
         raise 'Package version does not match release' unless manifest.fetch('version') == release.version
         raise 'Built artifact changed; refusing publication' unless Digest::SHA256.file(archive).hexdigest == manifest.fetch('sha256')
 
+        verify_metadata!(manifest, release)
         manifest
       end
 
+      def verify_metadata!(manifest, release)
+        spec = Gem::Package.new(archive).spec
+        raise 'Artifact metadata differs from manifest' unless spec.name == manifest.fetch('name') && spec.version.to_s == release.version
+      end
+
       def archive
         File.join(@directory, 'release.gem')
       end

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

@@ -4,31 +4,37 @@ require 'date'
 
 module RubyGemRelease
   class Release
-    attr_reader :version, :previous_version, :next_version, :date
+    attr_reader :version, :gemspec_version, :next_version, :date, :notes
 
-    def initialize(date:, version:, previous_version:, next_version: nil)
-      validate_versions(version, previous_version, next_version)
-      raise ArgumentError, 'date must be a Date' unless date.instance_of?(Date)
+    def initialize(date:, version:, gemspec_version:, next_version: nil, notes: nil)
+      validate_versions(version, gemspec_version, next_version)
+      validate_metadata(date, notes)
 
       @version = version.dup.freeze
-      @previous_version = previous_version.dup.freeze
+      @gemspec_version = gemspec_version.dup.freeze
       @next_version = next_version&.dup&.freeze
       @date = date.dup.freeze
+      @notes = notes&.dup&.freeze
       freeze
     end
 
     def with_version(version)
-      self.class.new(version: version, previous_version: @previous_version, date: @date, next_version: @next_version)
+      self.class.new(version: version, gemspec_version: @gemspec_version, date: @date, next_version: @next_version, notes: @notes)
     end
 
     def with_next_version(version)
-      self.class.new(version: @version, previous_version: @previous_version, date: @date, next_version: version)
+      self.class.new(version: @version, gemspec_version: @gemspec_version, date: @date, next_version: version, notes: @notes)
     end
 
     private
 
-    def validate_versions(version, previous_version, next_version)
-      raise ArgumentError, 'release versions must be strings' unless [version, previous_version].all?(String) && (next_version.nil? || next_version.is_a?(String))
+    def validate_metadata(date, notes)
+      raise ArgumentError, 'date must be a Date' unless date.instance_of?(Date)
+      raise ArgumentError, 'release notes must be a string or nil' unless notes.nil? || notes.is_a?(String)
+    end
+
+    def validate_versions(version, gemspec_version, next_version)
+      raise ArgumentError, 'release versions must be strings' unless [version, gemspec_version].all?(String) && (next_version.nil? || next_version.is_a?(String))
     end
   end
 end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyGemRelease
+  class ReleaseFailure
+    class CapturedError < StandardError
+      attr_reader :original_class
+
+      def self.capture(error)
+        new(original_class: error.class.name || error.class.to_s, message: error.message, backtrace: error.backtrace)
+      end
+
+      def self.from_h(attributes)
+        new(original_class: attributes.fetch('class'), message: attributes.fetch('message'), backtrace: attributes.fetch('backtrace'))
+      end
+
+      def initialize(original_class:, message:, backtrace:)
+        @original_class = original_class.freeze
+        super(message)
+        set_backtrace(backtrace)
+      end
+
+      def to_h
+        { 'class' => original_class, 'message' => message, 'backtrace' => backtrace }
+      end
+    end
+
+    attr_reader :phase, :error, :context
+
+    def initialize(phase:, error:, context:)
+      @phase = phase.dup.freeze
+      @error = error
+      @context = context
+      freeze
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'decision'
+
+module RubyGemRelease
+  class SemanticRelease
+    class ConventionalCommits
+      SELECTORS = %i[type scope subject breaking revert].freeze
+
+      def initialize(rules: [])
+        @rules = rules.map do |rule|
+          validate_rule(rule)
+          rule.to_h { |key, value| [key, value.is_a?(String) ? value.dup.freeze : value] }.freeze
+        end.freeze
+      end
+
+      def analyze(commits)
+        parsed(commits).filter_map { |commit| release_type(commit) }.max_by { |type| Decision::TYPES.index(type) }
+      end
+
+      def parsed(commits)
+        parsed = commits.reject { |commit| commit.fetch('message').strip.empty? }.map { |commit| parse(commit) }
+        cancelled = []
+        parsed.reverse_each do |commit|
+          next if cancelled.include?(commit) || !commit[:revert]
+
+          original = reverted_original(parsed, commit, cancelled)
+          cancelled.push(commit, original) if original
+        end
+        parsed - cancelled
+      end
+
+      private
+
+      def reverted_original(commits, revert, cancelled)
+        commits.find { |commit| commit != revert && commit[:sha].start_with?(revert[:revert]) && !cancelled.include?(commit) }
+      end
+
+      def parse(commit)
+        message = commit.fetch('message')
+        attributes = parsed_header(message.lines(chomp: true).first.to_s)
+        notes = breaking_notes(message)
+        notes << attributes[:subject] if attributes[:breaking] && notes.empty?
+        attributes.merge(sha: commit.fetch('sha'), notes: notes, breaking: attributes[:breaking] || !notes.empty?,
+                         revert: message[/^This reverts commit ([0-9a-f]{7,64})\./i, 1])
+      end
+
+      def parsed_header(header)
+        match = /\A([A-Za-z0-9_-]+)(?:\(([^()\r\n]+)\))?(!)?: (.+)\z/.match(header)
+        return { type: nil, scope: nil, subject: header, breaking: false } unless match
+
+        { type: match[1], scope: match[2], subject: match[4], breaking: match[3] == '!' }
+      end
+
+      def breaking_notes(message)
+        message.split(/^(?=BREAKING(?: CHANGE|-CHANGE):|[A-Za-z][A-Za-z-]*(?:: | #))/).filter_map do |section|
+          match = /\ABREAKING(?: CHANGE|-CHANGE):[ \t]*(.*)/m.match(section)
+          match[1].strip if match
+        end
+      end
+
+      def release_type(commit)
+        matches = @rules.select { |rule| matches?(commit, rule) }
+        return default_type(commit) if matches.empty?
+
+        matches.filter_map { |rule| rule[:release].to_s unless rule[:release] == false }.max_by { |type| Decision::TYPES.index(type) }
+      end
+
+      def default_type(commit)
+        return 'major' if commit[:breaking]
+        return 'minor' if commit[:type] == 'feat'
+        return 'patch' if commit[:revert] || %w[fix perf].include?(commit[:type])
+
+        nil
+      end
+
+      def matches?(commit, rule)
+        rule.all? do |key, value|
+          next true if key == :release
+          next value ? commit[key] : !commit[key] if %i[breaking revert].include?(key)
+
+          commit[key].is_a?(String) && File.fnmatch?(value, commit[key])
+        end
+      end
+
+      def validate_rule(rule)
+        valid = rule.is_a?(Hash) && (rule.keys - [*SELECTORS, :release]).empty? && rule.key?(:release) &&
+                (rule[:release] == false || Decision::TYPES.include?(rule[:release].to_s))
+        raise ArgumentError, 'release rules require supported selectors and major, minor, patch, or false' unless valid
+
+        validate_selectors(rule.except(:release))
+      end
+
+      def validate_selectors(selectors)
+        selectors.each do |key, value|
+          valid = %i[breaking revert].include?(key) ? [true, false].include?(value) : value.is_a?(String)
+          raise ArgumentError, "invalid release rule selector: #{key}" unless valid
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative '../version/ruby_constant'
+require 'rubygems/version'
+
+module RubyGemRelease
+  class SemanticRelease
+    class Decision
+      ATTRIBUTES = %w[head last_release commits release_type version notes explicit_version].freeze
+      TYPES = %w[patch minor major].freeze
+      SHA = /\A[0-9a-f]{40}(?:[0-9a-f]{24})?\z/
+
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(head:, last_release:, commits:, release_type:, version:, notes:, explicit_version: nil)
+        validate_history(head, last_release, commits)
+        validate_selection(last_release, release_type, version, notes, explicit_version)
+        values = { 'head' => head, 'last_release' => last_release, 'commits' => commits, 'release_type' => release_type,
+                   'version' => version, 'notes' => notes, 'explicit_version' => explicit_version }
+        @attributes = immutable_copy(values)
+        @attributes.each { |key, value| instance_variable_set("@#{key}", value) }
+        freeze
+      end
+
+      def self.from_h(attributes)
+        raise ArgumentError, 'unsupported semantic decision' unless attributes.is_a?(Hash) && attributes.keys.sort == ATTRIBUTES.sort
+
+        new(**attributes.transform_keys(&:to_sym))
+      end
+
+      def to_h
+        @attributes
+      end
+
+      def release?
+        !@version.nil?
+      end
+
+      def check!(head:, explicit_version:, version: nil)
+        explicit_version = nil if explicit_version == ''
+        raise ArgumentError, 'semantic decision belongs to another commit' unless @head == head
+        raise ArgumentError, 'explicit version changed after semantic analysis' unless @explicit_version == explicit_version
+        raise ArgumentError, 'release version differs from semantic decision' if version && @version != version
+      end
+
+      private
+
+      def validate_history(head, last_release, commits)
+        raise ArgumentError, 'invalid semantic history head' unless valid_sha?(head)
+        raise ArgumentError, 'invalid last semantic release' unless last_release.nil? || valid_last_release?(last_release)
+
+        validate_commits(commits)
+      end
+
+      def valid_last_release?(release)
+        release.is_a?(Hash) && release.keys.sort == %w[commit tag version] &&
+          valid_version?(release['version']) && release['tag'] == "v#{release['version']}" && valid_sha?(release['commit'])
+      end
+
+      def validate_commits(commits)
+        valid = commits.is_a?(Array) && commits.all? { |commit| valid_commit?(commit) }
+        raise ArgumentError, 'invalid semantic commits' unless valid && commits.map { |commit| commit['sha'] }.uniq.size == commits.size
+      end
+
+      def valid_commit?(commit)
+        commit.is_a?(Hash) && commit.keys.sort == %w[message sha] && valid_sha?(commit['sha']) && commit['message'].is_a?(String)
+      end
+
+      def validate_selection(last_release, type, version, notes, explicit)
+        raise ArgumentError, 'invalid semantic release type' unless type.nil? || TYPES.include?(type)
+
+        if version.nil?
+          validate_skipped_selection(type, notes, explicit)
+
+          return
+        end
+        validate_selected_version(type, version, notes, explicit)
+        return unless last_release && Gem::Version.new(version) <= Gem::Version.new(last_release.fetch('version'))
+
+        raise ArgumentError, 'semantic version must exceed the last release'
+      end
+
+      def validate_selected_version(type, version, notes, explicit)
+        valid = valid_version?(version) && notes.is_a?(String) && !notes.strip.empty? && [type, explicit].any? &&
+                (explicit.nil? || explicit == version)
+        raise ArgumentError, 'invalid semantic selection' unless valid
+      end
+
+      def validate_skipped_selection(type, notes, explicit)
+        raise ArgumentError, 'invalid skipped semantic decision' unless [type, notes, explicit].all?(&:nil?)
+      end
+
+      def valid_sha?(value)
+        value.is_a?(String) && SHA.match?(value)
+      end
+
+      def valid_version?(value)
+        value.is_a?(String) && Version::RubyConstant::PATTERN.match?(value)
+      end
+
+      def immutable_copy(value)
+        case value
+        when Hash then value.to_h { |key, entry| [key.dup.freeze, immutable_copy(entry)] }.freeze
+        when Array then value.map { |entry| immutable_copy(entry) }.freeze
+        when String then value.dup.freeze
+        else value
+        end
+      end
+    end
+  end
+end