plan_my_stuff 0.7.0 → 0.9.0

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

@@ -8,27 +8,29 @@ module PlanMyStuff
     # POST   /issues/:issue_id/closure -> create  (closes)
     # DELETE /issues/:issue_id/closure -> destroy (reopens)
     #
-    class ClosuresController < ApplicationController
+    class ClosuresController < PlanMyStuff::ApplicationController
       # POST /issues/:issue_id/closure
       def create
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
         issue.update!(state: :closed)
 
         flash[:success] = 'Issue was successfully closed.'
         redirect_to(plan_my_stuff.issue_path(issue.number, repo: issue.repo.full_name))
-      rescue PMS::Error, ArgumentError => e
+      rescue PlanMyStuff::Error, ArgumentError => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
       end
 
       # DELETE /issues/:issue_id/closure
       def destroy
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
         issue.update!(state: :open)
 
         flash[:success] = 'Issue was successfully reopened.'
         redirect_to(plan_my_stuff.issue_path(issue.number, repo: issue.repo.full_name))
-      rescue PMS::Error, ArgumentError => e
+      rescue PlanMyStuff::Error, ArgumentError => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
       end

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

@@ -2,14 +2,13 @@
 
 module PlanMyStuff
   module Issues
-    # CRUD for ticket relationships: +:related+ (metadata-backed) and
-    # +:blocked_by+ / +:parent+ / +:sub_ticket+ / +:duplicate_of+
-    # (native GitHub APIs). Backs the links panel on the issue show view.
+    # CRUD for ticket relationships: +:related+ (metadata-backed) and +:blocked_by+ / +:parent+ / +:sub_ticket+ /
+    # +:duplicate_of+ (native GitHub APIs). Backs the links panel on the issue show view.
     #
     # POST   /issues/:issue_id/links      -> create  (adds a link)
     # DELETE /issues/:issue_id/links/:id  -> destroy (removes a link)
     #
-    class LinksController < ApplicationController
+    class LinksController < PlanMyStuff::ApplicationController
       NATIVE_DISPATCH = {
         'related' => { add: :add_related!, remove: :remove_related! },
         'blocked_by' => { add: :add_blocker!, remove: :remove_blocker! },
@@ -26,12 +25,13 @@ module PlanMyStuff
           return
         end
 
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
         link = add_link(issue, type)
 
         flash[:success] = "Linked #{link}"
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
-      rescue PMS::ValidationError, ActiveModel::ValidationError, ArgumentError => e
+      rescue PlanMyStuff::ValidationError, ActiveModel::ValidationError, ArgumentError => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
       end
@@ -44,12 +44,13 @@ module PlanMyStuff
           return
         end
 
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
         remove_link(issue, type, repo: repo, number: number)
 
         flash[:success] = "Unlinked #{repo}##{number}"
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
-      rescue PMS::ValidationError, ActiveModel::ValidationError, ArgumentError => e
+      rescue PlanMyStuff::ValidationError, ActiveModel::ValidationError, ArgumentError => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
       end
@@ -61,21 +62,18 @@ module PlanMyStuff
           params.require(:link).permit(:type, :issue_number, :repo)
         end
 
-        # Only +:related+ may be mutated by non-support users. +destroy+
-        # is not defined for +:duplicate_of+ (reopen via GitHub).
+        # All link mutations require a support user. +destroy+ is not defined for +:duplicate_of+ (reopen via GitHub).
         #
         # @return [Boolean]
         #
         def dispatch_allowed?(type, action)
           entry = NATIVE_DISPATCH[type]
           return false if entry.nil? || entry[action].nil?
-          # FIXME: should non-support users be able to alter related links?
-          return true if type == 'related'
 
           support_user?
         end
 
-        # @return [PMS::Link]
+        # @return [PlanMyStuff::Link]
         def add_link(issue, type)
           method = NATIVE_DISPATCH.dig(type, :add)
           target = {
@@ -105,11 +103,9 @@ module PlanMyStuff
           end
         end
 
-        # Parses +"{type}:{owner/repo}:{number}"+ out of +params[:id]+.
-        # The route helper URL-encodes outgoing segments, but Rack's
-        # default path decoder intentionally leaves +%2F+ escaped in
-        # path params (anti-path-traversal), so the repo portion can
-        # still contain +%2F+. Decode before splitting.
+        # Parses +"{type}:{owner/repo}:{number}"+ out of +params[:id]+. The route helper URL-encodes outgoing segments,
+        # but Rack's default path decoder intentionally leaves +%2F+ escaped in path params (anti-path-traversal), so
+        # the repo portion can still contain +%2F+. Decode before splitting.
         #
         # @param id [String]
         #

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

@@ -2,21 +2,23 @@
 
 module PlanMyStuff
   module Issues
-    # Moves an issue's pipeline ProjectItem to "Started" via
-    # +PlanMyStuff::Pipeline.take!+. Backs the "Take" button on the
-    # mounted issue show view (T-RC-017). The primary UI path for a dev
-    # picking up work on an issue they've been assigned to.
+    # Moves an issue's pipeline ProjectItem to "Started" via +PlanMyStuff::Pipeline.take!+. Backs the "Take" button on
+    # the mounted issue show view (T-RC-017). The primary UI path for a dev picking up work on an issue they've been
+    # assigned to.
     #
-    class TakesController < ApplicationController
-      before_action :require_support_user!
+    class TakesController < PlanMyStuff::ApplicationController
+      before_action :require_support_user
 
       # POST /issues/:issue_id/take
       def create
         issue_number = params[:issue_id].to_i
         repo = params[:repo]
 
+        issue = PlanMyStuff::Issue.find(issue_number, repo: repo)
+        guard_already_taken!(issue)
+
         project_item = PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue_number)
-        project_item ||= add_to_pipeline(issue_number, repo)
+        project_item ||= add_to_pipeline(issue)
 
         PlanMyStuff::Pipeline.take!(project_item)
         assign_current_user(project_item)
@@ -24,18 +26,49 @@ module PlanMyStuff
 
         redirect_to(plan_my_stuff.issue_path(issue_number, repo: repo))
       rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
+        flash[:error] = e.message
+        redirect_to(plan_my_stuff.issue_path(issue_number, repo: repo))
+      end
+
+      # DELETE /issues/:issue_id/take
+      def destroy
+        issue_number = params[:issue_id].to_i
+        repo = params[:repo]
+
+        issue = PlanMyStuff::Issue.find(issue_number, repo: repo)
+        login = current_user_login
+        guard_release!(issue, login)
+
+        remaining = issue.assignees - [login]
+        project_item = PlanMyStuff::Pipeline::IssueLinker.find_project_item(issue_number)
+
+        if project_item.present?
+          if remaining.empty?
+            issue.update!(assignees: [])
+            project_item.destroy!
+          else
+            project_item.assign!(remaining)
+          end
+        else
+          issue.update!(assignees: remaining)
+        end
+
+        flash[:success] = "Issue ##{issue_number} released."
+        redirect_to(plan_my_stuff.issue_path(issue_number, repo: repo))
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.issue_path(issue_number, repo: repo))
       end
 
       private
 
-        # Redirects non-support users back to the issue page. Mirrors
-        # +Issues::ViewersController+'s authorization check.
+        # Redirects non-support users back to the issue page. Mirrors +Issues::ViewersController+'s authorization check.
         #
         # @return [void]
         #
-        def require_support_user!
+        def require_support_user
           return if support_user?
 
           redirect_to_unauthorized(
@@ -43,46 +76,84 @@ module PlanMyStuff
           )
         end
 
-        # Adds an issue to the pipeline project so +Pipeline.take!+ has
-        # something to operate on when the user clicks "Take" on an
-        # issue that hasn't been submitted to the pipeline yet.
+        # Best-effort race guard for two users clicking Take on the same issue. GitHub allows multiple assignees so a
+        # naive second take would silently pile on; refuse instead and let the second user see who already has it.
+        #
+        # @raise [PlanMyStuff::Error] if the issue already has assignees
         #
-        # @param issue_number [Integer]
-        # @param repo [String, nil]
+        # @param issue [PlanMyStuff::Issue]
+        #
+        # @return [void]
+        #
+        def guard_already_taken!(issue)
+          return if issue.assignees.blank?
+
+          raise(
+            PlanMyStuff::Error,
+            "Issue ##{issue.number} is already taken by @#{issue.assignees.join(', @')}.",
+          )
+        end
+
+        # Adds an issue to the pipeline project so +Pipeline.take!+ has something to operate on when the user clicks
+        # "Take" on an issue that hasn't been submitted to the pipeline yet.
+        #
+        # @param issue [PlanMyStuff::Issue]
         #
         # @return [PlanMyStuff::ProjectItem]
         #
-        def add_to_pipeline(issue_number, repo)
-          issue = PlanMyStuff::Issue.find(issue_number, repo: repo)
-          pipeline_number = PlanMyStuff::Pipeline.resolve_pipeline_project_number
+        def add_to_pipeline(issue)
+          pipeline_number = PlanMyStuff::Pipeline.resolve_pipeline_project_number!
           PlanMyStuff::ProjectItem.create!(issue, project_number: pipeline_number)
         end
 
-        # Looks up the current user's GitHub login in
-        # +config.github_login_for+ (a +{user_id => login}+ hash) and
-        # assigns them on the project item. Assignment failures are
-        # logged and surfaced as a flash warning but do not revert the
-        # status move.
+        # Looks up the current user's GitHub login in +config.github_login_for+ (a +{user_id => login}+ hash) and
+        # assigns them on the project item. Assignment failures are logged and surfaced as a flash warning but do not
+        # revert the status move.
         #
         # @param project_item [PlanMyStuff::ProjectItem]
         #
         # @return [void]
         #
         def assign_current_user(project_item)
-          user = pms_current_user
-          user_id = user.present? ? PMS::UserResolver.user_id(user) : nil
-          login = PlanMyStuff.configuration.github_login_for[user_id]
+          login = current_user_login
 
           if login.blank?
-            Rails.logger.info("[PMS] No github_login_for mapping for user #{user_id}; skipping Take assignment")
+            Rails.logger.info('[PlanMyStuff] No github_login_for mapping for current user; skipping Take assignment')
             return
           end
 
           project_item.assign!(login)
         rescue PlanMyStuff::Error => e
-          Rails.logger.warn("[PMS] Take assignment failed: #{e.message}")
+          Rails.logger.warn("[PlanMyStuff] Take assignment failed: #{e.message}")
           flash[:warning] = "Issue taken but assignment failed: #{e.message}"
         end
+
+        # GitHub login for the current user via +config.github_login_for+ (a +{user_id => login}+ hash), or +nil+ if the
+        # user is unmapped or unauthenticated.
+        #
+        # @return [String, nil]
+        #
+        def current_user_login
+          user = pms_current_user
+          user_id = user.present? ? PlanMyStuff::UserResolver.user_id(user) : nil
+          PlanMyStuff.configuration.github_login_for[user_id]
+        end
+
+        # Refuses the release when the current user has no login mapping or is not in the issue's assignees. Mirrors the
+        # +guard_already_taken!+ check on +#create+.
+        #
+        # @raise [PlanMyStuff::Error] if the user cannot release the issue
+        #
+        # @param issue [PlanMyStuff::Issue]
+        # @param login [String, nil]
+        #
+        # @return [void]
+        #
+        def guard_release!(issue, login)
+          raise(PlanMyStuff::Error, 'No GitHub login mapping for current user; cannot release.') if login.blank?
+
+          raise(PlanMyStuff::Error, "Issue ##{issue.number} is not assigned to you.") if issue.assignees.exclude?(login)
+        end
     end
   end
 end

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

@@ -8,7 +8,7 @@ module PlanMyStuff
     # POST   /issues/:issue_id/viewers      -> create  (adds viewer(s))
     # DELETE /issues/:issue_id/viewers/:id  -> destroy (removes a viewer)
     #
-    class ViewersController < ApplicationController
+    class ViewersController < PlanMyStuff::ApplicationController
       # POST /issues/:issue_id/viewers
       def create
         unless support_user?
@@ -23,11 +23,15 @@ module PlanMyStuff
           return
         end
 
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
-        issue.add_viewers(user_ids: viewer_ids, user: pms_current_user)
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue.add_viewers!(user_ids: viewer_ids, user: pms_current_user)
 
         flash[:success] = 'Viewers were successfully added.'
         redirect_to(plan_my_stuff.edit_issue_path(params[:issue_id], repo: params[:repo]))
+      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], repo: params[:repo]))
       end
 
       # DELETE /issues/:issue_id/viewers/:id
@@ -37,11 +41,15 @@ module PlanMyStuff
           return
         end
 
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
-        issue.remove_viewers(user_ids: [params[:id].to_i], user: pms_current_user)
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue.remove_viewers!(user_ids: [params[:id].to_i], user: pms_current_user)
 
         flash[:success] = 'Viewer was successfully removed.'
         redirect_to(plan_my_stuff.edit_issue_path(params[:issue_id], repo: params[:repo]))
+      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], repo: params[:repo]))
       end
     end
   end

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

@@ -8,7 +8,7 @@ module PlanMyStuff
     # POST   /issues/:issue_id/waiting -> create  (enters waiting-on-user)
     # DELETE /issues/:issue_id/waiting -> destroy (clears waiting-on-user)
     #
-    class WaitingsController < ApplicationController
+    class WaitingsController < PlanMyStuff::ApplicationController
       # POST /issues/:issue_id/waiting
       def create
         unless support_user?
@@ -16,12 +16,13 @@ module PlanMyStuff
           return
         end
 
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
         issue.enter_waiting_on_user!(user: pms_current_user)
 
         flash[:success] = 'Issue marked as waiting on user reply.'
         redirect_to(plan_my_stuff.issue_path(issue.number, repo: issue.repo.full_name))
-      rescue PMS::Error, ArgumentError => e
+      rescue PlanMyStuff::Error, ArgumentError => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
       end
@@ -33,12 +34,13 @@ module PlanMyStuff
           return
         end
 
-        issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+        issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
         issue.clear_waiting_on_user!
 
         flash[:success] = 'Waiting-on-user state cleared.'
         redirect_to(plan_my_stuff.issue_path(issue.number, repo: issue.repo.full_name))
-      rescue PMS::Error, ArgumentError => e
+      rescue PlanMyStuff::Error, ArgumentError => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
       end

data/app/controllers/plan_my_stuff/issues_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class IssuesController < ApplicationController
+  class IssuesController < PlanMyStuff::ApplicationController
     # GET /issues
     def index
       @page = (params[:page] || 1).to_i
@@ -10,7 +10,7 @@ module PlanMyStuff
       @labels = params[:labels].present? ? Array.wrap(params[:labels]) : []
       @repo = params[:repo]
 
-      @issues = PMS::Issue.list(
+      @issues = PlanMyStuff::Issue.list(
         repo: @repo,
         state: @state,
         labels: @labels,
@@ -21,13 +21,12 @@ module PlanMyStuff
 
     # GET /issues/new
     def new
-      @issue = PMS::Issue.new
-      @support_user = support_user?
+      @issue = PlanMyStuff::Issue.new
     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]),
@@ -36,32 +35,31 @@ module PlanMyStuff
 
       flash[:success] = 'Issue was successfully created.'
       redirect_to(plan_my_stuff.issue_path(@issue.number, repo: @issue.repo.full_name))
-    rescue PMS::ValidationError => e
-      @issue = PMS::Issue.new(title: issue_params[:title], body: issue_params[:body])
-      @support_user = support_user?
+    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])
+      @issue = PlanMyStuff::Issue.find(params[:id].to_i, repo: params[:repo])
       @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
-      @pipeline_enabled = PMS.configuration.pipeline_enabled
+      @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
     end
 
     # GET /issues/:id/edit
     def edit
-      @issue = PMS::Issue.find(params[:id].to_i, repo: params[:repo])
-      @support_user = support_user?
+      @issue = PlanMyStuff::Issue.find(params[:id].to_i, repo: params[:repo])
     end
 
     # PATCH/PUT /issues/:id
     def update
-      @issue = PMS::Issue.find(params[:id].to_i, repo: params[:repo])
+      @issue = PlanMyStuff::Issue.find(params[:id].to_i, repo: params[:repo])
 
       @issue.update!(
         title: issue_params[:title],
@@ -71,14 +69,14 @@ module PlanMyStuff
 
       flash[:success] = 'Issue was successfully updated.'
       redirect_to(plan_my_stuff.issue_path(@issue.number, repo: @issue.repo.full_name))
-    rescue PMS::StaleObjectError
-      @support_user = support_user?
+    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)
-    rescue PMS::ValidationError => e
-      @support_user = support_user?
+      render(:edit, status: PlanMyStuff.unprocessable_status)
+    rescue PlanMyStuff::ValidationError => e
+      pms_handle_rescue(e)
       flash.now[:error] = e.message
-      render(:edit, status: PMS.unprocessable_status)
+      render(:edit, status: PlanMyStuff.unprocessable_status)
     end
 
     private
@@ -99,18 +97,16 @@ module PlanMyStuff
         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.
+      # 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)
-        PMS::Pipeline::IssueLinker.find_project_item(issue_number)
-      rescue ArgumentError, PMS::Error => e
+        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

data/app/controllers/plan_my_stuff/labels_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class LabelsController < ApplicationController
+  class LabelsController < PlanMyStuff::ApplicationController
     # POST /issues/:issue_id/labels
     def create
       labels = parse_labels(params[:label_name])
@@ -11,20 +11,36 @@ module PlanMyStuff
         return
       end
 
-      issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
-      PMS::Label.add(issue: issue, labels: labels)
+      issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+
+      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.number, repo: issue.repo.full_name))
+        return
+      end
+
+      PlanMyStuff::Label.add!(issue: issue, labels: labels)
 
       flash[:success] = 'Label was successfully added.'
       redirect_to(plan_my_stuff.issue_path(issue.number, repo: issue.repo.full_name))
+    rescue PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
+      flash[:error] = e.message
+      redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
     end
 
     # DELETE /issues/:issue_id/labels/:id
     def destroy
-      issue = PMS::Issue.find(params[:issue_id].to_i, repo: params[:repo])
-      PMS::Label.remove(issue: issue, labels: [params[:id]])
+      issue = PlanMyStuff::Issue.find(params[:issue_id].to_i, repo: params[:repo])
+      PlanMyStuff::Label.remove!(issue: issue, labels: [params[:id]])
 
       flash[:success] = 'Label was successfully removed.'
       redirect_to(plan_my_stuff.issue_path(issue.number, repo: issue.repo.full_name))
+    rescue PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
+      flash[:error] = e.message
+      redirect_to(plan_my_stuff.issue_path(params[:issue_id], repo: params[:repo]))
     end
   end
 end

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

@@ -8,7 +8,7 @@ module PlanMyStuff
     # PATCH  /projects/:project_id/items/:item_id/assignment -> update (assign)
     # DELETE /projects/:project_id/items/:item_id/assignment -> destroy (unassign)
     #
-    class AssignmentsController < ApplicationController
+    class AssignmentsController < PlanMyStuff::ApplicationController
       # PATCH /projects/:project_id/items/:item_id/assignment
       def update
         item = find_project_item
@@ -16,9 +16,15 @@ module PlanMyStuff
 
         item.assign!(assignees)
 
-        flash[:success] = "Item assigned to #{assignees.join(', ')}."
+        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, PMS::Error => e
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
       end
@@ -39,7 +45,8 @@ module PlanMyStuff
 
         flash[:success] = "#{params[:username]} unassigned."
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
-      rescue ArgumentError, PMS::Error => e
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
       end
@@ -51,10 +58,10 @@ module PlanMyStuff
         # @return [PlanMyStuff::ProjectItem]
         #
         def find_project_item
-          project = PMS::Project.find(params[:project_id].to_i)
+          project = PlanMyStuff::Project.find(params[:project_id].to_i)
           item = project.items.find { |i| i.id == params[:item_id] }
 
-          raise(PMS::APIError, "Item not found: #{params[:item_id]}") unless item
+          raise(PlanMyStuff::APIError, "Item not found: #{params[:item_id]}") unless item
 
           item
         end

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

@@ -7,7 +7,7 @@ module PlanMyStuff
     #
     # PATCH /projects/:project_id/items/:item_id/status -> update (moves to new status)
     #
-    class StatusesController < ApplicationController
+    class StatusesController < PlanMyStuff::ApplicationController
       # PATCH /projects/:project_id/items/:item_id/status
       def update
         item = find_project_item
@@ -16,7 +16,8 @@ module PlanMyStuff
 
         flash[:success] = "Item moved to #{params[:status]}."
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
-      rescue ArgumentError, PMS::Error => e
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
       end
@@ -28,10 +29,10 @@ module PlanMyStuff
         # @return [PlanMyStuff::ProjectItem]
         #
         def find_project_item
-          project = PMS::Project.find(params[:project_id].to_i)
+          project = PlanMyStuff::Project.find(params[:project_id].to_i)
           item = project.items.find { |i| i.id == params[:item_id] }
 
-          raise(PMS::APIError, "Item not found: #{params[:item_id]}") unless item
+          raise(PlanMyStuff::APIError, "Item not found: #{params[:item_id]}") unless item
 
           item
         end