plan_my_stuff 0.1.0 → 1.0.0

data/app/controllers/plan_my_stuff/issues/testings_controller.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  module Issues
+    # Toggles the pipeline +Testing+ custom field on an issue's project item via
+    # +PlanMyStuff::Pipeline.request_testing!+ and +PlanMyStuff::Pipeline.clear_testing!+. Backs the "Request testing" /
+    # "Clear testing" buttons on the mounted issue show view.
+    #
+    # POST   /issues/:issue_id/testing -> create  (flips +Testing+ to its active value)
+    # DELETE /issues/:issue_id/testing -> destroy (flips +Testing+ back to inactive)
+    #
+    class TestingsController < PlanMyStuff::ApplicationController
+      before_action :require_support_user
+
+      # POST /issues/:issue_id/testing
+      def create
+        issue = PlanMyStuff::Issue.find(params[:issue_id])
+        project_item = find_project_item!(issue)
+
+        PlanMyStuff::Pipeline.request_testing!(project_item, user: pms_current_user)
+
+        yield(project_item) if block_given?
+        return if performed?
+
+        flash[:success] = "Issue ##{issue.number} marked as in testing."
+        redirect_to(plan_my_stuff.issue_path(issue))
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.issue_path(params[:issue_id]))
+      end
+
+      # DELETE /issues/:issue_id/testing
+      def destroy
+        issue = PlanMyStuff::Issue.find(params[:issue_id])
+        project_item = find_project_item!(issue)
+
+        PlanMyStuff::Pipeline.clear_testing!(project_item, user: pms_current_user)
+
+        yield(project_item) if block_given?
+        return if performed?
+
+        flash[:success] = "Issue ##{issue.number} testing cleared."
+        redirect_to(plan_my_stuff.issue_path(issue))
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.issue_path(params[:issue_id]))
+      end
+
+      private
+
+        # Redirects non-support users back to the issue page. Mirrors +Issues::TakesController+'s authorization check.
+        #
+        # @return [void]
+        #
+        def require_support_user
+          return if support_user?
+
+          redirect_to_unauthorized(
+            plan_my_stuff.issue_path(params[:issue_id]),
+          )
+        end
+
+        # Looks up the pipeline project item for the issue, raising if missing. Defensive against a stale view (button
+        # rendered before the item was removed) or a race with another tab removing the issue from the pipeline.
+        #
+        # @raise [PlanMyStuff::Error] if the issue is not in the pipeline
+        #
+        # @param issue [PlanMyStuff::Issue]
+        #
+        # @return [PlanMyStuff::ProjectItem]
+        #
+        def find_project_item!(issue)
+          project_item = PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue.number)
+          return project_item if project_item.present?
+
+          raise(PlanMyStuff::Error, "Issue ##{issue.number} is not in the pipeline.")
+        end
+    end
+  end
+end

data/app/controllers/plan_my_stuff/issues/viewers_controller.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  module Issues
+    # Handles adding and removing viewers from the visibility allowlist via CRUD-style routes.
+    # Backs the viewer management UI on the issue edit view (T-045).
+    #
+    # POST   /issues/:issue_id/viewers      -> create  (adds viewer(s))
+    # DELETE /issues/:issue_id/viewers/:id  -> destroy (removes a viewer)
+    #
+    class ViewersController < PlanMyStuff::ApplicationController
+      # POST /issues/:issue_id/viewers
+      def create
+        unless support_user?
+          redirect_to_unauthorized(plan_my_stuff.issue_path(params[:issue_id]))
+          return
+        end
+
+        viewer_ids = parse_viewer_ids(params[:viewer_ids])
+        if viewer_ids.blank?
+          flash[:error] = 'No valid viewer IDs provided.'
+          redirect_to(plan_my_stuff.edit_issue_path(params[:issue_id]))
+          return
+        end
+
+        issue = PlanMyStuff::Issue.find(params[:issue_id])
+        issue.add_viewers!(user_ids: viewer_ids, user: pms_current_user)
+
+        yield(issue) if block_given?
+        return if performed?
+
+        flash[:success] = 'Viewers were successfully added.'
+        redirect_to(plan_my_stuff.edit_issue_path(params[:issue_id]))
+      rescue PlanMyStuff::Error, Octokit::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.edit_issue_path(params[:issue_id]))
+      end
+
+      # DELETE /issues/:issue_id/viewers/:id
+      def destroy
+        unless support_user?
+          redirect_to_unauthorized(plan_my_stuff.issue_path(params[:issue_id]))
+          return
+        end
+
+        issue = PlanMyStuff::Issue.find(params[:issue_id])
+        issue.remove_viewers!(user_ids: [params[:id].to_i], user: pms_current_user)
+
+        yield(issue) if block_given?
+        return if performed?
+
+        flash[:success] = 'Viewer was successfully removed.'
+        redirect_to(plan_my_stuff.edit_issue_path(params[:issue_id]))
+      rescue PlanMyStuff::Error, Octokit::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.edit_issue_path(params[:issue_id]))
+      end
+    end
+  end
+end

data/app/controllers/plan_my_stuff/issues/waitings_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  module Issues
+    # Toggles the waiting-on-user state on an issue via CRUD-style routes.
+    # Backs the "Mark waiting" / "Mark replied" button on the issue show view.
+    #
+    # POST   /issues/:issue_id/waiting -> create  (enters waiting-on-user)
+    # DELETE /issues/:issue_id/waiting -> destroy (clears waiting-on-user)
+    #
+    class WaitingsController < PlanMyStuff::ApplicationController
+      # POST /issues/:issue_id/waiting
+      def create
+        unless support_user?
+          redirect_to_unauthorized(plan_my_stuff.issue_path(params[:issue_id]))
+          return
+        end
+
+        issue = PlanMyStuff::Issue.find(params[:issue_id])
+        issue.enter_waiting_on_user!(user: pms_current_user)
+
+        yield(issue) if block_given?
+        return if performed?
+
+        flash[:success] = 'Issue marked as waiting on user reply.'
+        redirect_to(plan_my_stuff.issue_path(issue))
+      rescue PlanMyStuff::Error, ArgumentError => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.issue_path(params[:issue_id]))
+      end
+
+      # DELETE /issues/:issue_id/waiting
+      def destroy
+        unless support_user?
+          redirect_to_unauthorized(plan_my_stuff.issue_path(params[:issue_id]))
+          return
+        end
+
+        issue = PlanMyStuff::Issue.find(params[:issue_id])
+        issue.clear_waiting_on_user!
+
+        yield(issue) if block_given?
+        return if performed?
+
+        flash[:success] = 'Waiting-on-user state cleared.'
+        redirect_to(plan_my_stuff.issue_path(issue))
+      rescue PlanMyStuff::Error, ArgumentError => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.issue_path(params[:issue_id]))
+      end
+    end
+  end
+end

data/app/controllers/plan_my_stuff/issues_controller.rb

@@ -1,65 +1,76 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class IssuesController < ApplicationController
+  class IssuesController < PlanMyStuff::ApplicationController
     # GET /issues
     def index
       @page = (params[:page] || 1).to_i
       @per_page = (params[:per_page] || 25).to_i
       @state = (params[:state] || 'open').to_sym
       @labels = params[:labels].present? ? Array.wrap(params[:labels]) : []
-      @repo = params[:repo]&.to_sym
+      @repo = params[:repo]
 
-      @issues = PMS::Issue.list(
+      @issues = PlanMyStuff::Issue.list(
         repo: @repo,
         state: @state,
         labels: @labels,
         page: @page,
         per_page: @per_page,
       )
+
+      yield(@issues) if block_given?
     end
 
     # GET /issues/new
     def new
-      @issue = PMS::Issue.new
-      @support_user = support_user?
+      @issue = PlanMyStuff::Issue.new
+
+      yield(@issue) if block_given?
     end
 
     # POST /issues
     def create
-      @issue = PMS::Issue.create!(
+      @issue = PlanMyStuff::Issue.create!(
         title: issue_params[:title],
         body: issue_params[:body],
         labels: parse_labels(issue_params[:labels]),
         user: pms_current_user,
       )
 
+      yield(@issue) if block_given?
+      return if performed?
+
       flash[:success] = 'Issue was successfully created.'
-      redirect_to(plan_my_stuff.issue_path(@issue.number))
-    rescue PMS::ValidationError => e
-      @issue = PMS::Issue.new(title: issue_params[:title], body: issue_params[:body])
-      @support_user = support_user?
+      redirect_to(plan_my_stuff.issue_path(@issue))
+    rescue PlanMyStuff::ValidationError => e
+      pms_handle_rescue(e)
+      @issue = PlanMyStuff::Issue.new(title: issue_params[:title], body: issue_params[:body])
       flash.now[:error] = e.message
-      render(:new, status: PMS.unprocessable_status)
+      render(:new, status: PlanMyStuff.unprocessable_status)
     end
 
     # GET /issues/:id
     def show
-      @issue = PMS::Issue.find(params[:id].to_i, repo: params[:repo]&.to_sym)
+      @issue = PlanMyStuff::Issue.find(params[:id])
       @comments = filter_visible_comments(@issue.comments)
-      @support_user = support_user?
-      @current_user_id = pms_current_user.present? ? PMS::UserResolver.user_id(pms_current_user) : nil
+      @current_user_id = pms_current_user.present? ? PlanMyStuff::UserResolver.user_id(pms_current_user) : nil
+      @current_user_login = PlanMyStuff.configuration.github_login_for[@current_user_id]
+      @pipeline_enabled = PlanMyStuff.configuration.pipeline_enabled
+      @pipeline_item = load_pipeline_item(@issue.number) if @pipeline_enabled
+
+      yield(@issue) if block_given?
     end
 
     # GET /issues/:id/edit
     def edit
-      @issue = PMS::Issue.find(params[:id].to_i, repo: params[:repo]&.to_sym)
-      @support_user = support_user?
+      @issue = PlanMyStuff::Issue.find(params[:id])
+
+      yield(@issue) if block_given?
     end
 
     # PATCH/PUT /issues/:id
     def update
-      @issue = PMS::Issue.find(params[:id].to_i, repo: params[:repo]&.to_sym)
+      @issue = PlanMyStuff::Issue.find(params[:id])
 
       @issue.update!(
         title: issue_params[:title],
@@ -67,58 +78,19 @@ module PlanMyStuff
         labels: parse_labels(issue_params[:labels]),
       )
 
+      yield(@issue) if block_given?
+      return if performed?
+
       flash[:success] = 'Issue was successfully updated.'
-      redirect_to(plan_my_stuff.issue_path(@issue.number))
-    rescue PMS::StaleObjectError
-      @support_user = support_user?
+      redirect_to(plan_my_stuff.issue_path(@issue))
+    rescue PlanMyStuff::StaleObjectError => e
+      pms_handle_rescue(e)
       flash.now[:error] = 'Issue was modified by someone else. Please review the latest changes and try again.'
-      render(:edit, status: PMS.unprocessable_status)
-    end
-
-    # PATCH /issues/:id/close
-    def close
-      @issue = PMS::Issue.find(params[:id].to_i, repo: params[:repo]&.to_sym)
-      @issue.update!(state: :closed)
-
-      flash[:success] = 'Issue was successfully closed.'
-      redirect_to(plan_my_stuff.issue_path(@issue.number))
-    end
-
-    # PATCH /issues/:id/reopen
-    def reopen
-      @issue = PMS::Issue.find(params[:id].to_i, repo: params[:repo]&.to_sym)
-      @issue.update!(state: :open)
-
-      flash[:success] = 'Issue was successfully reopened.'
-      redirect_to(plan_my_stuff.issue_path(@issue.number))
-    end
-
-    # POST /issues/:id/add_viewers
-    def add_viewers
-      return redirect_to_unauthorized(plan_my_stuff.issue_path(params[:id])) unless support_user?
-
-      viewer_ids = parse_viewer_ids(params[:viewer_ids])
-      if viewer_ids.blank?
-        flash[:error] = 'No valid viewer IDs provided.'
-        redirect_to(plan_my_stuff.edit_issue_path(params[:id]))
-        return
-      end
-
-      PMS::Issue.add_viewers(number: params[:id].to_i, user_ids: viewer_ids, repo: params[:repo]&.to_sym)
-
-      flash[:success] = 'Viewers were successfully added.'
-      redirect_to(plan_my_stuff.edit_issue_path(params[:id]))
-    end
-
-    # DELETE /issues/:id/remove_viewer
-    def remove_viewer
-      return redirect_to_unauthorized(plan_my_stuff.issue_path(params[:id])) unless support_user?
-
-      viewer_id = params[:viewer_id].to_i
-      PMS::Issue.remove_viewers(number: params[:id].to_i, user_ids: [viewer_id], repo: params[:repo]&.to_sym)
-
-      flash[:success] = 'Viewer was successfully removed.'
-      redirect_to(plan_my_stuff.edit_issue_path(params[:id]))
+      render(:edit, status: PlanMyStuff.unprocessable_status)
+    rescue PlanMyStuff::ValidationError => e
+      pms_handle_rescue(e)
+      flash.now[:error] = e.message
+      render(:edit, status: PlanMyStuff.unprocessable_status)
     end
 
     private
@@ -129,7 +101,6 @@ module PlanMyStuff
       end
 
       # Filters comments to only those visible to the current user.
-      # Falls back to showing all comments if no current_user is available.
       #
       # @param comments [Array<PlanMyStuff::Comment>]
       #
@@ -137,9 +108,21 @@ module PlanMyStuff
       #
       def filter_visible_comments(comments)
         user = pms_current_user
-        return comments unless user
-
         comments.select { |comment| comment.visible_to?(user) }
       end
+
+      # Looks up the pipeline ProjectItem for this issue, if any. Returns nil when the item cannot be loaded for any
+      # reason -- issue show should never break because the pipeline lookup failed.
+      #
+      # @param issue_number [Integer]
+      #
+      # @return [PlanMyStuff::ProjectItem, nil]
+      #
+      def load_pipeline_item(issue_number)
+        PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue_number)
+      rescue ArgumentError, PlanMyStuff::Error => e
+        Rails.logger.warn("[PlanMyStuff] Failed to load pipeline item for issue ##{issue_number}: #{e.message}")
+        nil
+      end
   end
 end

data/app/controllers/plan_my_stuff/labels_controller.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class LabelsController < ApplicationController
+  class LabelsController < PlanMyStuff::ApplicationController
     # POST /issues/:issue_id/labels
-    def add_to_issue
+    def create
       labels = parse_labels(params[:label_name])
       if labels.blank?
         flash[:error] = 'Label name is required.'
@@ -11,20 +11,42 @@ module PlanMyStuff
         return
       end
 
-      issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo]&.to_sym)
-      PMS::Label.add(issue: issue, labels: labels)
+      issue = PlanMyStuff::Issue.find(params[:issue_id])
+
+      missing = labels.reject { |label| PlanMyStuff::Label.exists?(repo: issue.repo, name: label) }
+      if missing.any?
+        flash[:error] = "Label#{'s' if missing.size > 1} not found in repo: #{missing.join(', ')}"
+        redirect_to(plan_my_stuff.issue_path(issue))
+        return
+      end
+
+      PlanMyStuff::Label.add!(issue: issue, labels: labels)
+
+      yield(issue) if block_given?
+      return if performed?
 
       flash[:success] = 'Label was successfully added.'
-      redirect_to(plan_my_stuff.issue_path(issue.number))
+      redirect_to(plan_my_stuff.issue_path(issue))
+    rescue PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
+      flash[:error] = e.message
+      redirect_to(plan_my_stuff.issue_path(params[:issue_id]))
     end
 
-    # DELETE /issues/:issue_id/labels/:name
-    def remove_from_issue
-      issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo]&.to_sym)
-      PMS::Label.remove(issue: issue, labels: [params[:name]])
+    # DELETE /issues/:issue_id/labels/:id
+    def destroy
+      issue = PlanMyStuff::Issue.find(params[:issue_id])
+      PlanMyStuff::Label.remove!(issue: issue, labels: [params[:id]])
+
+      yield(issue) if block_given?
+      return if performed?
 
       flash[:success] = 'Label was successfully removed.'
-      redirect_to(plan_my_stuff.issue_path(issue.number))
+      redirect_to(plan_my_stuff.issue_path(issue))
+    rescue PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
+      flash[:error] = e.message
+      redirect_to(plan_my_stuff.issue_path(params[:issue_id]))
     end
   end
 end

data/app/controllers/plan_my_stuff/project_items/assignments_controller.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  module ProjectItems
+    # Handles assigning and unassigning project item assignees via CRUD-style routes.
+    # Backs the assign/unassign forms on the project board view (T-047).
+    #
+    # PATCH  /projects/:project_id/items/:item_id/assignment -> update (assign)
+    # DELETE /projects/:project_id/items/:item_id/assignment -> destroy (unassign)
+    #
+    class AssignmentsController < PlanMyStuff::ApplicationController
+      # PATCH /projects/:project_id/items/:item_id/assignment
+      def update
+        item = find_project_item
+        assignees = parse_assignees(params[:assignee])
+
+        item.assign!(assignees)
+
+        yield(item) if block_given?
+        return if performed?
+
+        flash[:success] =
+          if assignees.present?
+            "Item assigned to #{assignees.join(', ')}."
+          else
+            'All assignees removed.'
+          end
+        redirect_to(plan_my_stuff.project_path(params[:project_id]))
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.project_path(params[:project_id]))
+      end
+
+      # DELETE /projects/:project_id/items/:item_id/assignment
+      def destroy
+        if params[:username].blank?
+          flash[:error] = 'Username is required to unassign.'
+          redirect_to(plan_my_stuff.project_path(params[:project_id]))
+          return
+        end
+
+        item = find_project_item
+        current_assignees = item.field_values['Assignees'] || []
+        remaining = current_assignees - [params[:username]]
+
+        item.assign!(remaining)
+
+        yield(item) if block_given?
+        return if performed?
+
+        flash[:success] = "#{params[:username]} unassigned."
+        redirect_to(plan_my_stuff.project_path(params[:project_id]))
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.project_path(params[:project_id]))
+      end
+
+      private
+
+        # Finds the project item by item_id within the given project.
+        #
+        # @return [PlanMyStuff::ProjectItem]
+        #
+        def find_project_item
+          project = PlanMyStuff::Project.find(params[:project_id].to_i)
+          item = project.items.find { |i| i.id == params[:item_id] }
+
+          raise(PlanMyStuff::APIError, "Item not found: #{params[:item_id]}") unless item
+
+          item
+        end
+
+        # Splits a comma-separated assignees string into an array.
+        #
+        # @param assignees_string [String, nil]
+        #
+        # @return [Array<String>]
+        #
+        def parse_assignees(assignees_string)
+          return [] if assignees_string.blank?
+
+          assignees_string.split(',').filter_map { |a| a.strip.presence }
+        end
+    end
+  end
+end

data/app/controllers/plan_my_stuff/project_items/statuses_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  module ProjectItems
+    # Handles moving a project item to a new status column via CRUD-style routes.
+    # Backs the status dropdown on the project board view (T-046).
+    #
+    # PATCH /projects/:project_id/items/:item_id/status -> update (moves to new status)
+    #
+    class StatusesController < PlanMyStuff::ApplicationController
+      # PATCH /projects/:project_id/items/:item_id/status
+      def update
+        item = find_project_item
+
+        item.move_to!(params[:status])
+
+        yield(item) if block_given?
+        return if performed?
+
+        flash[:success] = "Item moved to #{params[:status]}."
+        redirect_to(plan_my_stuff.project_path(params[:project_id]))
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.project_path(params[:project_id]))
+      end
+
+      private
+
+        # Finds the project item by item_id within the given project.
+        #
+        # @return [PlanMyStuff::ProjectItem]
+        #
+        def find_project_item
+          project = PlanMyStuff::Project.find(params[:project_id].to_i)
+          item = project.items.find { |i| i.id == params[:item_id] }
+
+          raise(PlanMyStuff::APIError, "Item not found: #{params[:item_id]}") unless item
+
+          item
+        end
+    end
+  end
+end