openlanes 3.0.1 → 3.1.0

data/lib/openlanes/cli/resync/subcommands/prs.rb

@@ -28,82 +28,21 @@ module OpenLanes
         # @param options [Hash]
         # @return [void]
         def call(**options)
-          github = Vcs.github
           tree = tree_for(options)
-          changes = OpenLanes::Lifecycle.resync_prs(tree:,
-            github:,
-            adopt: options.fetch(:adopt, true),
-            root: File.dirname(tree.dir))
-                                        .call(commit: !dry_run?(options))
+          changes = unwrap(OpenLanes::Lifecycle.retitle_prs(tree:,
+            github: Vcs.github,
+            adopt:  options.fetch(:adopt, true),
+            root:   File.dirname(tree.dir),
+            commit: !dry_run?(options)))
 
           if changes.empty?
             success("Every pull request title already carries a prefix.") unless quiet?(options)
             return
           end
 
-          changes.each do |change|
-            puts "#{change.number}\t#{change.new_title || "-"}\t#{change.reason}"
-          end
-
-          return if quiet?(options)
-
-          report_pr_changes(changes, options)
-        rescue OpenLanes::Error => e
-          refuse(e.message, 69)
-        end
-
-        private
-
-        # @param changes [Array]
-        # @param options [Hash]
-        # @return [void]
-        def report_pr_changes(changes, options)
-          applicable, flagged = changes.partition(&:applicable?)
-          assumed = applicable.select(&:assumed?)
-
-          applicable.each do |c|
-            note = if c.adopted?
-                     paint("   (new plan)", :magenta)
-                   elsif c.assumed?
-                     paint("   (assumed)", :yellow)
-                   end
-            say("##{c.number}  #{c.new_title}#{note}")
-          end
-
-          report_adoptions(applicable.select(&:adopted?), options)
-
-          flagged.each { |c| say("##{c.number}  #{paint("SKIPPED", :red)} — #{c.reason}", bullet: "!") }
-
-          if dry_run?(options)
-            dry_run_footer(applicable.size, "retitle#{"s" unless applicable.size == 1}")
-          else
-            success("Retitled #{applicable.size} pull request#{"s" unless applicable.size == 1}.")
-          end
-
-          return if assumed.empty?
-
-          warn("#{assumed.size} title#{"s" unless assumed.size == 1} would get " \
-               "[#{OpenLanes::NO_PLAN_PREFIX}] because no plan resolved.\n\n" \
-               "That is an assertion about intent, and it is yours to make: check each one\n" \
-               "before committing. A pull request that writes a plan's spec belongs to that\n" \
-               "plan however its branch was named.")
-        end
-
-        # Creating folders is a bigger act than editing a title, so it is
-        # reported separately rather than buried in the retitle list.
-        #
-        # @param adopted [Array]
-        # @param options [Hash]
-        # @return [void]
-        def report_adoptions(adopted, options)
-          return if adopted.empty?
-
-          verb = dry_run?(options) ? "Would create" : "Created"
-          info("#{verb} #{adopted.size} plan folder#{"s" unless adopted.size == 1} for pull " \
-               "requests that resolved to no plan:\n\n" \
-               "#{adopted.map { |c| "  #{c.ordinal}  ##{c.number}  #{c.title}" }.join("\n")}\n\n" \
-               "Each holds its pull request and nothing else. Run `openlanes run`\n" \
-               "to have the specification written from what the pull request actually did.")
+          report = Presentation.pr_changes(changes, dry_run: dry_run?(options))
+          puts report.lines
+          report.report unless quiet?(options)
         end
       end
     end

data/lib/openlanes/cli/review/review.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module CLI
+    # `openlanes review PR LABEL` — move a pull request to its next review label.
+    #
+    # The one door through which a review label is set. Agents may not run
+    # `gh pr edit`, so a verdict reaches GitHub only by passing the CI rule in
+    # {Vcs::Review}, and this command is where a person, or hansolo, asks.
+    class Review < Base
+      desc "Replace a pull request's review label, refusing a passing verdict while CI is red"
+
+      argument :pull_request, required: true, desc: "Pull request number or URL, e.g. 12, #12"
+      argument :label,
+        required: true,
+        values:   Plans::ReviewLabel.names,
+        desc:     "One of: #{Plans::ReviewLabel.names.join(", ")}"
+
+      dry_run_option "Compute the transition and write nothing to GitHub"
+
+      example [
+        "12 #{Plans::ReviewLabel::INITIAL.name}   # label PR #12",
+        "12 #{Plans::ReviewLabel::REJECTED.name} -n   # what that would do"
+      ]
+
+      # @param pull_request [String]
+      # @param label [String]
+      # @param options [Hash]
+      # @return [void]
+      def call(pull_request:, label:, **options)
+        quiet?(options)
+        begin
+          # Checked here so a typo is a usage error, not a `gh` failure.
+          Plans::ReviewLabel.fetch(label)
+        rescue OpenLanes::Error => e
+          refuse(e.message, 64)
+        end
+
+        result = begin
+          Vcs.review.call(pr: pull_request, label:, dry_run: dry_run?(options))
+        rescue OpenLanes::Error => e
+          refuse(e.message, 69)
+        end
+        report(result)
+        exit 1 if result.refused?
+      end
+
+      private
+
+      # The deliverable on STDOUT, one tab-separated line, and the reading of
+      # it on STDERR.
+      #
+      # @param result [OpenLanes::Vcs::Review::Result]
+      # @return [void]
+      def report(result)
+        from = result.from.empty? ? "(none)" : result.from.join(", ")
+        puts "#{result.pr}\t#{from}\t#{result.to}\t#{result.ci}\t#{result.refused? ? "refused" : "ok"}"
+
+        if result.refused?
+          error("PR ##{result.pr} stays #{from}: #{result.reason}.\n" \
+                "Only #{Plans::ReviewLabel::REJECTED.name} and #{Plans::ReviewLabel::VULNERABILITY.name} " \
+                "are accepted until CI is green.")
+          return
+        end
+
+        say("PR ##{result.pr}: #{from} → #{paint(result.to, :green)} (CI #{result.ci})")
+        warn(result.reason) if result.reason
+        dry_run_footer(1, "label change") if result.dry_run?
+      end
+    end
+  end
+end