Settings::RepositoryController includes protected tags in JS

app/controllers/projects/settings/repository_controller.rb

@@ -5,10 +5,9 @@ module Projects
       before_action :remote_mirror, only: [:show]
 
       def show
-        @deploy_keys = DeployKeysPresenter
-          .new(@project, current_user: current_user)
+        @deploy_keys = DeployKeysPresenter.new(@project, current_user: current_user)
 
-        define_protected_branches
+        define_protected_refs
 
         project.create_push_rule unless project.push_rule
         @push_rule = project.push_rule
@@ -16,21 +15,21 @@ module Projects
 
       private
 
-      def define_protected_branches
-        load_protected_branches
-        @protected_branch = @project.protected_branches.new
-        load_gon_index
-      end
-
       def remote_mirror
         @remote_mirror = @project.remote_mirrors.first_or_initialize
       end
 
-      def load_protected_branches
+      def define_protected_refs
         @protected_branches = @project.protected_branches.order(:name).page(params[:page])
+        @protected_tags = @project.protected_tags.order(:name).page(params[:page])
+        @protected_branch = @project.protected_branches.new
+        @protected_tag = @project.protected_tags.new
+        load_gon_index
       end
 
       def access_levels_options
+        #TODO: consider protected tags
+        #TODO: Refactor ProtectedBranch::PushAccessLevel so it doesn't mention branches
         {
           push_access_levels: {
             roles: ProtectedBranch::PushAccessLevel.human_access_levels.map do |id, text|
@@ -47,15 +46,29 @@ module Projects
         }
       end
 
+      #TODO: Move to Protections::TagMatcher.new(project).unprotected
+      def unprotected_tags
+        exact_protected_tag_names = @project.protected_tags.reject(&:wildcard?).map(&:name)
+        tag_names = @project.repository.tags.map(&:name)
+        non_open_tag_names = Set.new(exact_protected_tag_names).intersection(Set.new(tag_names))
+        @project.repository.tags.reject { |tag| non_open_tag_names.include? tag.name }
+      end
+
+      def unprotected_tags_hash
+        tags = unprotected_tags.map { |tag| { text: tag.name, id: tag.name, title: tag.name } }
+        { open_tags: tags }
+      end
+
       def open_branches
         branches = @project.open_branches.map { |br| { text: br.name, id: br.name, title: br.name } }
         { open_branches: branches }
       end
 
       def load_gon_index
-        params = open_branches
-        params[:current_project_id] = @project.id if @project
-        gon.push(params.merge(access_levels_options))
+        gon.push(open_branches)
+        gon.push(unprotected_tags_hash)
+        gon.push(access_levels_options)
+        gon.push(current_project_id: @project.id) if @project
       end
     end
   end

app/models/concerns/protected_ref_access.rb

-module ProtectedBranchAccess
-  extend ActiveSupport::Concern
+# module ProtectedRefAccess
+#   extend ActiveSupport::Concern
 
-  included do
-    belongs_to :protected_branch
-    delegate :project, to: :protected_branch
+#   included do
+#     # belongs_to :protected_branch
+#     # delegate :project, to: :protected_branch
 
-    scope :master, -> { where(access_level: Gitlab::Access::MASTER) }
-    scope :developer, -> { where(access_level: Gitlab::Access::DEVELOPER) }
-  end
+#     scope :master, -> { where(access_level: Gitlab::Access::MASTER) }
+#     scope :developer, -> { where(access_level: Gitlab::Access::DEVELOPER) }
+#   end
 
-  def humanize
-    self.class.human_access_levels[self.access_level]
-  end
+#   def humanize
+#     self.class.human_access_levels[self.access_level]
+#   end
 
-  def check_access(user)
-    return true if user.is_admin?
+#   def check_access(user)
+#     return true if user.is_admin?
 
-    project.team.max_member_access(user.id) >= access_level
-  end
-end
+#     project.team.max_member_access(user.id) >= access_level
+#   end
+# end

app/models/project.rb

@@ -978,6 +978,7 @@ class Project < ActiveRecord::Base
   end
 
   # Branches that are not _exactly_ matched by a protected branch.
+  #TODO: Move to Protections::BranchMatcher.new(project).unprotecte
   def open_branches
     exact_protected_branch_names = protected_branches.reject(&:wildcard?).map(&:name)
     branch_names = repository.branches.map(&:name)