Created ProtectedRefsController to reduce Tags/Branches duplication

Fixes ProtectedBranches#create flash errors bug due to
typo in 'flash[:alert] = @protected_branches.errors'

app/controllers/projects/protected_branches_controller.rb

-class Projects::ProtectedBranchesController < Projects::ApplicationController
-  include RepositorySettingsRedirect
-  # Authorize
-  before_action :require_non_empty_project
-  before_action :authorize_admin_project!
-  before_action :load_protected_branch, only: [:show, :update, :destroy]
+class Projects::ProtectedBranchesController < Projects::ProtectedRefsController
+  protected
 
-  layout "project_settings"
-
-  def index
-    redirect_to_repository_settings(@project)
+  def protected_ref
+    @protected_branch
   end
 
-  def create
-    @protected_branch = ::ProtectedBranches::CreateService.new(@project, current_user, protected_branch_params).execute
-    unless @protected_branch.persisted?
-      flash[:alert] = @protected_branches.errors.full_messages.join(', ').html_safe
-    end
-    redirect_to_repository_settings(@project)
+  def protected_ref=(val)
+    @protected_branch = val
   end
 
-  def show
-    @matching_branches = @protected_branch.matching(@project.repository.branches)
+  def matching_refs=(val)
+    @matching_branches = val
   end
 
-  def update
-    @protected_branch = ::ProtectedBranches::UpdateService.new(@project, current_user, protected_branch_params).execute(@protected_branch)
-
-    if @protected_branch.valid?
-      respond_to do |format|
-        format.json { render json: @protected_branch, status: :ok, include: [:merge_access_levels, :push_access_levels] }
-      end
-    else
-      respond_to do |format|
-        format.json { render json: @protected_branch.errors, status: :unprocessable_entity }
-      end
-    end
+  def project_refs
+    @project.repository.branches
   end
 
-  def destroy
-    @protected_branch.destroy
-
-    respond_to do |format|
-      format.html { redirect_to_repository_settings(@project) }
-      format.js { head :ok }
-    end
+  def create_service
+    ::ProtectedBranches::CreateService
   end
 
-  private
+  def update_service
+    ::ProtectedBranches::UpdateService
+  end
 
-  def load_protected_branch
-    @protected_branch = @project.protected_branches.find(params[:id])
+  def load_protected_ref
+    self.protected_ref = @project.protected_branches.find(params[:id])
   end
 
-  def protected_branch_params
+  def protected_ref_params
     params.require(:protected_branch).permit(:name,
                                              merge_access_levels_attributes: [:access_level, :id, :user_id, :_destroy, :group_id],
                                              push_access_levels_attributes: [:access_level, :id, :user_id, :_destroy, :group_id])
   end
-
-  def load_protected_branches
-    @protected_branches = @project.protected_branches.order(:name).page(params[:page])
-  end
 end

app/controllers/projects/protected_refs_controller.rb

+class Projects::ProtectedRefsController < Projects::ApplicationController
+  include RepositorySettingsRedirect
+  # Authorize
+  before_action :require_non_empty_project
+  before_action :authorize_admin_project!
+  before_action :load_protected_ref, only: [:show, :update, :destroy]
+
+  layout "project_settings"
+
+  def index
+    redirect_to_repository_settings(@project)
+  end
+
+  def create
+    self.protected_ref = create_service.new(@project, current_user, protected_ref_params).execute
+    unless protected_ref.persisted?
+      flash[:alert] = protected_ref.errors.full_messages.join(', ').html_safe
+    end
+    redirect_to_repository_settings(@project)
+  end
+
+  def show
+    self.matching_refs = protected_ref.matching(project_refs)
+  end
+
+  def update
+    self.protected_ref = update_service.new(@project, current_user, protected_ref_params).execute(protected_ref)
+
+    if protected_ref.valid?
+      respond_to do |format|
+        format.json { render json: protected_ref, status: :ok, include: [:merge_access_levels, :push_access_levels] }
+      end
+    else
+      respond_to do |format|
+        format.json { render json: protected_ref.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    protected_ref.destroy
+
+    respond_to do |format|
+      format.html { redirect_to_repository_settings(@project) }
+      format.js { head :ok }
+    end
+  end
+end

app/controllers/projects/protected_tags_controller.rb

-class Projects::ProtectedTagsController < Projects::ApplicationController
-  include RepositorySettingsRedirect
-  # Authorize
-  before_action :require_non_empty_project
-  before_action :authorize_admin_project!
-  before_action :load_protected_tag, only: [:show, :update, :destroy]
+class Projects::ProtectedTagsController < Projects::ProtectedRefsController
+  protected
 
-  layout "project_settings"
-
-  def index
-    redirect_to_repository_settings(@project)
+  def protected_ref
+    @protected_tag
   end
 
-  def create
-    @protected_tag = ::ProtectedTags::CreateService.new(@project, current_user, protected_tag_params).execute
-    unless @protected_tag.persisted?
-      flash[:alert] = @protected_tags.errors.full_messages.join(', ').html_safe
-    end
-    redirect_to_repository_settings(@project)
+  def protected_ref=(val)
+    @protected_tag = val
   end
 
-  def show
-    @matching_tags = @protected_tag.matching(@project.repository.tags)
+  def matching_refs=(val)
+    @matching_tags = val
   end
 
-  def update
-    @protected_tag = ::ProtectedTags::UpdateService.new(@project, current_user, protected_tag_params).execute(@protected_tag)
-
-    if @protected_tag.valid?
-      respond_to do |format|
-        format.json { render json: @protected_tag, status: :ok }
-      end
-    else
-      respond_to do |format|
-        format.json { render json: @protected_tag.errors, status: :unprocessable_entity }
-      end
+  def project_refs
+    @project.repository.tags
   end
-  end
-
-  def destroy
-    @protected_tag.destroy
 
-    respond_to do |format|
-      format.html { redirect_to_repository_settings(@project) }
-      format.js { head :ok }
-    end
+  def create_service
+    ::ProtectedTags::CreateService
   end
 
-  private
+  def update_service
+    ::ProtectedTags::UpdateService
+  end
 
-  def load_protected_tag
-    @protected_tag = @project.protected_tags.find(params[:id])
+  def load_protected_ref
+    self.protected_ref = @project.protected_tags.find(params[:id])
   end
 
-  def protected_tag_params
+  def protected_ref_params
     params.require(:protected_tag).permit(:name, push_access_levels_attributes: [:access_level, :id])
   end
 end