toys-release 0.1.0

data/toys/.lib/toys/release/request_logic.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Toys
+  module Release
+    ##
+    # Miscellaneous logic related to release requests.
+    #
+    class RequestLogic
+      ##
+      # Construct a RequestLogic
+      #
+      # @param repository [Toys::Release::Repository]
+      # @param request_spec [Toys::Release::RequestSpec]
+      # @param target_branch [String] Optional target branch. Defaults to the
+      #     current branch.
+      #
+      def initialize(repository, request_spec, target_branch: nil)
+        @repository = repository
+        @settings = repository.settings
+        @utils = repository.utils
+        @request_spec = request_spec
+        @target_branch = target_branch || @repository.current_branch
+      end
+
+      ##
+      # Perform component verification, including:
+      #
+      # * That there is at least one component to release in the request spec
+      # * That each component has not already released the specified version
+      #
+      def verify_component_status
+        if @request_spec.empty?
+          @utils.error("No components to release.")
+        end
+        @utils.accumulate_errors("One or more components was in an inconsistent state") do
+          @request_spec.resolved_components.each do |component_spec|
+            component = @repository.component_named(component_spec.component_name)
+            changelog_version = component.changelog_file.current_version
+            if changelog_version && changelog_version >= component_spec.version
+              @utils.error("Cannot add version #{component_spec.version} to #{component.name} changelog because the" \
+                " existing changelog already contains version #{changelog_version}.")
+            end
+            constant_version = component.version_rb_file.current_version
+            if constant_version >= component_spec.version
+              @utils.error("Cannot change #{component.name} version constant to #{component_spec.version} because the" \
+                " existing version constant is already at #{constant_version}.")
+            end
+          end
+        end
+        self
+      end
+
+      ##
+      # Attempt to verify that no other release pull request is already open
+      # for this release.
+      # This is currently somewhat conservative. If any multi-release pull
+      # request is already open for the target branch, it will be noted as
+      # conflicting, even if it doesn't actually overlap. We don't currently
+      # have logic to dig into the existing pull requests and determine which
+      # components they actually want to release.
+      #
+      def verify_pull_request_status
+        @utils.accumulate_errors("One or more existing release pull requests conflicts with this release") do
+          existing_prs = @repository.find_release_prs(branch: @target_branch)
+          if @request_spec.single_component?
+            component_name = @request_spec.resolved_components.first.component_name
+            release_branch_name = @repository.release_branch_name(@target_branch, component_name)
+            existing_prs.each do |pr|
+              if pr.head_ref == release_branch_name
+                @utils.error("A release pull request (##{pr.number}) is already open for #{component_name}")
+              elsif pr.head_ref =~ %r{release/multi/\d{14}-\d{6}/#{@target_branch}}
+                @utils.error("A release pull request (##{pr.number}) is already open for multiple components")
+              end
+            end
+          else
+            existing_prs.each do |pr|
+              if pr.head_ref.end_with?("/#{@target_branch}")
+                @utils.error("A release pull request (##{pr.number}) is already open")
+              end
+            end
+          end
+        end
+        self
+      end
+
+      ##
+      # @return [String] A release branch name for this release
+      #
+      def determine_release_branch
+        if @request_spec.single_component?
+          @repository.release_branch_name(@target_branch, @request_spec.resolved_components[0].component_name)
+        else
+          @repository.multi_release_branch_name(@target_branch)
+        end
+      end
+
+      ##
+      # @return [String] A commit title for this release
+      #
+      def build_commit_title
+        if @request_spec.single_component?
+          "release: Release #{format_component_info(@request_spec.resolved_components[0])}"
+        else
+          "release: Release #{@request_spec.resolved_components.size} items"
+        end
+      end
+
+      ##
+      # @return [String] Commit details for this release
+      #
+      def build_commit_details
+        if @request_spec.single_component?
+          ""
+        else
+          lines = @request_spec.resolved_components.map do |resolved_component|
+            "* #{format_component_info(resolved_component)}"
+          end
+          lines.join("\n")
+        end
+      end
+
+      ##
+      # @return [String] Pull reqeust body for this release
+      #
+      def build_pr_body
+        if @settings.enable_release_automation?
+          build_automation_pr_body
+        else
+          build_standalone_pr_body
+        end
+      end
+
+      ##
+      # @return [Array<String>] The set of labels to apply to a pull request
+      #
+      def determine_pr_labels
+        return unless @settings.enable_release_automation?
+        [@settings.release_pending_label]
+      end
+
+      ##
+      # Go through and update changelog and version files for each component.
+      #
+      def change_files
+        @request_spec.resolved_components.each do |resolved_component|
+          component = @repository.component_named(resolved_component.component_name)
+          component.changelog_file.append(resolved_component.change_set, resolved_component.version)
+          component.version_rb_file.update_version(resolved_component.version)
+        end
+      end
+
+      private
+
+      def format_component_info(resolved_component, bold: false)
+        last_release = resolved_component.last_version ? "was #{resolved_component.last_version}" : "initial release"
+        decor = bold ? "**" : ""
+        "#{decor}#{resolved_component.component_name} #{resolved_component.version}#{decor} (#{last_release})"
+      end
+
+      def build_automation_pr_body
+        <<~STR
+          #{build_pr_body_header}
+
+           *  To confirm this release, merge this pull request, ensuring the \
+          #{@settings.release_pending_label.inspect} label is set. The release \
+          script will trigger automatically on merge.
+           *  To abort this release, close this pull request without merging.
+
+          #{build_pr_body_footer}
+        STR
+      end
+
+      def build_standalone_pr_body
+        <<~STR
+          #{build_pr_body_header}
+
+          You can run the `release perform` script once these changes are merged.
+
+          #{build_pr_body_footer}
+        STR
+      end
+
+      def build_pr_body_header
+        lines = [
+          "This pull request prepares new releases for the following components:",
+          "",
+        ]
+        @request_spec.resolved_components.each do |resolved_component|
+          lines << " *  #{format_component_info(resolved_component, bold: true)}"
+        end
+        lines << ""
+        lines <<
+          "For each releasable component, this pull request modifies the" \
+            " version and provides an initial changelog entry based on" \
+            " [conventional commit](https://conventionalcommits.org) messages." \
+            " You can edit these changes before merging, to release a different" \
+            " version or to alter the changelog text."
+        lines.join("\n")
+      end
+
+      def build_pr_body_footer
+        lines = ["The generated changelog entries have been copied below:"]
+        @request_spec.resolved_components.each do |resolved_component|
+          lines << ""
+          lines << "----"
+          lines << ""
+          lines << "## #{resolved_component.component_name}"
+          lines << ""
+          resolved_component.change_set.change_groups.each do |group|
+            lines.concat(group.prefixed_changes.map { |line| " *  #{line}" })
+          end
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end

data/toys/.lib/toys/release/request_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative "semver"
+
+module Toys
+  module Release
+    ##
+    # Represents a release request specification.
+    #
+    class RequestSpec
+      ##
+      # Details about the resolved request for a particular component
+      #
+      # @!attribute [r] component_name
+      #   @return [String]
+      #
+      # @!attribute [r] change_set
+      #   @return [Toys::Release::ChangeSet]
+      #
+      # @!attribute [r] last_version
+      #   @return [::Gem::Version, nil]
+      #
+      # @!attribute [r] version
+      #   @return [::Gem::Version]
+      #
+      ResolvedComponent = ::Struct.new :component_name, :change_set, :last_version, :version
+
+      ##
+      # Create an empty request.
+      #
+      # @param environment_utils [Toys::Release::EnvironmentUtils]
+      #
+      def initialize(environment_utils)
+        @utils = environment_utils
+        @resolved_components = nil
+        @requested_components = {}
+        @release_sha = nil
+      end
+
+      ##
+      # @return [boolean] Whether the request has been resolved.
+      #
+      def resolved?
+        !@resolved_components.nil?
+      end
+
+      ##
+      # @return [boolean] Whether the request is empty, i.e. has no changed
+      #     components
+      #
+      def empty?
+        resolved_components.empty?
+      end
+
+      ##
+      # @return [boolean] Whether the request is for a single component
+      #
+      def single_component?
+        resolved_components.size == 1
+      end
+
+      ##
+      # @return [Array<ResolvedComponent>] Info about the components to release.
+      #     Valid only after resolution.
+      #
+      attr_reader :resolved_components
+
+      ##
+      # @return [String] The git SHA at which the release will be cut.
+      #     Valid only after resolution.
+      #
+      attr_reader :release_sha
+
+      ##
+      # Add a component and version constraint.
+      #
+      # @param component_name [String,:all] The name of the component to release
+      # @param version [::Gem::Version,Toys::Release::Semver,String,Symbol,nil]
+      #     The version to release, or the kind of version bump to use. If `nil`
+      #     (the default), infers a version bump from the changeset, and omits
+      #     the component if no release is needed.
+      #
+      def add(component_name, version: nil)
+        raise "Release request already resolved" if resolved?
+        if !version.nil? && !version.is_a?(::Gem::Version) && !version.is_a?(Semver)
+          name = version.to_s
+          version = if name =~ /^\d/
+                      ::Gem::Version.new(name)
+                    else
+                      Semver.for_name(name)
+                    end
+          @utils.error("Malformed version or semver name: #{name}") unless version
+        end
+        @utils.error("Cannot release with no version change") if version == Semver::NONE
+        if @requested_components[component_name] && @requested_components[component_name] != version
+          @utils.error("Requested release of #{component_name.inspect} twice with different versions")
+        else
+          @requested_components[component_name] = version
+        end
+        self
+      end
+
+      ##
+      # Resolve which components and versions to release.
+      #
+      # @param repository [Toys::Release::Repository]
+      # @param release_ref [String,nil] Git ref at which the release should be
+      #     cut. If nil, uses the current HEAD.
+      #
+      def resolve_versions(repository, release_ref: nil)
+        raise "Release request already resolved" if resolved?
+        @utils.accumulate_errors("Conflicts detected in the components and versions requested.") do
+          @release_sha = repository.current_sha(release_ref)
+          candidate_groups = determine_candidate_groups(repository)
+          @resolved_components = []
+          candidate_groups.each do |group, version|
+            resolved_group, version = resolve_one_group(group, version)
+            if version
+              resolved_group.each do |resolved_component|
+                resolved_component.version = version
+                resolved_component.change_set.force_release!
+              end
+              @resolved_components.concat(resolved_group)
+            end
+          end
+        end
+        self
+      end
+
+      private
+
+      ##
+      # Determines candidate groups, groups that could be released based on the
+      # release request alone (but we haven't yet checked commits.) Thus, the
+      # actual released groups will be a subset of this.
+      #
+      def determine_candidate_groups(repository)
+        candidate_groups = {}
+        if @requested_components.empty?
+          repository.coordination_groups.each { |group| candidate_groups[group] = nil }
+        else
+          @requested_components.each do |component_name, version|
+            component = repository.component_named(component_name)
+            unless component
+              @utils.error("Unknown component name #{component_name.inspect}")
+              next
+            end
+            group = component.coordination_group
+            group.each do |elem|
+              elem_name = elem.name
+              elem_version = @requested_components[elem_name]
+              if elem != component && version && elem_version && elem_version != version
+                @utils.error("#{component_name} #{version} implies #{elem_name} #{version} but " \
+                            "#{elem_name} #{elem_version} was already requested.")
+              end
+              candidate_groups[group] ||= version
+            end
+          end
+        end
+        candidate_groups
+      end
+
+      ##
+      # Resolves one candidate group. Returns an array of resolved components
+      # along with the version to release for the group.
+      #
+      def resolve_one_group(group, version)
+        suggested_next_version = nil
+        resolved_group = group.map do |component|
+          last_version = component.latest_tag_version(ref: @release_sha)
+          if last_version && version.is_a?(::Gem::Version) && last_version >= version
+            @utils.error("Requested #{component.name} #{version} but #{last_version} is the latest.")
+          end
+          latest_tag = component.version_tag(last_version)
+          changeset = component.make_change_set(from: latest_tag, to: @release_sha)
+          unless version.is_a?(::Gem::Version)
+            cur_suggested = version ? version.bump(last_version) : changeset.suggested_version(last_version)
+            if suggested_next_version.nil? || (cur_suggested && cur_suggested > suggested_next_version)
+              suggested_next_version = cur_suggested
+            end
+          end
+          ResolvedComponent.new(component.name, changeset, last_version, nil)
+        end
+        [resolved_group, suggested_next_version || version]
+      end
+    end
+  end
+end

data/toys/.lib/toys/release/semver.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Toys
+  module Release
+    ##
+    # A semver level
+    #
+    class Semver
+      class << self
+        ##
+        # Return the semver level for the given name.
+        #
+        # @param name [String,Symbol] The name
+        # @return [Semver] The semver level
+        # @return [nil] If the name is not recognized
+        #
+        def for_name(name)
+          @name_mapping[name.to_s.downcase]
+        end
+      end
+
+      include ::Comparable
+
+      ##
+      # @return [Symbol] The name of this semver level
+      #
+      attr_reader :name
+
+      ##
+      # @return [Integer,nil] Which version segment to bump (0 is major), or
+      #     nil for the "none" level.
+      #
+      attr_reader :segment
+
+      ##
+      # @return [boolean] Whether this semver implies any change
+      #
+      def significant?
+        !segment.nil?
+      end
+
+      ##
+      # @return [String] The name of this semver level as a string
+      #
+      def to_s
+        name.to_s
+      end
+
+      ##
+      # Bump the given version.
+      #
+      # @param version [::Gem::Version] The original version
+      # @return [::Gem::Version] The new version
+      #
+      def bump(version)
+        return version if segment.nil?
+        bump_seg = segment
+        version_segs = version&.segments || [0, 0, 0]
+        max_seg = bump_seg
+        max_seg = 2 if max_seg < 2
+        version_segs = version_segs[0..max_seg]
+        bump_seg = 1 if bump_seg.zero? && version_segs[0].zero?
+        version_segs[bump_seg] += 1
+        ::Gem::Version.new(version_segs.fill(0, bump_seg + 1).join("."))
+      end
+
+      # @private
+      def initialize(name, segment)
+        @name = name
+        @segment = segment
+      end
+
+      # @private
+      def <=>(other)
+        (other.segment || 99) <=> (segment || 99)
+      end
+
+      ##
+      # Major version bump
+      #
+      MAJOR = new(:major, 0)
+
+      ##
+      # Minor version bump
+      #
+      MINOR = new(:minor, 1)
+
+      ##
+      # Patch version bump
+      #
+      PATCH = new(:patch, 2)
+
+      ##
+      # Patch2 version bump
+      #
+      PATCH2 = new(:patch2, 3)
+
+      ##
+      # No version bump
+      #
+      NONE = new(:none, nil)
+
+      @name_mapping = {
+        "major" => MAJOR,
+        "minor" => MINOR,
+        "patch" => PATCH,
+        "patch2" => PATCH2,
+        "none" => NONE,
+      }
+    end
+  end
+end