plan_my_stuff 0.1.0 → 1.0.0

data/app/controllers/plan_my_stuff/webhooks/github_controller.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module PlanMyStuff
+  module Webhooks
+    class GithubController < ActionController::API
+      before_action :verify_signature
+
+      # POST /webhooks/github
+      def create
+        event = request.headers['X-GitHub-Event']
+
+        case event
+        when 'pull_request'
+          handle_pull_request
+        when 'issues'
+          handle_issues
+        when 'projects_v2_item'
+          handle_projects_v2_item
+        end
+
+        head(:ok)
+      end
+
+      private
+
+        # Validates HMAC-SHA256 signature from the X-Hub-Signature-256 header.
+        #
+        # @return [void]
+        #
+        def verify_signature
+          body = request.body.read
+          request.body.rewind
+
+          signature = request.headers['X-Hub-Signature-256'].to_s.gsub('sha256=', '')
+          if signature.blank?
+            head(:unauthorized)
+
+            return
+          end
+
+          digest = OpenSSL::Digest.new('sha256')
+          secret = PlanMyStuff.configuration.webhook_secret
+          hmac = OpenSSL::HMAC.hexdigest(digest, secret, body)
+
+          return if ActiveSupport::SecurityUtils.secure_compare(hmac, signature)
+
+          head(:unauthorized)
+        end
+
+        # @return [ActionController::Parameters]
+        def payload_params
+          @payload_params ||=
+            begin
+              body = request.body.read
+              request.body.rewind
+              ActionController::Parameters.new(JSON.parse(body))
+            end
+        end
+
+        # @return [ActionController::Parameters]
+        def pull_request_params
+          payload_params.fetch(:pull_request)
+        end
+
+        # @return [ActionController::Parameters]
+        def issue_params
+          payload_params.fetch(:issue)
+        end
+
+        # @return [void]
+        def handle_issues
+          action = payload_params.fetch(:action)
+
+          case action
+          when 'assigned'
+            handle_issue_assigned
+          when 'unassigned'
+            handle_issue_unassigned
+          end
+        end
+
+        # Adds the issue to the pipeline project at "Started" the first time it is assigned. Re-assigns and
+        # additional assignees are ignored -- if the issue is already in the pipeline we do not touch its status.
+        #
+        # Skipped paths (no project item is created):
+        #   - Issue is closed (assignment changes on a closed issue must not alter the pipeline)
+        #   - Issue has pending approvals (creating + +take!+ would either orphan an item or 500 on the approval guard)
+        #
+        # GitHub already records the issue assignment (that's what triggered this webhook), so the gem does not
+        # call +assign!+ on the project item -- that would clobber co-assignees on the underlying issue.
+        #
+        # Regardless of pipeline state, +mark_responded!+ stamps +metadata.responded_at+ when a support user is the
+        # assignee -- including self-assigns to issues already in the pipeline. The method's own guards no-op for
+        # non-support assignees and already-responded issues.
+        #
+        # @return [void]
+        #
+        def handle_issue_assigned
+          return if issue_params[:state] == 'closed'
+
+          issue_number = issue_params.fetch(:number)
+          assignee_login = payload_params.dig(:assignee, :login)
+
+          return if assignee_login.blank?
+
+          repo = payload_params.dig(:repository, :full_name)
+          issue = PlanMyStuff::Issue.find(issue_number, repo: repo)
+          assignee_user = PlanMyStuff::UserResolver.from_github_login(assignee_login)
+
+          # Stamp before the already-in-pipeline early-return so a support user self-assigning to an
+          # already-taken issue still records a first response.
+          issue.mark_responded!(assignee_user)
+
+          existing = PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue_number)
+          if existing.present?
+            Rails.logger.info("[PlanMyStuff] Issue ##{issue_number} already in pipeline project, skipping")
+
+            return
+          end
+
+          if issue.approvals_required? && !issue.fully_approved?
+            Rails.logger.info("[PlanMyStuff] Issue ##{issue_number} has pending approvals, skipping")
+
+            return
+          end
+
+          number = PlanMyStuff::Pipeline.resolve_pipeline_project_number!
+          project_item = PlanMyStuff::ProjectItem.create!(issue, project_number: number)
+          PlanMyStuff::Pipeline.take!(project_item, user: assignee_user)
+        end
+
+        # Removes the issue from the pipeline project when the LAST assignee is removed. If any assignees remain,
+        # the webhook is a no-op (only one of N was removed). If the issue isn't in the pipeline at all, also a
+        # no-op (logged at info).
+        #
+        # Closed issues are skipped: assignment changes on a closed issue must not alter the pipeline. Items
+        # already on the release cycle (Ready for Release, Release in Progress, Completed) are also locked --
+        # once on the release path an item should not come off via webhook.
+        #
+        # @return [void]
+        #
+        def handle_issue_unassigned
+          return if issue_params[:state] == 'closed'
+
+          remaining_assignees = Array.wrap(issue_params[:assignees])
+          return if remaining_assignees.present?
+
+          issue_number = issue_params.fetch(:number)
+          project_item = PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue_number)
+
+          if project_item.nil?
+            Rails.logger.info(
+              "[PlanMyStuff] Issue ##{issue_number} not in pipeline project, skipping remove!",
+            )
+
+            return
+          end
+
+          if PlanMyStuff::Pipeline.release_cycle_locked?(project_item)
+            Rails.logger.info(
+              "[PlanMyStuff] Issue ##{issue_number} on release cycle (#{project_item.status}), skipping remove!",
+            )
+
+            return
+          end
+
+          PlanMyStuff::Pipeline.remove!(project_item)
+        end
+
+        # Handles GitHub's +projects_v2_item+ webhook event. Mirrors a dev dragging an item from "Submitted" to
+        # "Started" on the project board into a +Pipeline.take!+ call so the +pipeline_started.plan_my_stuff+
+        # event fires.
+        #
+        # Only acts on +action: 'edited'+ where the Status single-select field changed on the pipeline project.
+        # No-ops when the new status is anything other than "Started", when the +from+ status is already "Started"
+        # (loop guard from +move_to!+ triggering another webhook), or when the item cannot be located on the
+        # pipeline project.
+        #
+        # @return [void]
+        #
+        def handle_projects_v2_item
+          return unless payload_params[:action] == 'edited'
+
+          item_project_node_id = payload_params.dig(:projects_v2_item, :project_node_id)
+          return if item_project_node_id.blank?
+
+          pipeline_number = PlanMyStuff::Pipeline.resolve_pipeline_project_number!
+          project = PlanMyStuff::Project.find(pipeline_number)
+          return unless project.id == item_project_node_id
+
+          field_value = payload_params.dig(:changes, :field_value)
+          return if field_value.blank?
+
+          return unless field_value[:field_name] == 'Status'
+
+          started_name = PlanMyStuff::Pipeline.resolve_status_name(
+            PlanMyStuff::Pipeline::Status::STARTED,
+          )
+
+          to_name = field_value.dig(:to, :name)
+          from_name = field_value.dig(:from, :name)
+
+          # Moved from 'Started'
+          return if from_name == started_name
+
+          # Moved to something other than 'Started'
+          return unless to_name == started_name
+
+          item_node_id = payload_params.dig(:projects_v2_item, :node_id)
+          return if item_node_id.blank?
+
+          project_item = project.items.find { |item| item.id == item_node_id }
+
+          if project_item.nil?
+            Rails.logger.info(
+              "[PlanMyStuff] projects_v2_item #{item_node_id} not found in pipeline project, skipping take!",
+            )
+
+            return
+          end
+
+          PlanMyStuff::Pipeline.take!(project_item)
+        end
+
+        # @return [void]
+        def handle_pull_request
+          action = payload_params.fetch(:action)
+
+          # Only PRs targeting +main+ drive pipeline transitions on open/draft/reopen. PRs into +production+ are
+          # deploy PRs (often auto-created as drafts) and must not bump items back to "Started". The +closed+
+          # branch handles its own base-ref routing.
+          if %w[opened ready_for_review reopened converted_to_draft].include?(action)
+            base_ref = pull_request_params.dig(:base, :ref)
+            return unless base_ref == PlanMyStuff.configuration.main_branch
+          end
+
+          case action
+          when 'opened'
+            pull_request_params[:draft] ? handle_draft_opened : handle_ready_for_review
+          when 'ready_for_review', 'reopened'
+            handle_ready_for_review
+          when 'converted_to_draft'
+            handle_converted_to_draft
+          when 'closed'
+            handle_closed
+          end
+        end
+
+        # Opening a PR as a draft is a soft "I've started working on this" signal. For each linked issue, when
+        # the issue is not yet in the pipeline, add it at "Started"; when the issue has no assignees, assign the
+        # PR author. Already-in-pipeline items are NOT moved (a draft open is not a status change).
+        #
+        # @return [void]
+        #
+        def handle_draft_opened
+          repo = payload_params.dig(:repository, :full_name)
+          pr_author = pull_request_params.dig(:user, :login)
+
+          each_linked_issue_number do |issue_number|
+            issue = PlanMyStuff::Issue.find(issue_number, repo: repo)
+
+            if PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue_number).nil?
+              ensure_in_pipeline_at_started(issue, pr_author)
+            end
+
+            assign_pr_author(issue, pr_author) if pr_author.present? && issue.assignees.empty?
+          end
+        end
+
+        # @return [void]
+        def handle_ready_for_review
+          each_linked_item do |item|
+            PlanMyStuff::Pipeline.mark_in_review!(item)
+          end
+        end
+
+        # Adds the issue to the pipeline at "Started". Skipped when the issue has pending approvals
+        # (Pipeline.take!'s guard would otherwise leave an orphan project item behind).
+        #
+        # @param issue [PlanMyStuff::Issue]
+        # @param actor_login [String, nil] GitHub login of the webhook actor, mapped to a user via +github_login_for+
+        #
+        # @return [void]
+        #
+        def ensure_in_pipeline_at_started(issue, actor_login = nil)
+          if issue.approvals_required? && !issue.fully_approved?
+            Rails.logger.info("[PlanMyStuff] Issue ##{issue.number} has pending approvals, skipping pipeline add")
+            return
+          end
+
+          number = PlanMyStuff::Pipeline.resolve_pipeline_project_number!
+          project_item = PlanMyStuff::ProjectItem.create!(issue, project_number: number)
+          PlanMyStuff::Pipeline.take!(project_item, user: PlanMyStuff::UserResolver.from_github_login(actor_login))
+        end
+
+        # @param issue [PlanMyStuff::Issue]
+        # @param pr_author [String]
+        #
+        # @return [void]
+        #
+        def assign_pr_author(issue, pr_author)
+          PlanMyStuff::Issue.update!(number: issue.number, repo: issue.repo, assignees: [pr_author])
+        end
+
+        # @return [void]
+        def handle_converted_to_draft
+          each_linked_item do |item|
+            PlanMyStuff::Pipeline.take!(item)
+          end
+        end
+
+        # @return [void]
+        def handle_closed
+          return unless pull_request_params[:merged]
+
+          base_ref = pull_request_params.dig(:base, :ref)
+          config = PlanMyStuff.configuration
+
+          if base_ref == config.main_branch
+            each_linked_item do |item|
+              PlanMyStuff::Pipeline.mark_ready_for_release!(item)
+            end
+          elsif base_ref == config.production_branch
+            PlanMyStuff::Pipeline.start_deployment!(commit_sha: pull_request_params[:merge_commit_sha])
+          end
+        end
+
+        # @yield [PlanMyStuff::ProjectItem]
+        def each_linked_item
+          each_linked_issue_number do |issue_number|
+            item = PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue_number)
+
+            if item
+              yield(item)
+            else
+              Rails.logger.info("[PlanMyStuff] Issue ##{issue_number} not found in pipeline project, skipping")
+            end
+          end
+        end
+
+        # @yield [Integer] linked issue number
+        def each_linked_issue_number(&)
+          messages = fetch_commit_messages
+          numbers = PlanMyStuff::Pipeline::IssueLinker.extract_issue_numbers(
+            pull_request_params,
+            commit_messages: messages,
+          )
+
+          numbers.each(&)
+        end
+
+        # Fetches commit messages for the current PR via the GitHub API.
+        #
+        # @return [Array<String>] commit messages (empty on failure)
+        #
+        def fetch_commit_messages
+          repo = payload_params.dig(:repository, :full_name)
+          pr_number = pull_request_params[:number]
+
+          # TODO? Add a PR class
+          commits = PlanMyStuff.client.rest(:pull_request_commits, repo, pr_number)
+          commits.map { |c| c[:commit][:message] }
+        rescue PlanMyStuff::APIError => e
+          Rails.logger.warn("[PlanMyStuff] Failed to fetch PR commits: #{e.message}")
+          []
+        end
+    end
+  end
+end

data/app/jobs/plan_my_stuff/application_job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  # Base class for all PMS gem jobs. Subclasses +::ActiveJob::Base+ so the gem doesn't depend on the consuming app
+  # having an +ApplicationJob+ constant.
+  class ApplicationJob < ::ActiveJob::Base
+  end
+end

data/app/jobs/plan_my_stuff/reminders_sweep_job.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  # Daily-cadence sweep job for reminder dispatch + inactivity auto-close. Consuming apps enqueue it once; the job
+  # self-requeues after each perform so the schedule persists without requiring a cron/whenever setup.
+  # Queue-adapter-agnostic: runs through ActiveJob's +set(wait_until:).perform_later+ so any backend works.
+  class RemindersSweepJob < PlanMyStuff::ApplicationJob
+    queue_as :default
+
+    # Only try once per enqueue. Without this, Delayed-style adapters retry up to 25 times on error and our
+    # +around_perform+ +ensure+ re-enqueues a follow-up run on every attempt, causing geometric duplicate
+    # pile-up. With +attempts: 1+, exactly one perform per +perform_later+; if it fails, the follow-up scheduled
+    # in +ensure+ takes over tomorrow.
+    retry_on StandardError, attempts: 1
+
+    around_perform :requeue_for_next_run
+
+    class << self
+      # Next sweep time. Default: 6:30am Eastern tomorrow (today if the current time is before 6:30am ET). Apps
+      # wanting a different cadence override this on a subclass.
+      #
+      # @return [Time] UTC
+      #
+      def next_run
+        now = Time.current.in_time_zone('Eastern Time (US & Canada)')
+        target = now.change(hour: 6, min: 30, sec: 0)
+        target += 1.day if target <= now
+        target.utc
+      end
+
+      # Schedules a sweep for +next_run+. Used by the after-perform self-requeue and the
+      # +plan_my_stuff:reminders:sweep+ rake task so both kick off runs on the same cadence (instead of "now").
+      #
+      # @param repo [Symbol, String]
+      #
+      # @return [ActiveJob::Base]
+      #
+      def requeue(repo)
+        set(wait_until: next_run).perform_later(repo)
+      end
+    end
+
+    # @param repo [Symbol, String]
+    #
+    # @return [void]
+    #
+    def perform(repo)
+      @repo_arg = repo
+      PlanMyStuff::Reminders::Sweep.new(repo: repo).call
+      PlanMyStuff::Archive::Sweep.new(repo: repo).call
+      PlanMyStuff::Pipeline::CompletedSweep.perform!
+    end
+
+    private
+
+      # Runs inside +around_perform+. Re-enqueues the next run in an +ensure+ so a perform error still schedules
+      # the next one. Skips requeue when perform never captured a repo arg (deserialization error or direct
+      # +.perform+ call with missing kwargs).
+      #
+      # @return [void]
+      #
+      def requeue_for_next_run
+        yield
+      ensure
+        enqueue_next_run
+      end
+
+      # @return [void]
+      def enqueue_next_run
+        return if @repo_arg.nil?
+
+        self.class.requeue(@repo_arg)
+      end
+  end
+end

data/app/views/plan_my_stuff/comments/edit.html.erb

@@ -1,8 +1,6 @@
 <h1>Edit Comment</h1>
 
-<% if flash[:error].present? %>
-  <p style="color: red;"><%= flash[:error] %></p>
-<% end %>
+<%= render({ partial: 'plan_my_stuff/partials/flash' }) %>
 
 <%=
   render({

data/app/views/plan_my_stuff/comments/partials/_form.html.erb

@@ -1,3 +1,4 @@
+<%# locals: (issue:, comment:, support_user:) %>
 <%
   persisted = comment.persisted?
   url =
@@ -24,6 +25,13 @@
         )
       %>
     </div>
+
+    <% unless persisted %>
+      <div>
+        <%= form.check_box(:waiting_on_reply) %>
+        <%= form.label(:waiting_on_reply, 'Waiting on reply') %>
+      </div>
+    <% end %>
   <% end %>
 
   <div>

data/app/views/plan_my_stuff/issues/edit.html.erb

@@ -1,10 +1,8 @@
 <h1>Edit Issue #<%= @issue.number %></h1>
 
-<% if flash[:error].present? %>
-  <p style="color: red;"><%= flash[:error] %></p>
-<% end %>
+<%= render({ partial: 'plan_my_stuff/partials/flash' }) %>
 
-<%= render({ partial: 'plan_my_stuff/issues/partials/form', locals: { issue: @issue, support_user: @support_user } }) %>
+<%= render({ partial: 'plan_my_stuff/issues/partials/form', locals: { issue: @issue } }) %>
 
 <% if @support_user %>
   <hr>

data/app/views/plan_my_stuff/issues/index.html.erb

@@ -1,6 +1,6 @@
 <h1>Issues</h1>
 
-<% if @issues.any? %>
+<% if @issues.present? %>
   <table>
     <thead>
       <tr>
@@ -14,7 +14,7 @@
       <% @issues.each do |issue| %>
         <tr>
           <td><%= issue.number %></td>
-          <td><%= link_to(issue.title, plan_my_stuff.issue_path(issue.number)) %></td>
+          <td><%= link_to(issue.title, plan_my_stuff.issue_path(issue)) %></td>
           <td><%= issue.state %></td>
           <td><%= issue.labels.join(', ') %></td>
         </tr>
@@ -24,14 +24,14 @@
 
   <nav>
     <% if @page > 1 %>
-      <%= link_to('Previous', plan_my_stuff.issues_path(page: @page - 1, state: @state, labels: @labels)) %>
+      <%= link_to('Previous', plan_my_stuff.issues_path(page: @page - 1, state: @state, labels: @labels, repo: @repo)) %>
     <% end %>
     <% if @issues.size == @per_page %>
-      <%= link_to('Next', plan_my_stuff.issues_path(page: @page + 1, state: @state, labels: @labels)) %>
+      <%= link_to('Next', plan_my_stuff.issues_path(page: @page + 1, state: @state, labels: @labels, repo: @repo)) %>
     <% end %>
   </nav>
 <% else %>
   <p>No issues found.</p>
 <% end %>
 <br>
-<%= link_to "New Issue", plan_my_stuff.new_issue_path %>
+<%= link_to('New Issue', plan_my_stuff.new_issue_path(repo: @repo)) %>

data/app/views/plan_my_stuff/issues/new.html.erb

@@ -1,7 +1,5 @@
 <h1>New Issue</h1>
 
-<% if flash[:error].present? %>
-  <p style="color: red;"><%= flash[:error] %></p>
-<% end %>
+<%= render({ partial: 'plan_my_stuff/partials/flash' }) %>
 
-<%= render({ partial: 'plan_my_stuff/issues/partials/form', locals: { issue: @issue, support_user: @support_user } }) %>
+<%= render({ partial: 'plan_my_stuff/issues/partials/form', locals: { issue: @issue } }) %>

data/app/views/plan_my_stuff/issues/partials/_approvals.html.erb

@@ -0,0 +1,108 @@
+<%# locals: (issue:, support_user:, current_user_id_local:) %>
+<%
+  approvers = issue.approvers
+  pending_count = issue.pending_approvals.size
+  rejected_count = issue.rejected_approvals.size
+  current_user_id = current_user_id_local
+%>
+
+<% if issue.approvals_required? || support_user %>
+  <section aria-label="Manager approvals">
+    <h3>Approvals</h3>
+
+    <% if issue.approvals_required? %>
+      <% if issue.fully_approved? %>
+        <p><strong>Fully approved</strong></p>
+      <% else %>
+        <p>
+          <strong><%= pending_count %> of <%= approvers.size %> approval(s) pending</strong>
+          <% if rejected_count.positive? %>
+            (<%= rejected_count %> rejected)
+          <% end %>
+        </p>
+      <% end %>
+
+      <ul>
+        <% approvers.each do |approval| %>
+          <li>
+            <%= PlanMyStuff::UserResolver.display_name(approval.user) %> &mdash;
+            <% if approval.approved? %>
+              approved
+              <% if approval.approved_at %>
+                at <%= approval.approved_at.iso8601 %>
+              <% end %>
+            <% elsif approval.rejected? %>
+              rejected
+              <% if approval.rejected_at %>
+                at <%= approval.rejected_at.iso8601 %>
+              <% end %>
+            <% else %>
+              pending
+            <% end %>
+
+            <% if approval.pending? && approval.user_id == current_user_id %>
+              <%=
+                button_to(
+                  'Approve',
+                  plan_my_stuff.issue_approval_path(issue, approval.user_id),
+                  method: :patch,
+                  params: { approval: { status: 'approved' } },
+                  form: { style: 'display:inline' },
+                )
+              %>
+              <%=
+                button_to(
+                  'Reject',
+                  plan_my_stuff.issue_approval_path(issue, approval.user_id),
+                  method: :patch,
+                  params: { approval: { status: 'rejected' } },
+                  form: { style: 'display:inline' },
+                )
+              %>
+            <% end %>
+
+            <% if !approval.pending? && (approval.user_id == current_user_id || support_user) %>
+              <%=
+                button_to(
+                  'Revoke',
+                  plan_my_stuff.issue_approval_path(issue, approval.user_id),
+                  method: :patch,
+                  params: { approval: { status: 'pending' } },
+                  form: { style: 'display:inline' },
+                )
+              %>
+            <% end %>
+
+            <% if support_user %>
+              <%=
+                button_to(
+                  'Remove',
+                  plan_my_stuff.issue_approval_path(issue, approval.user_id),
+                  method: :delete,
+                  form: { style: 'display:inline' },
+                )
+              %>
+            <% end %>
+          </li>
+        <% end %>
+      </ul>
+    <% else %>
+      <p><em>No approvers required</em></p>
+    <% end %>
+
+    <% if support_user %>
+      <%=
+        form_with(
+          scope: :approval,
+          url: plan_my_stuff.issue_approvals_path(issue),
+          method: :post,
+          local: true,
+        ) do |form|
+      %>
+        <%= form.label(:user_ids, 'Add approver IDs (comma-separated)') %>
+        <%= form.text_field(:user_ids) %>
+        <%= form.submit('Add Approvers') %>
+      <% end %>
+    <% end %>
+  </section>
+<% end %>

data/app/views/plan_my_stuff/issues/partials/_form.html.erb

@@ -1,9 +1,14 @@
-<% persisted = issue.persisted? %>
-<%= form_with(
-  url: persisted ? plan_my_stuff.issue_path(issue.number) : plan_my_stuff.issues_path,
-  method: persisted ? :patch : :post,
-  scope: :issue,
-) do |form| %>
+<%# locals: (issue:) %>
+<%
+  persisted = issue.persisted?
+  url =
+    if persisted
+      plan_my_stuff.issue_path(issue)
+    else
+      plan_my_stuff.issues_path(repo: issue.repo&.full_name)
+    end
+%>
+<%= form_with(url: url, method: persisted ? :patch : :post, scope: :issue) do |form| %>
   <div>
     <%= form.label(:title, 'Title') %>
     <%= form.text_field(:title, value: issue.title) %>