Merge branch '8-2-stable' of gitlab.com:gitlab-org/gitlab-ce into 8-2-stable-ce-to-ee

Signed-off-by: Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>

CHANGELOG

@@ -9,6 +9,8 @@ v 8.2.0 (unreleased)
 v 8.3.0 (unreleased)
 
 v 8.2.0
+  - Improved performance of finding projects and groups in various places
+  - Improved performance of rendering user profile pages and Atom feeds
   - Fix grouping of contributors by email in graph.
   - Remove CSS property preventing hard tabs from rendering in Chromium 45 (Stan Hu)
   - Fix Drone CI service template not saving properly (Stan Hu)
@@ -17,6 +19,10 @@ v 8.2.0
   - Upgrade gitlab_git to 7.2.20 and rugged to 0.23.3 (Stan Hu)
   - Improved performance of finding users by one of their Email addresses
   - Add allow_failure field to commit status API (Stan Hu)
+  - Commits without .gitlab-ci.yml are marked as skipped
+  - Save detailed error when YAML syntax is invalid
+  - Since GitLab CI is enabled by default, remove enabling it by pushing .gitlab-ci.yml
+  - Added build artifacts
   - Improved performance of replacing references in comments
   - Show last project commit to default branch on project home page
   - Highlight comment based on anchor in URL
@@ -34,6 +40,7 @@ v 8.2.0
   - Allow to define cache in `.gitlab-ci.yml`
   - Fix: 500 error returned if destroy request without HTTP referer (Kazuki Shimizu)
   - Remove deprecated CI events from project settings page
+  - Improve personal snippet access workflow (Douglas Alexandre)
   - [API] Add ability to fetch the commit ID of the last commit that actually touched a file
   - Fix omniauth documentation setting for omnibus configuration (Jon Cairns)
   - Add "New file" link to dropdown on project page
@@ -55,7 +62,9 @@ v 8.2.0
   - Fix trailing whitespace issue in merge request/issue title
   - Fix bug when milestone/label filter was empty for dashboard issues page
   - Add ability to create milestone in group projects from single form
+  - Add option to create merge request when editing/creating a file (Dirceu Tiegs)
   - Prevent the last owner of a group from being able to delete themselves by 'adding' themselves as a master (James Lopez)
+  - Add Award Emoji to issue and merge request pages
 
 v 8.1.4
   - Fix bug where manually merged branches in a MR would end up with an empty diff (Stan Hu)

app/assets/javascripts/awards_handler.coffee

+class @AwardsHandler
+  constructor: (@post_emoji_url, @noteable_type, @noteable_id) ->
+
+  addAward: (emoji) ->
+    @postEmoji emoji, =>
+      @addAwardToEmojiBar(emoji)
+    
+  addAwardToEmojiBar: (emoji, custom_path = '') ->
+    if @exist(emoji)
+      if @isActive(emoji)
+        @decrementCounter(emoji)
+      else
+        counter = @findEmojiIcon(emoji).siblings(".counter")
+        counter.text(parseInt(counter.text()) + 1)
+        counter.parent().addClass("active")
+        @addMeToAuthorList(emoji)
+    else
+      @createEmoji(emoji, custom_path)
+
+  exist: (emoji) ->
+    @findEmojiIcon(emoji).length > 0
+
+  isActive: (emoji) ->
+    @findEmojiIcon(emoji).parent().hasClass("active")
+
+  decrementCounter: (emoji) ->
+    counter = @findEmojiIcon(emoji).siblings(".counter")
+
+    if parseInt(counter.text()) > 1
+      counter.text(parseInt(counter.text()) - 1)
+      counter.parent().removeClass("active")
+      @removeMeFromAuthorList(emoji)
+    else
+      award = counter.parent()
+      award.tooltip("destroy")
+      award.remove()
+
+  removeMeFromAuthorList: (emoji) ->
+    award_block = @findEmojiIcon(emoji).parent()
+    authors = award_block.attr("data-original-title").split(", ")
+    authors = _.without(authors, "me").join(", ")
+    award_block.attr("title", authors)
+    @resetTooltip(award_block)
+
+  addMeToAuthorList: (emoji) ->
+    award_block = @findEmojiIcon(emoji).parent()
+    authors = award_block.attr("data-original-title").split(", ")
+    authors.push("me")
+    award_block.attr("title", authors.join(", "))
+    @resetTooltip(award_block)
+
+  resetTooltip: (award) ->
+    award.tooltip("destroy")
+
+    # "destroy" call is asynchronous, this is why we need to set timeout.
+    setTimeout (->
+      award.tooltip()
+    ), 200
+    
+
+  createEmoji: (emoji, custom_path) ->
+    nodes = []
+    nodes.push("<div class='award active' title='me'>")
+    nodes.push("<div class='icon' data-emoji='" + emoji + "'>")
+    nodes.push(@getImage(emoji, custom_path))
+    nodes.push("</div>")
+    nodes.push("<div class='counter'>1")
+    nodes.push("</div></div>")
+
+    $(".awards-controls").before(nodes.join("\n"))
+
+    $(".award").tooltip()
+
+  getImage: (emoji, custom_path) ->
+    if custom_path
+      $(".awards-menu li").first().html().replace(/emoji\/.*\.png/, custom_path)
+    else
+      $("li[data-emoji='" + emoji + "']").html()
+
+
+  postEmoji: (emoji, callback) ->
+    $.post @post_emoji_url, { note: {
+      note: ":" + emoji + ":"
+      noteable_type: @noteable_type
+      noteable_id: @noteable_id
+    }},(data) ->
+      if data.ok
+        callback.call()
+
+  findEmojiIcon: (emoji) ->
+    $(".icon[data-emoji='" + emoji + "']")
\ No newline at end of file

app/assets/javascripts/blob/blob_file_dropzone.js.coffee

@@ -23,18 +23,6 @@ class @BlobFileDropzone
       init: ->
         this.on 'addedfile', (file) ->
           $('.dropzone-alerts').html('').hide()
-          commit_message = form.find('#commit_message')[0]
-
-          if /^Upload/.test(commit_message.placeholder)
-            commit_message.placeholder = 'Upload ' + file.name
-
-          return
-
-        this.on 'removedfile', (file) ->
-          commit_message = form.find('#commit_message')[0]
-
-          if /^Upload/.test(commit_message.placeholder)
-            commit_message.placeholder = 'Upload new file'
 
           return
 
@@ -47,8 +35,9 @@ class @BlobFileDropzone
           return
 
         this.on 'sending', (file, xhr, formData) ->
-          formData.append('new_branch', form.find('#new_branch').val())
-          formData.append('commit_message', form.find('#commit_message').val())
+          formData.append('new_branch', form.find('.js-new-branch').val())
+          formData.append('create_merge_request', form.find('.js-create-merge-request').val())
+          formData.append('commit_message', form.find('.js-commit-message').val())
           return
 
       # Override behavior of adding error underneath preview

app/assets/javascripts/copy_to_clipboard.js.coffee

@@ -9,13 +9,24 @@ $ ->
   clipboard.on 'success', (e) ->
     $(e.trigger).
       tooltip(trigger: 'manual', placement: 'auto bottom', title: 'Copied!').
-      tooltip('show')
+      tooltip('show').
+      one('mouseleave', -> $(this).tooltip('hide'))
 
     # Clear the selection and blur the trigger so it loses its border
     e.clearSelection()
     $(e.trigger).blur()
 
-    # Manually hide the tooltip after 1 second
-    setTimeout(->
-      $(e.trigger).tooltip('hide')
-    , 1000)
+  # Safari doesn't support `execCommand`, so instead we inform the user to
+  # copy manually.
+  #
+  # See http://clipboardjs.com/#browser-support
+  clipboard.on 'error', (e) ->
+    if /Mac/i.test(navigator.userAgent)
+      title = "Press ⌘-C to copy"
+    else
+      title = "Press Ctrl-C to copy"
+
+    $(e.trigger).
+      tooltip(trigger: 'manual', placement: 'auto bottom', html: true, title: title).
+      tooltip('show').
+      one('mouseleave', -> $(this).tooltip('hide'))

app/assets/javascripts/new_commit_form.js.coffee

+class @NewCommitForm
+  constructor: (form) ->
+    @newBranch = form.find('.js-new-branch')
+    @originalBranch = form.find('.js-original-branch')
+    @createMergeRequest = form.find('.js-create-merge-request')
+    @createMergeRequestFormGroup = form.find('.js-create-merge-request-form-group')
+
+    @renderDestination()
+    @newBranch.keyup @renderDestination
+
+  renderDestination: =>
+    different = @newBranch.val() != @originalBranch.val()
+
+    if different
+      @createMergeRequestFormGroup.show()
+      @createMergeRequest.prop('checked', true) unless @wasDifferent
+    else
+      @createMergeRequestFormGroup.hide()
+      @createMergeRequest.prop('checked', false)
+
+    @wasDifferent = different

app/assets/javascripts/notes.js.coffee

@@ -113,13 +113,16 @@ class @Notes
   renderNote: (note) ->
     # render note if it not present in loaded list
     # or skip if rendered
-    if @isNewNote(note)
+    if @isNewNote(note) && !note.award
       @note_ids.push(note.id)
       $('ul.main-notes-list').
         append(note.html).
         syntaxHighlight()
       @initTaskList()
 
+    if note.award
+      awards_handler.addAwardToEmojiBar(note.note, note.emoji_path)
+
   ###
   Check if note does not exists on page
   ###
@@ -255,7 +258,6 @@ class @Notes
   ###
   addNote: (xhr, note, status) =>
     @renderNote(note)
-    @updateVotes()
 
   ###
   Called in response to the new note form being submitted
@@ -473,9 +475,6 @@ class @Notes
     form = $(e.target).closest(".js-discussion-note-form")
     @removeDiscussionNoteForm(form)
 
-  updateVotes: ->
-    true
-
   ###
   Called after an attachment file has been selected.
 

app/assets/stylesheets/pages/commit.scss

@@ -56,6 +56,7 @@
 
     li {
       padding: 3px 0px;
+      line-height: 20px;
     }
   }
   .new-file {

app/assets/stylesheets/pages/issuable.scss

@@ -101,3 +101,71 @@
     background-color: $background-color;
   }
 }
+
+.awards {
+  @include clearfix;
+  line-height: 34px;
+  margin: 2px 0;
+
+  .award {
+    @include border-radius(5px);
+
+    border: 1px solid;
+    padding: 0px 10px;
+    float: left;
+    margin: 0 5px;
+    border-color: $border-color;
+    cursor: pointer;
+
+    &.active {
+      border-color: $border-gray-light;
+      background-color: $gray-light;
+
+      .counter {
+        font-weight: bold;
+      }
+    }
+
+    .icon {
+      float: left;
+      margin-right: 10px;
+    }
+
+    .counter {
+      float: left;
+    }
+  }
+
+  .awards-controls {
+    margin-left: 10px;
+    float: left;
+
+    .add-award {
+      font-size: 24px;
+      color: $gl-gray;
+      position: relative;
+      top: 2px;
+
+      &:hover,
+      &:link {
+        text-decoration: none;
+      }
+    }
+
+    .awards-menu {
+      padding: $gl-padding;
+      min-width: 214px;
+
+      > li {
+        margin: 5px;
+      }
+    }
+  }
+
+  .awards-menu{
+    li {
+      float: left;
+      margin: 3px;
+    }
+  }
+}

app/controllers/ci/lints_controller.rb

@@ -15,10 +15,10 @@ module Ci
         @builds = @config_processor.builds
         @status = true
       end
-    rescue Ci::GitlabCiYamlProcessor::ValidationError => e
+    rescue Ci::GitlabCiYamlProcessor::ValidationError, Psych::SyntaxError => e
       @error = e.message
       @status = false
-    rescue Exception
+    rescue
       @error = "Undefined error"
       @status = false
     end

app/controllers/concerns/creates_merge_request_for_commit.rb

+module CreatesMergeRequestForCommit
+  extend ActiveSupport::Concern
+
+  def new_merge_request_path
+    if @project.forked?
+      target_project = @project.forked_from_project || @project
+      target_branch = target_project.repository.root_ref
+    else
+      target_project = @project
+      target_branch = @ref
+    end
+
+    new_namespace_project_merge_request_path(
+      @project.namespace,
+      @project,
+      merge_request: {
+        source_project_id: @project.id,
+        target_project_id: target_project.id,
+        source_branch: @new_branch,
+        target_branch: target_branch
+      }
+    )
+  end
+
+  def create_merge_request?
+    params[:create_merge_request] && @new_branch != @ref
+  end
+end

app/controllers/projects/blob_controller.rb

 # Controller for viewing a file's blame
 class Projects::BlobController < Projects::ApplicationController
   include ExtractsPath
+  include CreatesMergeRequestForCommit
   include ActionView::Helpers::SanitizeHelper
 
   # Raised when given an invalid file path
@@ -22,21 +23,9 @@ class Projects::BlobController < Projects::ApplicationController
   end
 
   def create
-    result = Files::CreateService.new(@project, current_user, @commit_params).execute
-
-    if result[:status] == :success
-      flash[:notice] = "The changes have been successfully committed"
-      respond_to do |format|
-        format.html { redirect_to namespace_project_blob_path(@project.namespace, @project, File.join(@target_branch, @file_path)) }
-        format.json { render json: { message: "success", filePath: namespace_project_blob_path(@project.namespace, @project, File.join(@target_branch, @file_path)) } }
-      end
-    else
-      flash[:alert] = result[:message]
-      respond_to do |format|
-        format.html { render :new }
-        format.json { render json: { message: "failed", filePath: namespace_project_blob_path(@project.namespace, @project, @id) } }
-      end
-    end
+    create_commit(Files::CreateService, success_path: after_create_path,
+                                        failure_view: :new,
+                                        failure_path: namespace_project_new_blob_path(@project.namespace, @project, @ref))
   end
 
   def show
@@ -47,21 +36,9 @@ class Projects::BlobController < Projects::ApplicationController
   end
 
   def update
-    result = Files::UpdateService.new(@project, current_user, @commit_params).execute
-
-    if result[:status] == :success
-      flash[:notice] = "Your changes have been successfully committed"
-      respond_to do |format|
-        format.html { redirect_to after_edit_path }
-        format.json { render json: { message: "success", filePath: after_edit_path } }
-      end
-    else
-      flash[:alert] = result[:message]
-      respond_to do |format|
-        format.html { render :edit }
-        format.json { render json: { message: "failed", filePath: namespace_project_new_blob_path(@project.namespace, @project, @id) } }
-      end
-    end
+    create_commit(Files::UpdateService, success_path: after_edit_path,
+                                        failure_view: :edit,
+                                        failure_path: namespace_project_blob_path(@project.namespace, @project, @id))
   end
 
   def preview
@@ -77,7 +54,7 @@ class Projects::BlobController < Projects::ApplicationController
 
     if result[:status] == :success
       flash[:notice] = "Your changes have been successfully committed"
-      redirect_to namespace_project_tree_path(@project.namespace, @project, @target_branch)
+      redirect_to after_destroy_path
     else
       flash[:alert] = result[:message]
       render :show
@@ -131,15 +108,51 @@ class Projects::BlobController < Projects::ApplicationController
     render_404
   end
 
+  def create_commit(service, success_path:, failure_view:, failure_path:)
+    result = service.new(@project, current_user, @commit_params).execute
+
+    if result[:status] == :success
+      flash[:notice] = "Your changes have been successfully committed"
+      respond_to do |format|
+        format.html { redirect_to success_path }
+        format.json { render json: { message: "success", filePath: success_path } }
+      end
+    else
+      flash[:alert] = result[:message]
+      respond_to do |format|
+        format.html { render failure_view }
+        format.json { render json: { message: "failed", filePath: failure_path } }
+      end
+    end
+  end
+
+  def after_create_path
+    @after_create_path ||=
+      if create_merge_request?
+        new_merge_request_path
+      else
+        namespace_project_blob_path(@project.namespace, @project, File.join(@new_branch, @file_path))
+      end
+  end
+
   def after_edit_path
     @after_edit_path ||=
-      if from_merge_request
+      if create_merge_request?
+        new_merge_request_path
+      elsif from_merge_request && @new_branch == @ref
         diffs_namespace_project_merge_request_path(from_merge_request.target_project.namespace, from_merge_request.target_project, from_merge_request) +
           "#file-path-#{hexdigest(@path)}"
-      elsif @target_branch.present?
-        namespace_project_blob_path(@project.namespace, @project, File.join(@target_branch, @path))
       else
-        namespace_project_blob_path(@project.namespace, @project, @id)
+        namespace_project_blob_path(@project.namespace, @project, File.join(@new_branch, @path))
+      end
+  end
+
+  def after_destroy_path
+    @after_destroy_path ||=
+      if create_merge_request?
+        new_merge_request_path
+      else
+        namespace_project_tree_path(@project.namespace, @project, @new_branch)
       end
   end
 
@@ -154,7 +167,7 @@ class Projects::BlobController < Projects::ApplicationController
 
   def editor_variables
     @current_branch = @ref
-    @target_branch = params[:new_branch].present? ? sanitized_new_branch_name : @ref
+    @new_branch = params[:new_branch].present? ? sanitized_new_branch_name : @ref
 
     @file_path =
       if action_name.to_s == 'create'
@@ -174,7 +187,7 @@ class Projects::BlobController < Projects::ApplicationController
     @commit_params = {
       file_path: @file_path,
       current_branch: @current_branch,
-      target_branch: @target_branch,
+      target_branch: @new_branch,
       commit_message: params[:commit_message],
       file_content: params[:content],
       file_content_encoding: params[:encoding]

app/controllers/projects/issues_controller.rb

@@ -66,7 +66,7 @@ class Projects::IssuesController < Projects::ApplicationController
   def show
     @participants = @issue.participants(current_user)
     @note = @project.notes.new(noteable: @issue)
-    @notes = @issue.notes.with_associations.fresh
+    @notes = @issue.notes.nonawards.with_associations.fresh
     @noteable = @issue
 
     respond_with(@issue)

app/controllers/projects/merge_requests_controller.rb

@@ -294,7 +294,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
 
     # Build a note object for comment form
     @note = @project.notes.new(noteable: @merge_request)
-    @notes = @merge_request.mr_and_commit_notes.inc_author.fresh
+    @notes = @merge_request.mr_and_commit_notes.nonawards.inc_author.fresh
     @discussions = Note.discussions_from_notes(@notes)
     @noteable = @merge_request
 

app/controllers/projects/notes_controller.rb

@@ -3,7 +3,7 @@ class Projects::NotesController < Projects::ApplicationController
   before_action :authorize_read_note!
   before_action :authorize_create_note!, only: [:create]
   before_action :authorize_admin_note!, only: [:update, :destroy]
-  before_action :find_current_user_notes, except: [:destroy, :delete_attachment]
+  before_action :find_current_user_notes, except: [:destroy, :delete_attachment, :award_toggle]
 
   def index
     current_fetched_at = Time.now.to_i
@@ -58,6 +58,27 @@ class Projects::NotesController < Projects::ApplicationController
     end
   end
 
+  def award_toggle
+    noteable = note_params[:noteable_type] == "issue" ? Issue : MergeRequest
+    noteable = noteable.find_by!(id: note_params[:noteable_id], project: project)
+
+    data = {
+      author: current_user,
+      is_award: true,
+      note: note_params[:note].gsub(":", '')
+    }
+
+    note = noteable.notes.find_by(data)
+
+    if note
+      note.destroy
+    else
+      Notes::CreateService.new(project, current_user, note_params).execute
+    end
+
+    render json: { ok: true }
+  end
+
   private
 
   def note
@@ -111,6 +132,9 @@ class Projects::NotesController < Projects::ApplicationController
       id: note.id,
       discussion_id: note.discussion_id,
       html: note_to_html(note),
+      award: note.is_award,
+      emoji_path: note.is_award ? ::AwardEmoji.path_to_emoji_image(note.note) : "",
+      note: note.note,
       discussion_html: note_to_discussion_html(note),
       discussion_with_diff_html: note_to_discussion_with_diff_html(note)
     }

app/controllers/projects/tree_controller.rb

 # Controller for viewing a repository's file structure
 class Projects::TreeController < Projects::ApplicationController
   include ExtractsPath
+  include CreatesMergeRequestForCommit
   include ActionView::Helpers::SanitizeHelper
 
   before_action :require_non_empty_project, except: [:new, :create]
@@ -43,7 +44,7 @@ class Projects::TreeController < Projects::ApplicationController
     if result && result[:status] == :success
       flash[:notice] = "The directory has been successfully created"
       respond_to do |format|
-        format.html { redirect_to namespace_project_blob_path(@project.namespace, @project, File.join(@new_branch, @dir_name)) }
+        format.html { redirect_to after_create_dir_path }
       end
     else
       flash[:alert] = message
@@ -53,6 +54,8 @@ class Projects::TreeController < Projects::ApplicationController
     end
   end
 
+  private
+
   def assign_dir_vars
     @new_branch = params[:new_branch].present? ? sanitize(strip_tags(params[:new_branch])) : @ref
     @dir_name = File.join(@path, params[:dir_name])
@@ -63,4 +66,12 @@ class Projects::TreeController < Projects::ApplicationController
       commit_message: params[:commit_message],
     }
   end
+
+  def after_create_dir_path
+    if create_merge_request?
+      new_merge_request_path
+    else
+      namespace_project_blob_path(@project.namespace, @project, File.join(@new_branch, @dir_name))
+    end
+  end
 end

app/controllers/snippets_controller.rb

 class SnippetsController < ApplicationController
   before_action :snippet, only: [:show, :edit, :destroy, :update, :raw]
 
+  # Allow read snippet
+  before_action :authorize_read_snippet!, only: [:show]
+
   # Allow modify snippet
   before_action :authorize_update_snippet!, only: [:edit, :update]
 
@@ -79,10 +82,14 @@ class SnippetsController < ApplicationController
                      [Snippet::PUBLIC, Snippet::INTERNAL]).
                      find(params[:id])
                  else
-                   PersonalSnippet.are_public.find(params[:id])
+                   PersonalSnippet.find(params[:id])
                  end
   end
 
+  def authorize_read_snippet!
+    authenticate_user! unless can?(current_user, :read_personal_snippet, @snippet)
+  end
+
   def authorize_update_snippet!
     return render_404 unless can?(current_user, :update_personal_snippet, @snippet)
   end

app/controllers/users_controller.rb

@@ -3,14 +3,11 @@ class UsersController < ApplicationController
   before_action :set_user
 
   def show
-    @contributed_projects = contributed_projects.joined(@user).
-      reject(&:forked?)
+    @contributed_projects = contributed_projects.joined(@user).reject(&:forked?)
 
-    @projects = @user.personal_projects.
-      where(id: authorized_projects_ids).includes(:namespace)
+    @projects = PersonalProjectsFinder.new(@user).execute(current_user)
 
-    # Collect only groups common for both users
-    @groups = @user.groups & GroupsFinder.new.execute(current_user)
+    @groups = JoinedGroupsFinder.new(@user).execute(current_user)
 
     respond_to do |format|
       format.html
@@ -53,16 +50,8 @@ class UsersController < ApplicationController
     @user = User.find_by_username!(params[:username])
   end
 
-  def authorized_projects_ids
-    # Projects user can view
-    @authorized_projects_ids ||=
-      ProjectsFinder.new.execute(current_user).pluck(:id)
-  end
-
   def contributed_projects
-    @contributed_projects = Project.
-      where(id: authorized_projects_ids & @user.contributed_projects_ids).
-      includes(:namespace)
+    ContributedProjectsFinder.new(@user).execute(current_user)
   end
 
   def contributions_calendar
@@ -73,9 +62,13 @@ class UsersController < ApplicationController
   def load_events
     # Get user activity feed for projects common for both users
     @events = @user.recent_events.
-      where(project_id: authorized_projects_ids).
-      with_associations
+      merge(projects_for_current_user).
+      references(:project).
+      with_associations.
+      limit_recent(20, params[:offset])
+  end
 
-    @events = @events.limit(20).offset(params[:offset] || 0)
+  def projects_for_current_user
+    ProjectsFinder.new.execute(current_user)
   end
 end

app/finders/contributed_projects_finder.rb

+class ContributedProjectsFinder
+  def initialize(user)
+    @user = user
+  end
+
+  # Finds the projects "@user" contributed to, limited to either public projects
+  # or projects visible to the given user.
+  #
+  # current_user - When given the list of the projects is limited to those only
+  #                visible by this user.
+  #
+  # Returns an ActiveRecord::Relation.
+  def execute(current_user = nil)
+    if current_user
+      relation = projects_visible_to_user(current_user)
+    else
+      relation = public_projects
+    end
+
+    relation.includes(:namespace).order_id_desc
+  end
+
+  private
+
+  def projects_visible_to_user(current_user)
+    authorized = @user.contributed_projects.visible_to_user(current_user)
+
+    union = Gitlab::SQL::Union.
+      new([authorized.select(:id), public_projects.select(:id)])
+
+    Project.where("projects.id IN (#{union.to_sql})")
+  end
+
+  def public_projects
+    @user.contributed_projects.public_only
+  end
+end

app/finders/groups_finder.rb

 class GroupsFinder
-  def execute(current_user, options = {})
-    all_groups(current_user)
+  # Finds the groups available to the given user.
+  #
+  # current_user - The user to find the groups for.
+  #
+  # Returns an ActiveRecord::Relation.
+  def execute(current_user = nil)
+    if current_user
+      relation = groups_visible_to_user(current_user)
+    else
+      relation = public_groups
+    end
+
+    relation.order_id_desc
   end
 
   private
 
-  def all_groups(current_user)
-    group_ids = if current_user
-                  if current_user.authorized_groups.any?
-                    # User has access to groups
-                    #
-                    # Return only:
-                    #   groups with public projects
-                    #   groups with internal projects
-                    #   groups with joined projects
-                    #
-                    Project.public_and_internal_only.pluck(:namespace_id) +
-                      current_user.authorized_groups.pluck(:id)
-                  else
-                    # User has no group membership
-                    #
-                    # Return only:
-                    #   groups with public projects
-                    #   groups with internal projects
-                    #
-                    Project.public_and_internal_only.pluck(:namespace_id)
-                  end
-                else
-                  # Not authenticated
-                  #
-                  # Return only:
-                  #   groups with public projects
-                  Project.public_only.pluck(:namespace_id)
-                end
-
-    Group.where("public IS TRUE OR id IN(?)", group_ids)
+  # This method returns the groups "current_user" can see.
+  def groups_visible_to_user(current_user)
+    base = groups_for_projects(public_and_internal_projects)
+
+    union = Gitlab::SQL::Union.
+      new([base.select(:id), current_user.authorized_groups.select(:id)])
+
+    Group.where("namespaces.id IN (#{union.to_sql})")
+  end
+
+  def public_groups
+    groups_for_projects(public_projects)
+  end
+
+  def groups_for_projects(projects)
+    Group.public_and_given_groups(projects.select(:namespace_id))
+  end
+
+  def public_projects
+    Project.unscoped.public_only
+  end
+
+  def public_and_internal_projects
+    Project.unscoped.public_and_internal_only
   end
 end

app/finders/joined_groups_finder.rb

+# Class for finding the groups a user is a member of.
+class JoinedGroupsFinder
+  def initialize(user = nil)
+    @user = user
+  end
+
+  # Finds the groups of the source user, optionally limited to those visible to
+  # the current user.
+  #
+  # current_user - If given the groups of "@user" will only include the groups
+  #                "current_user" can also see.
+  #
+  # Returns an ActiveRecord::Relation.
+  def execute(current_user = nil)
+    if current_user
+      relation = groups_visible_to_user(current_user)
+    else
+      relation = public_groups
+    end
+
+    relation.order_id_desc
+  end
+
+  private
+
+  # Returns the groups the user in "current_user" can see.
+  #
+  # This list includes all public/internal projects as well as the projects of
+  # "@user" that "current_user" also has access to.
+  def groups_visible_to_user(current_user)
+    base  = @user.authorized_groups.visible_to_user(current_user)
+    extra = public_and_internal_groups
+    union = Gitlab::SQL::Union.new([base.select(:id), extra.select(:id)])
+
+    Group.where("namespaces.id IN (#{union.to_sql})")
+  end
+
+  def public_groups
+    groups_for_projects(@user.authorized_projects.public_only)
+  end
+
+  def public_and_internal_groups
+    groups_for_projects(@user.authorized_projects.public_and_internal_only)
+  end
+
+  def groups_for_projects(projects)
+    @user.groups.public_and_given_groups(projects.select(:namespace_id))
+  end
+end

app/finders/notes_finder.rb

@@ -12,9 +12,9 @@ class NotesFinder
       when "commit"
         project.notes.for_commit_id(target_id).not_inline
       when "issue"
-        project.issues.find(target_id).notes.inc_author
+        project.issues.find(target_id).notes.nonawards.inc_author
       when "merge_request"
-        project.merge_requests.find(target_id).mr_and_commit_notes.inc_author
+        project.merge_requests.find(target_id).mr_and_commit_notes.nonawards.inc_author
       when "snippet", "project_snippet"
         project.snippets.find(target_id).notes
       else

app/finders/personal_projects_finder.rb

+class PersonalProjectsFinder
+  def initialize(user)
+    @user = user
+  end
+
+  # Finds the projects belonging to the user in "@user", limited to either
+  # public projects or projects visible to the given user.
+  #
+  # current_user - When given the list of projects is limited to those only
+  #                visible by this user.
+  #
+  # Returns an ActiveRecord::Relation.
+  def execute(current_user = nil)
+    if current_user
+      relation = projects_visible_to_user(current_user)
+    else
+      relation = public_projects
+    end
+
+    relation.includes(:namespace).order_id_desc
+  end
+
+  private
+
+  def projects_visible_to_user(current_user)
+    authorized = @user.personal_projects.visible_to_user(current_user)
+
+    union = Gitlab::SQL::Union.
+      new([authorized.select(:id), public_and_internal_projects.select(:id)])
+
+    Project.where("projects.id IN (#{union.to_sql})")
+  end
+
+  def public_projects
+    @user.personal_projects.public_only
+  end
+
+  def public_and_internal_projects
+    @user.personal_projects.public_and_internal_only
+  end
+end

app/finders/projects_finder.rb

 class ProjectsFinder
-  def execute(current_user, options = {})
+  # Returns all projects, optionally including group projects a user has access
+  # to.
+  #
+  # ## Examples
+  #
+  # Retrieving all public projects:
+  #
+  #     ProjectsFinder.new.execute
+  #
+  # Retrieving all public/internal projects and those the given user has access
+  # to:
+  #
+  #     ProjectsFinder.new.execute(some_user)
+  #
+  # Retrieving all public/internal projects as well as the group's projects the
+  # user has access to:
+  #
+  #     ProjectsFinder.new.execute(some_user, group: some_group)
+  #
+  # Returns an ActiveRecord::Relation.
+  def execute(current_user = nil, options = {})
     group = options[:group]
 
     if group
-      group_projects(current_user, group)
+      base, extra = group_projects(current_user, group)
     else
-      all_projects(current_user)
+      base, extra = all_projects(current_user)
+    end
+
+    if base and extra
+      union = Gitlab::SQL::Union.new([base.select(:id), extra.select(:id)])
+
+      Project.where("projects.id IN (#{union.to_sql})")
+    else
+      base
     end
   end
 
@@ -13,6 +41,7 @@ class ProjectsFinder
 
   def group_projects(current_user, group)
     if current_user
+<<<<<<< HEAD
       if group.users.include?(current_user)
         # User is group member
         #
@@ -57,45 +86,38 @@ class ProjectsFinder
           )
         end
       end
+=======
+      [
+        group_projects_for_user(current_user, group),
+        group.projects.public_and_internal_only
+      ]
+>>>>>>> b6f0eddce552d7423869e9072a7a0706e309dbdf
     else
-      # Not authenticated
-      #
-      # Return only:
-      #   public projects
-      group.projects.public_only
+      [group.projects.public_only]
     end
   end
 
   def all_projects(current_user)
     if current_user
-      if current_user.authorized_projects.any?
-        # User has access to private projects
-        #
-        # Return only:
-        #   public projects
-        #   internal projects
-        #   joined projects
-        #
-        Project.where(
-          "projects.id IN (?) OR projects.visibility_level IN (?)",
-          current_user.authorized_projects.pluck(:id),
-          Project.public_and_internal_levels
-        )
-      else
-        # User has no access to private projects
-        #
-        # Return only:
-        #   public projects
-        #   internal projects
-        #
-        Project.public_and_internal_only
-      end
+      [current_user.authorized_projects, public_and_internal_projects]
+    else
+      [Project.public_only]
+    end
+  end
+
+  def group_projects_for_user(current_user, group)
+    if group.users.include?(current_user)
+      group.projects
     else
-      # Not authenticated
-      #
-      # Return only:
-      #   public projects
-      Project.public_only
+      group.projects.visible_to_user(current_user)
     end
   end
+
+  def public_projects
+    Project.unscoped.public_only
+  end
+
+  def public_and_internal_projects
+    Project.unscoped.public_and_internal_only
+  end
 end

app/helpers/issues_helper.rb

@@ -87,6 +87,33 @@ module IssuesHelper
     merge_requests.map(&:to_reference).to_sentence(last_word_connector: ', or ')
   end
 
+  def url_to_emoji(name)
+    emoji_path = ::AwardEmoji.path_to_emoji_image(name)
+    url_to_image(emoji_path)
+  rescue StandardError
+    ""
+  end
+
+  def emoji_author_list(notes, current_user)
+    list = notes.map do |note|
+             note.author == current_user ? "me" : note.author.username
+           end
+
+    list.join(", ")
+  end
+
+  def emoji_list
+    ::AwardEmoji::EMOJI_LIST
+  end
+
+  def note_active_class(notes, current_user)
+    if current_user && notes.pluck(:author_id).include?(current_user.id)
+      "active"
+    else
+      ""
+    end
+  end
+
   # Required for Gitlab::Markdown::IssueReferenceFilter
   module_function :url_for_issue
 end

app/helpers/merge_requests_helper.rb

@@ -8,14 +8,6 @@ module MergeRequestsHelper
     )
   end
 
-  def new_mr_path_for_fork_from_push_event(event)
-    new_namespace_project_merge_request_path(
-      event.project.namespace,
-      event.project,
-      new_mr_from_push_event(event, event.project.forked_from_project)
-    )
-  end
-
   def new_mr_from_push_event(event, target_project)
     {
       merge_request: {

app/models/ability.rb

 class Ability
   class << self
     def allowed(user, subject)
-      return not_auth_abilities(user, subject) if user.nil?
-      return [] unless user.kind_of?(User)
+      return anonymous_abilities(user, subject) if user.nil?
+      return [] unless user.is_a?(User)
       return [] if user.blocked?
 
       abilities =
@@ -36,15 +36,25 @@ class Ability
       ]
     end
 
-    # List of possible abilities
-    # for non-authenticated user
-    def not_auth_abilities(user, subject)
-      project = if subject.kind_of?(Project)
+    # List of possible abilities for anonymous user
+    def anonymous_abilities(user, subject)
+      case true
+      when subject.is_a?(PersonalSnippet)
+        anonymous_personal_snippet_abilities(subject)
+      when subject.is_a?(Project) || subject.respond_to?(:project)
+        anonymous_project_abilities(subject)
+      when subject.is_a?(Group) || subject.respond_to?(:group)
+        anonymous_group_abilities(subject)
+      else
+        []
+      end
+    end
+
+    def anonymous_project_abilities(subject)
+      project = if subject.is_a?(Project)
                   subject
-                elsif subject.respond_to?(:project)
-                  subject.project
                 else
-                  nil
+                  subject.project
                 end
 
       if project && project.public?
@@ -64,19 +74,29 @@ class Ability
 
         rules - project_disabled_features_rules(project)
       else
-        group = if subject.kind_of?(Group)
-                  subject
-                elsif subject.respond_to?(:group)
-                  subject.group
-                else
-                  nil
-                end
+        []
+      end
+    end
 
-        if group && group.public_profile?
-          [:read_group]
-        else
-          []
-        end
+    def anonymous_group_abilities(subject)
+      group = if subject.is_a?(Group)
+                subject
+              else
+                subject.group
+              end
+
+      if group && group.public_profile?
+        [:read_group]
+      else
+        []
+      end
+    end
+
+    def anonymous_personal_snippet_abilities(snippet)
+      if snippet.public?
+        [:read_personal_snippet]
+      else
+        []
       end
     end
 
@@ -300,7 +320,7 @@ class Ability
       end
     end
 
-    [:note, :project_snippet, :personal_snippet].each do |name|
+    [:note, :project_snippet].each do |name|
       define_method "#{name}_abilities" do |user, subject|
         rules = []
 
@@ -320,6 +340,24 @@ class Ability
       end
     end
 
+    def personal_snippet_abilities(user, snippet)
+      rules = []
+
+      if snippet.author == user
+        rules += [
+          :read_personal_snippet,
+          :update_personal_snippet,
+          :admin_personal_snippet
+        ]
+      end
+
+      if snippet.public? || snippet.internal?
+        rules << :read_personal_snippet 
+      end
+
+      rules
+    end
+
     def group_member_abilities(user, subject)
       rules = []
       target_user = subject.user

app/models/ci/commit.rb

@@ -188,13 +188,13 @@ module Ci
     end
 
     def config_processor
+      return nil unless ci_yaml_file
       @config_processor ||= Ci::GitlabCiYamlProcessor.new(ci_yaml_file, gl_project.path_with_namespace)
-    rescue Ci::GitlabCiYamlProcessor::ValidationError => e
+    rescue Ci::GitlabCiYamlProcessor::ValidationError, Psych::SyntaxError => e
       save_yaml_error(e.message)
       nil
-    rescue Exception => e
-      logger.error e.message + "\n" + e.backtrace.join("\n")
-      save_yaml_error("Undefined yaml error")
+    rescue
+      save_yaml_error("Undefined error")
       nil
     end
 

app/models/concerns/issuable.rb

@@ -89,41 +89,6 @@ module Issuable
     opened? || reopened?
   end
 
-  #
-  # Votes
-  #
-
-  # Return the number of -1 comments (downvotes)
-  def downvotes
-    filter_superceded_votes(notes.select(&:downvote?), notes).size
-  end
-
-  def downvotes_in_percent
-    if votes_count.zero?
-      0
-    else
-      100.0 - upvotes_in_percent
-    end
-  end
-
-  # Return the number of +1 comments (upvotes)
-  def upvotes
-    filter_superceded_votes(notes.select(&:upvote?), notes).size
-  end
-
-  def upvotes_in_percent
-    if votes_count.zero?
-      0
-    else
-      100.0 / votes_count * upvotes
-    end
-  end
-
-  # Return the total number of votes
-  def votes_count
-    upvotes + downvotes
-  end
-
   def subscribed?(user)
     subscription = subscriptions.find_by_user_id(user.id)
 
@@ -183,18 +148,4 @@ module Issuable
   def notes_with_associations
     notes.includes(:author, :project)
   end
-
-  private
-
-  def filter_superceded_votes(votes, notes)
-    filteredvotes = [] + votes
-
-    votes.each do |vote|
-      if vote.superceded?(notes)
-        filteredvotes.delete(vote)
-      end
-    end
-
-    filteredvotes
-  end
 end

app/models/concerns/sortable.rb

@@ -8,8 +8,9 @@ module Sortable
   included do
     # By default all models should be ordered
     # by created_at field starting from newest
-    default_scope { order(id: :desc) }
+    default_scope { order_id_desc }
 
+    scope :order_id_desc, -> { reorder(id: :desc) }
     scope :order_created_desc, -> { reorder(created_at: :desc) }
     scope :order_created_asc, -> { reorder(created_at: :asc) }
     scope :order_updated_desc, -> { reorder(updated_at: :desc) }

app/models/event.rb

@@ -63,6 +63,16 @@ class Event < ActiveRecord::Base
             Event::PUSHED, ["MergeRequest", "Issue"],
             [Event::CREATED, Event::CLOSED, Event::MERGED])
     end
+
+    def latest_update_time
+      row = select(:updated_at, :project_id).reorder(id: :desc).take
+
+      row ? row.updated_at : nil
+    end
+
+    def limit_recent(limit = 20, offset = nil)
+      recent.limit(limit).offset(offset)
+    end
   end
 
   def proper?

app/models/group.rb

@@ -53,6 +53,14 @@ class Group < Namespace
     def reference_pattern
       User.reference_pattern
     end
+
+    def public_and_given_groups(ids)
+      where('public IS TRUE OR namespaces.id IN (?)', ids)
+    end
+
+    def visible_to_user(user)
+      where(id: user.authorized_groups.select(:id).reorder(nil))
+    end
   end
 
   def to_reference(_from_project = nil)

app/models/note.rb

@@ -40,16 +40,20 @@ class Note < ActiveRecord::Base
   delegate :name, :email, to: :author, prefix: true
 
   validates :note, :project, presence: true
+  validates :note, uniqueness: { scope: [:author, :noteable_type, :noteable_id] }, if: ->(n) { n.is_award }
   validates :line_code, format: { with: /\A[a-z0-9]+_\d+_\d+\Z/ }, allow_blank: true
   # Attachments are deprecated and are handled by Markdown uploader
   validates :attachment, file_size: { maximum: :max_attachment_size }
 
   validates :noteable_id, presence: true, if: ->(n) { n.noteable_type.present? && n.noteable_type != 'Commit' }
   validates :commit_id, presence: true, if: ->(n) { n.noteable_type == 'Commit' }
+  validates :author, presence: true
 
   mount_uploader :attachment, AttachmentUploader
 
   # Scopes
+  scope :awards, ->{ where(is_award: true) }
+  scope :nonawards, ->{ where(is_award: false) }
   scope :for_commit_id, ->(commit_id) { where(noteable_type: "Commit", commit_id: commit_id) }
   scope :inline, ->{ where("line_code IS NOT NULL") }
   scope :not_inline, ->{ where(line_code: [nil, '']) }
@@ -97,6 +101,12 @@ class Note < ActiveRecord::Base
     def search(query)
       where("LOWER(note) like :query", query: "%#{query.downcase}%")
     end
+
+    def grouped_awards
+      awards.select(:note).distinct.map do |note|
+        [ note.note, where(note: note.note) ]
+      end
+    end
   end
 
   def cross_reference?
@@ -288,44 +298,6 @@ class Note < ActiveRecord::Base
     nil
   end
 
-  DOWNVOTES = %w(-1 :-1: :thumbsdown: :thumbs_down_sign:)
-
-  # Check if the note is a downvote
-  def downvote?
-    votable? && note.start_with?(*DOWNVOTES)
-  end
-
-  UPVOTES = %w(+1 :+1: :thumbsup: :thumbs_up_sign:)
-
-  # Check if the note is an upvote
-  def upvote?
-    votable? && note.start_with?(*UPVOTES)
-  end
-
-  def superceded?(notes)
-    return false unless vote?
-
-    notes.each do |note|
-      next if note == self
-
-      if note.vote? &&
-        self[:author_id] == note[:author_id] &&
-        self[:created_at] <= note[:created_at]
-        return true
-      end
-    end
-
-    false
-  end
-
-  def vote?
-    upvote? || downvote?
-  end
-
-  def votable?
-    for_issue? || (for_merge_request? && !for_diff_line?)
-  end
-
   # Mentionable override.
   def gfm_reference(from_project = nil)
     noteable.gfm_reference(from_project)

app/models/project.rb

@@ -313,6 +313,10 @@ class Project < ActiveRecord::Base
 
       joins(join_body).reorder('join_note_counts.amount DESC')
     end
+
+    def visible_to_user(user)
+      where(id: user.authorized_projects.select(:id).reorder(nil))
+    end
   end
 
   def team

app/models/user.rb

@@ -417,14 +417,12 @@ class User < ActiveRecord::Base
     end
   end
 
-  # Groups user has access to
+  # Returns the groups a user has access to
   def authorized_groups
-    @authorized_groups ||= begin
-                             group_ids = (groups.pluck(:id) + authorized_projects.pluck(:namespace_id))
-                             Group.where(id: group_ids)
-                           end
-  end
+    union = Gitlab::SQL::Union.
+      new([groups.select(:id), authorized_projects.select(:namespace_id)])
 
+<<<<<<< HEAD
   def authorized_projects_id
     @authorized_projects_id ||= begin
       project_ids = personal_projects.pluck(:id)
@@ -441,19 +439,20 @@ class User < ActiveRecord::Base
       project_ids.push(*groups_projects.where(members: scope).pluck(:id))
       project_ids.push(*projects.where(members: scope).pluck(:id).uniq)
     end
+=======
+    Group.where("namespaces.id IN (#{union.to_sql})")
+>>>>>>> b6f0eddce552d7423869e9072a7a0706e309dbdf
   end
 
-  # Projects user has access to
+  # Returns the groups a user is authorized to access.
   def authorized_projects
-    @authorized_projects ||= Project.where(id: authorized_projects_id)
+    Project.where("projects.id IN (#{projects_union.to_sql})")
   end
 
   def owned_projects
     @owned_projects ||=
-      begin
-        namespace_ids = owned_groups.pluck(:id).push(namespace.id)
-        Project.in_namespace(namespace_ids).joins(:namespace)
-      end
+      Project.where('namespace_id IN (?) OR namespace_id = ?',
+                    owned_groups.select(:id), namespace.id).joins(:namespace)
   end
 
   # Team membership in authorized projects
@@ -772,12 +771,25 @@ class User < ActiveRecord::Base
     Doorkeeper::AccessToken.where(resource_owner_id: self.id, revoked_at: nil)
   end
 
-  def contributed_projects_ids
-    Event.contributions.where(author_id: self).
+  # Returns the projects a user contributed to in the last year.
+  #
+  # This method relies on a subquery as this performs significantly better
+  # compared to a JOIN when coupled with, for example,
+  # `Project.visible_to_user`. That is, consider the following code:
+  #
+  #     some_user.contributed_projects.visible_to_user(other_user)
+  #
+  # If this method were to use a JOIN the resulting query would take roughly 200
+  # ms on a database with a similar size to GitLab.com's database. On the other
+  # hand, using a subquery means we can get the exact same data in about 40 ms.
+  def contributed_projects
+    events = Event.select(:project_id).
+      contributions.where(author_id: self).
       where("created_at > ?", Time.now - 1.year).
-      reorder(project_id: :desc).
-      select(:project_id).
-      uniq.map(&:project_id)
+      uniq.
+      reorder(nil)
+
+    Project.where(id: events)
   end
 
   def restricted_signup_domains
@@ -810,8 +822,27 @@ class User < ActiveRecord::Base
   def ci_authorized_runners
     @ci_authorized_runners ||= begin
       runner_ids = Ci::RunnerProject.joins(:project).
-        where(ci_projects: { gitlab_id: master_or_owner_projects_id }).select(:runner_id)
+        where("ci_projects.gitlab_id IN (#{ci_projects_union.to_sql})").
+        select(:runner_id)
+
       Ci::Runner.specific.where(id: runner_ids)
     end
   end
+
+  private
+
+  def projects_union
+    Gitlab::SQL::Union.new([personal_projects.select(:id),
+                            groups_projects.select(:id),
+                            projects.select(:id)])
+  end
+
+  def ci_projects_union
+    scope  = { access_level: [Gitlab::Access::MASTER, Gitlab::Access::OWNER] }
+    groups = groups_projects.where(members: scope)
+    other  = projects.where(members: scope)
+
+    Gitlab::SQL::Union.new([personal_projects.select(:id), groups.select(:id),
+                            other.select(:id)])
+  end
 end

app/services/git_push_service.rb

@@ -58,12 +58,6 @@ class GitPushService
 
     @push_data = build_push_data(oldrev, newrev, ref)
 
-    # If CI was disabled but .gitlab-ci.yml file was pushed
-    # we enable CI automatically
-    if !project.builds_enabled? && gitlab_ci_yaml?(newrev)
-      project.enable_ci
-    end
-
     EventCreateService.new.push(project, user, @push_data)
     project.execute_hooks(@push_data.dup, :push_hooks)
     project.execute_services(@push_data.dup, :push_hooks)
@@ -134,10 +128,4 @@ class GitPushService
   def commit_user(commit)
     commit.author || user
   end
-
-  def gitlab_ci_yaml?(sha)
-    @project.repository.blob_at(sha, '.gitlab-ci.yml')
-  rescue Rugged::ReferenceError
-    nil
-  end
 end

app/services/notes/create_service.rb

@@ -5,11 +5,16 @@ module Notes
       note.author = current_user
       note.system = false
 
+      if contains_emoji_only?(params[:note])
+        note.is_award = true
+        note.note = emoji_name(params[:note])
+      end
+
       if note.save
         notification_service.new_note(note)
 
-        # Skip system notes, like status changes and cross-references.
-        unless note.system
+        # Skip system notes, like status changes and cross-references and awards
+        unless note.system || note.is_award
           event_service.leave_note(note, note.author)
           note.create_cross_references!
           execute_hooks(note)
@@ -28,5 +33,13 @@ module Notes
       note.project.execute_hooks(note_data, :note_hooks)
       note.project.execute_services(note_data, :note_hooks)
     end
+
+    def contains_emoji_only?(note)
+      note =~ /\A:[-_+[:alnum:]]*:\s?\z/
+    end
+
+    def emoji_name(note)
+      note.match(/\A:([-_+[:alnum:]]*):\s?/)[1]
+    end
   end
 end

app/services/notification_service.rb

@@ -102,6 +102,7 @@ class NotificationService
     # ignore gitlab service messages
     return true if note.note.start_with?('Status changed to closed')
     return true if note.cross_reference? && note.system == true
+    return true if note.is_award
 
     target = note.noteable
 

app/views/dashboard/projects/index.atom.builder

@@ -4,7 +4,7 @@ xml.feed "xmlns" => "http://www.w3.org/2005/Atom", "xmlns:media" => "http://sear
   xml.link    href: dashboard_projects_url(format: :atom, private_token: current_user.try(:private_token)), rel: "self", type: "application/atom+xml"
   xml.link    href: dashboard_projects_url, rel: "alternate", type: "text/html"
   xml.id      dashboard_projects_url
-  xml.updated @events.maximum(:updated_at).strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
+  xml.updated @events.latest_update_time.strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
 
   @events.each do |event|
     event_to_atom(xml, event)

app/views/groups/show.atom.builder

@@ -4,7 +4,7 @@ xml.feed "xmlns" => "http://www.w3.org/2005/Atom", "xmlns:media" => "http://sear
   xml.link    href: group_url(@group, format: :atom, private_token: current_user.try(:private_token)), rel: "self", type: "application/atom+xml"
   xml.link    href: group_url(@group), rel: "alternate", type: "text/html"
   xml.id      group_url(@group)
-  xml.updated @events.maximum(:updated_at).strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
+  xml.updated @events.latest_update_time.strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
 
   @events.each do |event|
     event_to_atom(xml, event)

app/views/projects/_zen.html.haml

@@ -2,9 +2,12 @@
   %input#zen-toggle-comment.zen-toggle-comment(tabindex="-1" type="checkbox")
   .zen-backdrop
     - classes << ' js-gfm-input markdown-area'
-    = f.text_area attr, class: classes, placeholder: ''
+    - if defined?(f) && f
+      = f.text_area attr, class: classes, placeholder: ''
+    - else
+      = text_area_tag attr, nil, class: classes, placeholder: ''
     %a.zen-enter-link(tabindex="-1" href="#")
-      %i.fa.fa-expand
+      = icon('expand')
       Edit in fullscreen
     %a.zen-leave-link(href="#")
-      %i.fa.fa-compress
+      = icon('compress')

app/views/projects/blob/_actions.html.haml

@@ -19,4 +19,4 @@
 - if allowed_tree_edit?
   .btn-group{ role: "group" }
     %button.btn.btn-default{ 'data-target' => '#modal-upload-blob', 'data-toggle' => 'modal' } Replace
-    %button.btn.btn-remove{ 'data-target' => '#modal-remove-blob', 'data-toggle' => 'modal' } Remove
+    %button.btn.btn-remove{ 'data-target' => '#modal-remove-blob', 'data-toggle' => 'modal' } Delete

app/views/projects/blob/_new_dir.html.haml

@@ -5,21 +5,19 @@
         %a.close{href: "#", "data-dismiss" => "modal"} ×
         %h3.page-title Create New Directory
       .modal-body
-        = form_tag namespace_project_create_dir_path(@project.namespace, @project, @id), method: :post, remote: false, id: 'dir-create-form', class: 'form-horizontal' do
+        = form_tag namespace_project_create_dir_path(@project.namespace, @project, @id), method: :post, remote: false, class: 'form-horizontal js-create-dir-form' do
           .form-group
             = label_tag :dir_name, 'Directory Name', class: 'control-label'
             .col-sm-10
               = text_field_tag :dir_name, params[:dir_name], placeholder: "Directory name", required: true, class: 'form-control'
-          = render 'shared/commit_message_container', params: params, placeholder: ''
-          - unless @project.empty_repo?
-            .form-group
-              = label_tag :branch_name, 'Branch', class: 'control-label'
-              .col-sm-10
-                = text_field_tag 'new_branch', @ref, class: "form-control"
+
+          = render 'shared/new_commit_form', placeholder: "Add new directory"
+
           .form-group
             .col-sm-offset-2.col-sm-10
               = submit_tag "Create directory", class: 'btn btn-primary btn-create'
               = link_to "Cancel", '#', class: "btn btn-cancel", "data-dismiss" => "modal"
 
 :javascript
-  disableButtonIfAnyEmptyField($("#dir-create-form"), ".form-control", ".btn-create");
+  disableButtonIfAnyEmptyField($(".js-create-dir-form"), ".form-control", ".btn-create");
+  new NewCommitForm($('.js-create-dir-form'))

app/views/projects/blob/_remove.html.haml

@@ -3,16 +3,16 @@
     .modal-content
       .modal-header
         %a.close{href: "#", "data-dismiss" => "modal"} ×
-        %h3.page-title Remove #{@blob.name}
-        %p.light
-          From branch
-          %strong= @ref
+        %h3.page-title Delete #{@blob.name}
 
       .modal-body
-        = form_tag namespace_project_blob_path(@project.namespace, @project, @id), method: :delete, class: 'form-horizontal js-requires-input' do
-          = render 'shared/commit_message_container', params: params,
-                   placeholder: 'Removed this file because...'
+        = form_tag namespace_project_blob_path(@project.namespace, @project, @id), method: :delete, class: 'form-horizontal js-replace-blob-form js-requires-input' do
+          = render 'shared/new_commit_form', placeholder: "Delete #{@blob.name}"
+
           .form-group
             .col-sm-offset-2.col-sm-10
-              = button_tag 'Remove file', class: 'btn btn-remove btn-remove-file'
+              = button_tag 'Delete file', class: 'btn btn-remove btn-remove-file'
               = link_to "Cancel", '#', class: "btn btn-cancel", "data-dismiss" => "modal"
+
+:javascript
+  new NewCommitForm($('.js-replace-blob-form'))

app/views/projects/blob/_upload.html.haml

@@ -5,7 +5,7 @@
         %a.close{href: "#", "data-dismiss" => "modal"} ×
         %h3.page-title #{title}
       .modal-body
-        = form_tag form_path, method: method, class: 'blob-file-upload-form-js form-horizontal' do
+        = form_tag form_path, method: method, class: 'js-upload-blob-form form-horizontal' do
           .dropzone
             .dropzone-previews.blob-upload-dropzone-previews
               %p.dz-message.light
@@ -13,19 +13,15 @@
                 = link_to 'click to upload', '#', class: "markdown-selector"
           %br
           .dropzone-alerts{class: "alert alert-danger data", style: "display:none"}
-          = render 'shared/commit_message_container', params: params,
-            placeholder: placeholder
-          - unless @project.empty_repo?
-            .form-group.branch
-              = label_tag 'branch', class: 'control-label' do
-                Branch
-              .col-sm-10
-                = text_field_tag 'new_branch', @ref, class: "form-control"
+
+          = render 'shared/new_commit_form', placeholder: placeholder
+
           .form-group
             .col-sm-offset-2.col-sm-10
               = button_tag button_title, class: 'btn btn-small btn-primary btn-upload-file', id: 'submit-all'
               = link_to "Cancel", '#', class: "btn btn-cancel", "data-dismiss" => "modal"
 
 :javascript
-  disableButtonIfEmptyField($('.blob-file-upload-form-js').find('#commit_message'), '.btn-upload-file');
-  new BlobFileDropzone($('.blob-file-upload-form-js'), '#{method}');
+  disableButtonIfEmptyField($('.js-upload-blob-form').find('.js-commit-message'), '.btn-upload-file');
+  new BlobFileDropzone($('.js-upload-blob-form'), '#{method}');
+  new NewCommitForm($('.js-upload-blob-form'))

app/views/projects/blob/edit.html.haml

@@ -13,15 +13,9 @@
         %i.fa.fa-eye
         = editing_preview_title(@blob.name)
 
-  = form_tag(namespace_project_update_blob_path(@project.namespace, @project, @id), method: :put, class: 'form-horizontal js-requires-input') do
+  = form_tag(namespace_project_update_blob_path(@project.namespace, @project, @id), method: :put, class: 'form-horizontal js-requires-input js-edit-blob-form') do
     = render 'projects/blob/editor', ref: @ref, path: @path, blob_data: @blob.data
-    = render 'shared/commit_message_container', params: params, placeholder: "Update #{@blob.name}"
-
-    .form-group.branch
-      = label_tag 'branch', class: 'control-label' do
-        Branch
-      .col-sm-10
-        = text_field_tag 'new_branch', @ref, class: "form-control"
+    = render 'shared/new_commit_form', placeholder: "Update #{@blob.name}"
 
     = hidden_field_tag 'last_commit', @last_commit
     = hidden_field_tag 'content', '', id: "file-content"
@@ -30,3 +24,4 @@
 
 :javascript
   blob = new EditBlob(gon.relative_url_root + "#{Gitlab::Application.config.assets.prefix}", "#{@blob.language.try(:ace_mode)}")
+  new NewCommitForm($('.js-edit-blob-form'))

app/views/projects/blob/new.html.haml

@@ -2,20 +2,13 @@
 = render "header_title"
 
 .gray-content-block.top-block
-  Create a new file
+  %h3.page-title
+    Create New File
 
 .file-editor
-  = form_tag(namespace_project_create_blob_path(@project.namespace, @project, @id), method: :post, class: 'form-horizontal form-new-file js-requires-input') do
+  = form_tag(namespace_project_create_blob_path(@project.namespace, @project, @id), method: :post, class: 'form-horizontal js-new-blob-form js-requires-input') do
     = render 'projects/blob/editor', ref: @ref
-    = render 'shared/commit_message_container', params: params,
-             placeholder: 'Add new file'
-
-    - unless @project.empty_repo?
-      .form-group.branch
-        = label_tag 'branch', class: 'control-label' do
-          Branch
-        .col-sm-10
-          = text_field_tag 'new_branch', @ref, class: "form-control js-quick-submit"
+    = render 'shared/new_commit_form', placeholder: "Add new file"
 
     = hidden_field_tag 'content', '', id: 'file-content'
     = render 'projects/commit_button', ref: @ref,
@@ -23,3 +16,4 @@
 
 :javascript
   blob = new NewBlob(gon.relative_url_root + "#{Gitlab::Application.config.assets.prefix}", null)
+  new NewCommitForm($('.js-new-blob-form'))

app/views/projects/blob/show.html.haml

@@ -10,6 +10,4 @@
   = render 'projects/blob/remove'
 
   - title = "Replace #{@blob.name}"
-  = render 'projects/blob/upload', title: title, placeholder: title,
-    button_title: 'Replace file', form_path: namespace_project_update_blob_path(@project.namespace, @project, @id),
-    method: :put
+  = render 'projects/blob/upload', title: title, placeholder: title, button_title: 'Replace file', form_path: namespace_project_update_blob_path(@project.namespace, @project, @id), method: :put

app/views/projects/issues/_discussion.html.haml

@@ -7,7 +7,7 @@
 
 = render 'shared/show_aside'
 
-.gray-content-block.second-block
+.gray-content-block.second-block.oneline-block
   .row
     .col-md-9
       .votes-holder.pull-right

app/views/projects/issues/_issue.html.haml

@@ -29,8 +29,6 @@
 
   .issue-info
     = "#{issue.to_reference} opened #{time_ago_with_tooltip(issue.created_at, placement: 'bottom')} by #{link_to_member(@project, issue.author, avatar: false)}".html_safe
-    - if issue.votes_count > 0
-      = render 'votes/votes_inline', votable: issue
     - if issue.milestone
        
       %span

app/views/projects/merge_requests/_discussion.html.haml

@@ -14,8 +14,10 @@
         #votes= render 'votes/votes_block', votable: @merge_request
       = render "projects/merge_requests/show/participants"
     .col-md-3
-      %span.slead.has_tooltip{:"data-original-title" => 'Cross-project reference'}
-        = cross_project_reference(@project, @merge_request)
+      .input-group.cross-project-reference
+        %span.slead.has_tooltip{title: 'Cross-project reference'}
+          = cross_project_reference(@project, @merge_request)
+        = clipboard_button
 
 .row
   %section.col-md-9

app/views/projects/merge_requests/_merge_request.html.haml

@@ -34,8 +34,6 @@
 
   .merge-request-info
     = "##{merge_request.iid} opened #{time_ago_with_tooltip(merge_request.created_at, placement: 'bottom')} by #{link_to_member(@project, merge_request.author, avatar: false)}".html_safe
-    - if merge_request.votes_count > 0
-      = render 'votes/votes_inline', votable: merge_request
     - if merge_request.milestone_id?
        
       %span

app/views/projects/notes/_note.html.haml

@@ -35,26 +35,6 @@
               - if note.updated_by && note.updated_by != note.author
                 by #{link_to_member(note.project, note.updated_by, avatar: false, author_class: nil)}
 
-        - if note.superceded?(@notes)
-          - if note.upvote?
-            %span.vote.upvote.label.label-gray.strikethrough
-              = icon('thumbs-up')
-              \+1
-          - if note.downvote?
-            %span.vote.downvote.label.label-gray.strikethrough
-              = icon('thumbs-down')
-              \-1
-        - else
-          - if note.upvote?
-            %span.vote.upvote.label.label-success
-              = icon('thumbs-up')
-              \+1
-          - if note.downvote?
-            %span.vote.downvote.label.label-danger
-              = icon('thumbs-down')
-              \-1
-
-
       .note-body{class: note_editable?(note) ? 'js-task-list-container' : ''}
         .note-text
           = preserve do

app/views/projects/releases/edit.html.haml

@@ -11,10 +11,9 @@
 .prepend-top-default
   = form_for(@release, method: :put, url: namespace_project_tag_release_path(@project.namespace, @project, @tag.name), html: { class: 'form-horizontal gfm-form release-form' }) do |f|
     = render layout: 'projects/md_preview', locals: { preview_class: "md-preview", referenced_users: true } do
-      = render 'projects/zen', f: f, attr: :description, classes: 'description js-quick-submit'
+      = render 'projects/zen', f: f, attr: :description, classes: 'description js-quick-submit form-control'
       = render 'projects/notes/hints'
       .error-alert
       .prepend-top-default
         = f.submit 'Save changes', class: 'btn btn-save'
         = link_to "Cancel", namespace_project_tag_path(@project.namespace, @project, @tag.name), class: "btn btn-default btn-cancel"
-

app/views/projects/show.atom.builder

@@ -4,7 +4,7 @@ xml.feed "xmlns" => "http://www.w3.org/2005/Atom", "xmlns:media" => "http://sear
   xml.link    href: namespace_project_url(@project.namespace, @project, format: :atom, private_token: current_user.try(:private_token)), rel: "self", type: "application/atom+xml"
   xml.link    href: namespace_project_url(@project.namespace, @project), rel: "alternate", type: "text/html"
   xml.id      namespace_project_url(@project.namespace, @project)
-  xml.updated @events.maximum(:updated_at).strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
+  xml.updated @events.latest_update_time.strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
 
   @events.each do |event|
     event_to_atom(xml, event)

app/views/projects/tags/new.html.haml

@@ -10,7 +10,7 @@
   New git tag
 %hr
 
-= form_tag namespace_project_tags_path, method: :post, id: "new-tag-form", class: "form-horizontal tag-form" do
+= form_tag namespace_project_tags_path, method: :post, id: "new-tag-form", class: "form-horizontal gfm-form tag-form" do
   .form-group
     = label_tag :tag_name, 'Name for new tag', class: 'control-label'
     .col-sm-10
@@ -30,16 +30,7 @@
     = label_tag :release_description, 'Release notes', class: 'control-label'
     .col-sm-10
       = render layout: 'projects/md_preview', locals: { preview_class: "md-preview", referenced_users: true } do
-        .zennable
-          %input#zen-toggle-comment.zen-toggle-comment(tabindex="-1" type="checkbox")
-          .zen-backdrop
-            = text_area_tag :release_description, nil, class: 'js-gfm-input markdown-area description js-quick-submit form-control', placeholder: ''
-            %a.zen-enter-link(tabindex="-1" href="#")
-              = icon('expand')
-              Edit in fullscreen
-            %a.zen-leave-link(href="#")
-              = icon('compress')
-
+        = render 'projects/zen', attr: :release_description, classes: 'description js-quick-submit form-control'
         = render 'projects/notes/hints'
         .help-block (Optional) You can add release notes to your tag. It will be stored in the GitLab database and shown on the tags page
   .form-actions

app/views/projects/tree/_tree_content.html.haml

@@ -30,7 +30,7 @@
     = render "projects/tree/readme", readme: tree.readme
 
 - if allowed_tree_edit?
-  = render 'projects/blob/upload', title: 'Upload', placeholder: 'Upload new file', button_title: 'Upload file', form_path: namespace_project_create_blob_path(@project.namespace, @project, @id), method: :post
+  = render 'projects/blob/upload', title: 'Upload New File', placeholder: 'Upload new file', button_title: 'Upload file', form_path: namespace_project_create_blob_path(@project.namespace, @project, @id), method: :post
   = render 'projects/blob/new_dir'
 
 :javascript

app/views/shared/_commit_message_container.html.haml

 .form-group.commit_message-group
-  = label_tag 'commit_message', class: 'control-label' do
+  - nonce = SecureRandom.hex
+  = label_tag "commit_message-#{nonce}", class: 'control-label' do
     Commit message
   .col-sm-10
     .commit-message-container
       .max-width-marker
       = text_area_tag 'commit_message',
           (params[:commit_message] || local_assigns[:text]),
-          class: 'form-control js-quick-submit', placeholder: local_assigns[:placeholder],
-          required: true, rows: (local_assigns[:rows] || 3)
+          class: 'form-control js-commit-message js-quick-submit', placeholder: local_assigns[:placeholder],
+          required: true, rows: (local_assigns[:rows] || 3),
+          id: "commit_message-#{nonce}"
     - if local_assigns[:hint]
       %p.hint
         Try to keep the first line under 52 characters

app/views/shared/_new_commit_form.html.haml

+= render 'shared/commit_message_container', placeholder: placeholder
+
+- unless @project.empty_repo?
+  .form-group.branch
+    = label_tag 'branch', class: 'control-label' do
+      Branch
+    .col-sm-10
+      = text_field_tag 'new_branch', @new_branch || @ref, class: "form-control js-new-branch"
+
+  .form-group.js-create-merge-request-form-group
+    .col-sm-offset-2.col-sm-10
+      .checkbox
+        - nonce = SecureRandom.hex
+        = label_tag "create_merge_request-#{nonce}" do
+          = check_box_tag 'create_merge_request', 1, true, class: 'js-create-merge-request', id: "create_merge_request-#{nonce}"
+          Start a <strong>new merge request</strong> with this commit
+
+  = hidden_field_tag 'original_branch', @ref, class: 'js-original-branch'

app/views/users/show.atom.builder

@@ -4,7 +4,7 @@ xml.feed "xmlns" => "http://www.w3.org/2005/Atom", "xmlns:media" => "http://sear
   xml.link    href: user_url(@user, :atom), rel: "self", type: "application/atom+xml"
   xml.link    href: user_url(@user), rel: "alternate", type: "text/html"
   xml.id      user_url(@user)
-  xml.updated @events.maximum(:updated_at).strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
+  xml.updated @events.latest_update_time.strftime("%Y-%m-%dT%H:%M:%SZ") if @events.any?
 
   @events.each do |event|
     event_to_atom(xml, event)

app/views/votes/_votes_block.html.haml

-.votes.votes-block
-  .btn-group
-    - unless votable.upvotes.zero?
-      .btn.btn-sm.disabled.cgreen
-        %i.fa.fa-thumbs-up
-        = votable.upvotes
-    - unless votable.downvotes.zero?
-      .btn.btn-sm.disabled.cred
-        %i.fa.fa-thumbs-down
-        = votable.downvotes
+.awards.votes-block
+  - votable.notes.awards.grouped_awards.each do |emoji, notes|
+    .award{class: (note_active_class(notes, current_user)), title: emoji_author_list(notes, current_user)}
+      .icon{"data-emoji" => "#{emoji}"}
+        = image_tag url_to_emoji(emoji), height: "20px", width: "20px"
+      .counter
+        = notes.count
+
+  - if current_user
+    .dropdown.awards-controls
+      %a.add-award{"data-toggle" => "dropdown", "data-target" => "#", "href" => "#"}
+        = icon('smile-o')
+      %ul.dropdown-menu.awards-menu
+        - emoji_list.each do |emoji|
+          %li{"data-emoji" => "#{emoji}"}= image_tag url_to_emoji(emoji), height: "20px", width: "20px"
+
+- if current_user
+  :coffeescript
+    post_emoji_url = "#{award_toggle_namespace_project_notes_path(@project.namespace, @project)}"
+    noteable_type = "#{votable.class.name.underscore}"
+    noteable_id = "#{votable.id}"
+    window.awards_handler = new AwardsHandler(post_emoji_url, noteable_type, noteable_id)
+
+    $(".awards-menu li").click (e)->
+      emoji = $(this).data("emoji")
+      awards_handler.addAward(emoji)
+
+    $(".awards").on "click", ".award", (e)->
+      emoji = $(this).find(".icon").data("emoji")
+      awards_handler.addAward(emoji)
+
+    $(".award").tooltip()

app/views/votes/_votes_inline.html.haml

-.votes.votes-inline
-  - unless votable.upvotes.zero?
-    %span.upvotes.cgreen
-      + #{votable.upvotes}
-    - unless votable.downvotes.zero?
-      \/
-  - unless votable.downvotes.zero?
-    %span.downvotes.cred
-      \- #{votable.downvotes}

config/gitlab.yml.example

@@ -126,7 +126,7 @@ production: &base
 
   ## Git LFS
   lfs:
-    enabled: false
+    enabled: true
     # The location where LFS objects are stored (default: shared/lfs-objects).
     # storage_path: shared/lfs-objects
 

config/initializers/1_settings.rb

@@ -231,7 +231,7 @@ Settings.incoming_email['mailbox']    = "inbox" if Settings.incoming_email['mail
 # Git LFS
 #
 Settings['lfs'] ||= Settingslogic.new({})
-Settings.lfs['enabled']      = false if Settings.lfs['enabled'].nil?
+Settings.lfs['enabled']      = true if Settings.lfs['enabled'].nil?
 Settings.lfs['storage_path'] = File.expand_path(Settings.lfs['storage_path'] || File.join(Settings.shared['path'], "lfs-objects"), Rails.root)
 
 #

config/routes.rb

@@ -716,6 +716,10 @@ Gitlab::Application.routes.draw do
           member do
             delete :delete_attachment
           end
+
+          collection do
+            post :award_toggle
+          end
         end
 
         resources :uploads, only: [:create] do

db/migrate/20151106000015_add_is_award_to_notes.rb

+class AddIsAwardToNotes < ActiveRecord::Migration
+  def change
+    add_column :notes, :is_award, :boolean, default: false, null: false
+    add_index :notes, :is_award
+  end
+end

db/migrate/20151118162244_add_projects_public_index.rb

+class AddProjectsPublicIndex < ActiveRecord::Migration
+  def change
+    add_index :namespaces, :public
+  end
+end

db/schema.rb

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20151116144118) do
+ActiveRecord::Schema.define(version: 20151118162244) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -607,6 +607,7 @@ ActiveRecord::Schema.define(version: 20151116144118) do
   add_index "namespaces", ["name"], name: "index_namespaces_on_name", unique: true, using: :btree
   add_index "namespaces", ["owner_id"], name: "index_namespaces_on_owner_id", using: :btree
   add_index "namespaces", ["path"], name: "index_namespaces_on_path", unique: true, using: :btree
+  add_index "namespaces", ["public"], name: "index_namespaces_on_public", using: :btree
   add_index "namespaces", ["type"], name: "index_namespaces_on_type", using: :btree
 
   create_table "notes", force: true do |t|
@@ -623,12 +624,14 @@ ActiveRecord::Schema.define(version: 20151116144118) do
     t.boolean  "system",        default: false, null: false
     t.text     "st_diff"
     t.integer  "updated_by_id"
+    t.boolean  "is_award",      default: false, null: false
   end
 
   add_index "notes", ["author_id"], name: "index_notes_on_author_id", using: :btree
   add_index "notes", ["commit_id"], name: "index_notes_on_commit_id", using: :btree
   add_index "notes", ["created_at", "id"], name: "index_notes_on_created_at_and_id", using: :btree
   add_index "notes", ["created_at"], name: "index_notes_on_created_at", using: :btree
+  add_index "notes", ["is_award"], name: "index_notes_on_is_award", using: :btree
   add_index "notes", ["line_code"], name: "index_notes_on_line_code", using: :btree
   add_index "notes", ["noteable_id", "noteable_type"], name: "index_notes_on_noteable_id_and_noteable_type", using: :btree
   add_index "notes", ["noteable_type"], name: "index_notes_on_noteable_type", using: :btree

doc/api/merge_requests.md

@@ -31,8 +31,6 @@ Parameters:
     "project_id": 3,
     "title": "test1",
     "state": "opened",
-    "upvotes": 0,
-    "downvotes": 0,
     "author": {
       "id": 1,
       "username": "admin",
@@ -77,8 +75,6 @@ Parameters:
   "project_id": 3,
   "title": "test1",
   "state": "merged",
-  "upvotes": 0,
-  "downvotes": 0,
   "author": {
     "id": 1,
     "username": "admin",
@@ -126,8 +122,6 @@ Parameters:
   "updated_at": "2015-02-02T20:08:49.959Z",
   "target_branch": "secret_token",
   "source_branch": "version-1-9",
-  "upvotes": 0,
-  "downvotes": 0,
   "author": {
     "name": "Chad Hamill",
     "username": "jarrett",
@@ -198,8 +192,6 @@ Parameters:
   "project_id": 3,
   "title": "test1",
   "state": "opened",
-  "upvotes": 0,
-  "downvotes": 0,
   "author": {
     "id": 1,
     "username": "admin",
@@ -250,8 +242,6 @@ Parameters:
   "title": "test1",
   "description": "description1",
   "state": "opened",
-  "upvotes": 0,
-  "downvotes": 0,
   "author": {
     "id": 1,
     "username": "admin",
@@ -304,8 +294,6 @@ Parameters:
   "project_id": 3,
   "title": "test1",
   "state": "merged",
-  "upvotes": 0,
-  "downvotes": 0,
   "author": {
     "id": 1,
     "username": "admin",

doc/api/notes.md

@@ -32,9 +32,7 @@ Parameters:
       "created_at": "2013-09-30T13:46:01Z"
     },
     "created_at": "2013-10-02T09:22:45Z",
-    "system": true,
-    "upvote": false,
-    "downvote": false
+    "system": true
   },
   {
     "id": 305,
@@ -49,9 +47,7 @@ Parameters:
       "created_at": "2013-09-30T13:46:01Z"
     },
     "created_at": "2013-10-02T09:56:03Z",
-    "system": false,
-    "upvote": false,
-    "downvote": false
+    "system": false
   }
 ]
 ```

doc/raketasks/backup_restore.md

@@ -29,7 +29,7 @@ sudo -u git -H bundle exec rake gitlab:backup:create RAILS_ENV=production
 ```
 
 Also you can choose what should be backed up by adding environment variable SKIP. Available options: db,
-uploads (attachments), repositories, builds(CI build output logs), artifacts (CI build artifacts).
+uploads (attachments), repositories, builds(CI build output logs), artifacts (CI build artifacts), lfs (LFS objects).
 Use a comma to specify several options at the same time.
 
 ```

doc/workflow/git_lfs.md

@@ -55,7 +55,7 @@ In `config/gitlab.yml`:
 * When SSH is set as a remote, Git LFS objects still go through HTTPS
 * Any Git LFS request will ask for HTTPS credentials to be provided so good Git credentials store is recommended
 * Currently, storing GitLab Git LFS objects on a non-local storage (like S3 buckets) is not supported
-* Git LFS always assumes HTTPS so if you have GitLab server on HTTP you will have to add the url to Git config manually (see #troubleshooting-tips)
+* Git LFS always assumes HTTPS so if you have GitLab server on HTTP you will have to add the URL to Git config manually (see #troubleshooting-tips)
 
 ## Using Git LFS
 
@@ -77,11 +77,10 @@ git commit -am "Added Debian iso"     # commit the file meta data
 git push origin master                # sync the git repo and large file to the GitLab server
 ```
 
-Downloading a single large file is also very simple:
+Cloning the repository works the same as before. Git automatically detects the LFS-tracked files and clones them via HTTP. If you performed the git clone command with a SSH URL, you have to enter your GitLab credentials for HTTP authentication.
 
 ```bash
 git clone git@gitlab.example.com:group/project.git
-git lfs fetch debian.iso              # download the large file
 ```
 
 

features/project/issues/award_emoji.feature

+Feature: Award Emoji
+  Background:
+    Given I sign in as a user
+    And I own project "Shop"
+    And project "Shop" has issue "Bugfix"
+    And I visit "Bugfix" issue page
+
+  @javascript
+  Scenario: I add and remove award in the issue
+    Given I click to emoji-picker
+    And I click to emoji in the picker
+    Then I have award added
+    And I can remove it by clicking to icon
+    
\ No newline at end of file

features/project/source/browse_files.feature

@@ -42,7 +42,7 @@ Feature: Project Source Browse Files
     And I fill the new branch name
     And I click on "Upload file"
     Then I can see the new text file
-    And I am redirected to the uploaded file on new branch
+    And I am redirected to the new merge request page
     And I can see the new commit message
 
   @javascript
@@ -64,7 +64,7 @@ Feature: Project Source Browse Files
     And I fill the commit message
     And I fill the new branch name
     And I click on "Commit Changes"
-    Then I am redirected to the new file on new branch
+    Then I am redirected to the new merge request page
     And I should see its new content
 
   @javascript
@@ -134,7 +134,7 @@ Feature: Project Source Browse Files
     And I fill the commit message
     And I fill the new branch name
     And I click on "Commit Changes"
-    Then I am redirected to the ".gitignore" on new branch
+    Then I am redirected to the new merge request page
     And I should see its new content
 
   @javascript  @wip
@@ -154,7 +154,7 @@ Feature: Project Source Browse Files
     And I fill the commit message
     And I fill the new branch name
     And I click on "Create directory"
-    Then I am redirected to the new directory
+    Then I am redirected to the new merge request page
 
   @javascript
   Scenario: I attempt to create an existing directory
@@ -174,12 +174,12 @@ Feature: Project Source Browse Files
     Then I see diff
 
   @javascript
-  Scenario: I can remove file and commit
+  Scenario: I can delete file and commit
     Given I click on ".gitignore" file in repo
     And I see the ".gitignore"
-    And I click on "Remove"
+    And I click on "Delete"
     And I fill the commit message
-    And I click on "Remove file"
+    And I click on "Delete file"
     Then I am redirected to the files URL
     And I don't see the ".gitignore"
 

features/steps/project/issues/award_emoji.rb

+class Spinach::Features::AwardEmoji < Spinach::FeatureSteps
+  include SharedAuthentication
+  include SharedProject
+  include SharedPaths
+  include Select2Helper
+
+  step 'I visit "Bugfix" issue page' do
+    visit namespace_project_issue_path(@project.namespace, @project, @issue)
+  end
+
+  step 'I click to emoji-picker' do
+    page.within ".awards-controls" do
+      page.find(".add-award").click
+    end
+  end
+
+  step 'I click to emoji in the picker' do
+    page.within ".awards-menu" do
+      page.first("img").click
+    end
+  end
+
+  step 'I can remove it by clicking to icon' do
+    page.within ".awards" do
+      page.first(".award").click
+      expect(page).to_not have_selector ".award"
+    end
+  end
+
+  step 'I have award added' do
+    page.within ".awards" do
+      expect(page).to have_selector ".award"
+      expect(page.find(".award .counter")).to have_content "1"
+    end
+  end
+
+  step 'project "Shop" has issue "Bugfix"' do
+    @project = Project.find_by(name: "Shop")
+    @issue = create(:issue, title: "Bugfix", project: project)
+  end
+end

features/steps/project/source/browse_files.rb

@@ -98,12 +98,12 @@ class Spinach::Features::ProjectSourceBrowseFiles < Spinach::FeatureSteps
     click_button 'Create directory'
   end
 
-  step 'I click on "Remove"' do
-    click_button 'Remove'
+  step 'I click on "Delete"' do
+    click_button 'Delete'
   end
 
-  step 'I click on "Remove file"' do
-    click_button 'Remove file'
+  step 'I click on "Delete file"' do
+    click_button 'Delete file'
   end
 
   step 'I click on "Replace"' do
@@ -142,7 +142,7 @@ class Spinach::Features::ProjectSourceBrowseFiles < Spinach::FeatureSteps
   end
 
   step 'I can see new file page' do
-    expect(page).to have_content "new file"
+    expect(page).to have_content "Create New File"
     expect(page).to have_content "Commit message"
   end
 
@@ -225,10 +225,6 @@ class Spinach::Features::ProjectSourceBrowseFiles < Spinach::FeatureSteps
     expect(current_path).to eq(namespace_project_blob_path(@project.namespace, @project, 'master/.gitignore'))
   end
 
-  step 'I am redirected to the ".gitignore" on new branch' do
-    expect(current_path).to eq(namespace_project_blob_path(@project.namespace, @project, 'new_branch_name/.gitignore'))
-  end
-
   step 'I am redirected to the permalink URL' do
     expect(current_path).to(
       eq(namespace_project_blob_path(@project.namespace, @project,
@@ -247,20 +243,8 @@ class Spinach::Features::ProjectSourceBrowseFiles < Spinach::FeatureSteps
       @project.namespace, @project, 'master/' + new_file_name_with_directory))
   end
 
-  step 'I am redirected to the new file on new branch' do
-    expect(current_path).to eq(namespace_project_blob_path(
-      @project.namespace, @project, 'new_branch_name/' + new_file_name))
-  end
-
-  step 'I am redirected to the uploaded file on new branch' do
-    expect(current_path).to eq(namespace_project_blob_path(
-      @project.namespace, @project,
-      'new_branch_name/' + File.basename(test_text_file)))
-  end
-
-  step 'I am redirected to the new directory' do
-    expect(current_path).to eq(namespace_project_tree_path(
-      @project.namespace, @project, 'new_branch_name/' + new_dir_name))
+  step 'I am redirected to the new merge request page' do
+    expect(current_path).to eq(new_namespace_project_merge_request_path(@project.namespace, @project))
   end
 
   step 'I am redirected to the root directory' do

lib/api/entities.rb

@@ -172,7 +172,7 @@ module API
     end
 
     class MergeRequest < ProjectEntity
-      expose :target_branch, :source_branch, :upvotes, :downvotes
+      expose :target_branch, :source_branch
       expose :author, :assignee, using: Entities::UserBasic
       expose :source_project_id, :target_project_id
       expose :label_names, as: :labels
@@ -202,8 +202,6 @@ module API
       expose :author, using: Entities::UserBasic
       expose :created_at
       expose :system?, as: :system
-      expose :upvote?, as: :upvote
-      expose :downvote?, as: :downvote
     end
 
     class MRNote < Grape::Entity

lib/award_emoji.rb

+class AwardEmoji
+  EMOJI_LIST = [
+    "+1", "-1", "100", "blush", "heart", "smile", "rage",
+    "beers", "disappointed", "ok_hand",
+    "helicopter", "shit", "airplane", "alarm_clock",
+    "ambulance", "anguished", "two_hearts", "wink"
+  ]
+
+  def self.path_to_emoji_image(name)
+    "emoji/#{Emoji.emoji_filename(name)}.png"
+  end
+end

lib/backup/lfs.rb

+require 'backup/files'
+
+module Backup
+  class Lfs < Files
+    def initialize
+      super('lfs', Settings.lfs.storage_path)
+    end
+
+    def create_files_dir
+      Dir.mkdir(app_files_dir, 0700)
+    end
+  end
+end

lib/backup/manager.rb

@@ -154,7 +154,7 @@ module Backup
     end
 
     def archives_to_backup
-      %w{uploads builds artifacts}.map{ |name| (name + ".tar.gz") unless skipped?(name) }.compact
+      %w{uploads builds artifacts lfs}.map{ |name| (name + ".tar.gz") unless skipped?(name) }.compact
     end
 
     def folders_to_backup

lib/gitlab/lfs/response.rb

@@ -10,23 +10,9 @@ module Gitlab
         @request = request
       end
 
-      # Return a response for a download request
-      # Can be a response to:
-      # Request from a user to get the file
-      # Request from gitlab-workhorse which file to serve to the user
-      def render_download_hypermedia_response(oid)
-        render_response_to_download do
-          if check_download_accept_header?
-            render_lfs_download_hypermedia(oid)
-          else
-            render_not_found
-          end
-        end
-      end
-
       def render_download_object_response(oid)
         render_response_to_download do
-          if check_download_sendfile_header? && check_download_accept_header?
+          if check_download_sendfile_header?
             render_lfs_sendfile(oid)
           else
             render_not_found
@@ -34,20 +20,15 @@ module Gitlab
         end
       end
 
-      def render_lfs_api_auth
-        render_response_to_push do
-          request_body = JSON.parse(@request.body.read)
-          return render_not_found if request_body.empty? || request_body['objects'].empty?
-
-          response = build_response(request_body['objects'])
-          [
-            200,
-            {
-              "Content-Type" => "application/json; charset=utf-8",
-              "Cache-Control" => "private",
-            },
-            [JSON.dump(response)]
-          ]
+      def render_batch_operation_response
+        request_body = JSON.parse(@request.body.read)
+        case request_body["operation"]
+        when "download"
+          render_batch_download(request_body)
+        when "upload"
+          render_batch_upload(request_body)
+        else
+          render_not_found
         end
       end
 
@@ -71,13 +52,24 @@ module Gitlab
         end
       end
 
+      def render_unsupported_deprecated_api
+        [
+          501,
+          { "Content-Type" => "application/json; charset=utf-8" },
+          [JSON.dump({
+            'message' => 'Server supports batch API only, please update your Git LFS client to version 0.6.0 and up.',
+            'documentation_url' => "#{Gitlab.config.gitlab.url}/help",
+          })]
+        ]
+      end
+
       private
 
       def render_not_enabled
         [
           501,
           {
-            "Content-Type" => "application/vnd.git-lfs+json",
+            "Content-Type" => "application/json; charset=utf-8",
           },
           [JSON.dump({
             'message' => 'Git LFS is not enabled on this GitLab server, contact your admin.',
@@ -142,18 +134,35 @@ module Gitlab
         end
       end
 
-      def render_lfs_download_hypermedia(oid)
-        return render_not_found unless oid.present?
+      def render_batch_upload(body)
+        return render_not_found if body.empty? || body['objects'].nil?
 
-        lfs_object = object_for_download(oid)
-        if lfs_object
+        render_response_to_push do
+          response = build_upload_batch_response(body['objects'])
           [
             200,
-            { "Content-Type" => "application/vnd.git-lfs+json" },
-            [JSON.dump(download_hypermedia(oid))]
+            {
+              "Content-Type" => "application/json; charset=utf-8",
+              "Cache-Control" => "private",
+            },
+            [JSON.dump(response)]
+          ]
+        end
+      end
+
+      def render_batch_download(body)
+        return render_not_found if body.empty? || body['objects'].nil?
+
+        render_response_to_download do
+          response = build_download_batch_response(body['objects'])
+          [
+            200,
+            {
+              "Content-Type" => "application/json; charset=utf-8",
+              "Cache-Control" => "private",
+            },
+            [JSON.dump(response)]
           ]
-        else
-          render_not_found
         end
       end
 
@@ -199,10 +208,6 @@ module Gitlab
         @env['HTTP_X_SENDFILE_TYPE'].to_s == "X-Sendfile"
       end
 
-      def check_download_accept_header?
-        @env['HTTP_ACCEPT'].to_s == "application/vnd.git-lfs+json; charset=utf-8"
-      end
-
       def user_can_fetch?
         # Check user access against the project they used to initiate the pull
         @user.can?(:download_code, @origin_project)
@@ -266,42 +271,56 @@ module Gitlab
         @project.lfs_objects.where(oid: objects_oids).pluck(:oid).to_set
       end
 
-      def build_response(objects)
+      def build_upload_batch_response(objects)
         selected_objects = select_existing_objects(objects)
 
-        upload_hypermedia(objects, selected_objects)
+        upload_hypermedia_links(objects, selected_objects)
       end
 
-      def download_hypermedia(oid)
-        {
-         '_links' => {
-           'download' =>
-             {
-              'href' => "#{@origin_project.http_url_to_repo}/gitlab-lfs/objects/#{oid}",
-              'header' => {
-                'Accept' => "application/vnd.git-lfs+json; charset=utf-8",
-                'Authorization' => @env['HTTP_AUTHORIZATION']
-              }.compact
-            }
-          }
-        }
+      def build_download_batch_response(objects)
+        selected_objects = select_existing_objects(objects)
+
+        download_hypermedia_links(objects, selected_objects)
       end
 
-      def upload_hypermedia(all_objects, existing_objects)
+      def download_hypermedia_links(all_objects, existing_objects)
         all_objects.each do |object|
-          object['_links'] = hypermedia_links(object) unless existing_objects.include?(object['oid'])
+          if existing_objects.include?(object['oid'])
+            object['actions'] = {
+              'download' => {
+                'href' => "#{@origin_project.http_url_to_repo}/gitlab-lfs/objects/#{object['oid']}",
+                'header' => {
+                  'Authorization' => @env['HTTP_AUTHORIZATION']
+                }.compact
+              }
+            }
+          else
+            object['error'] = {
+              'code' => 404,
+              'message' => "Object does not exist on the server or you don't have permissions to access it",
+            }
+          end
         end
 
         { 'objects' => all_objects }
       end
 
-      def hypermedia_links(object)
-        {
-          "upload" => {
-            'href' => "#{@origin_project.http_url_to_repo}/gitlab-lfs/objects/#{object['oid']}/#{object['size']}",
-            'header' => { 'Authorization' => @env['HTTP_AUTHORIZATION'] }
-          }.compact
-        }
+      def upload_hypermedia_links(all_objects, existing_objects)
+        all_objects.each do |object|
+          # generate actions only for non-existing objects
+          next if existing_objects.include?(object['oid'])
+
+          object['actions'] = {
+            'upload' => {
+              'href' => "#{@origin_project.http_url_to_repo}/gitlab-lfs/objects/#{object['oid']}/#{object['size']}",
+              'header' => {
+                'Authorization' => @env['HTTP_AUTHORIZATION']
+              }.compact
+            }
+          }
+        end
+
+        { 'objects' => all_objects }
       end
     end
   end

lib/gitlab/lfs/router.rb

@@ -34,7 +34,7 @@ module Gitlab
 
         case path_match[1]
         when "info/lfs"
-          lfs.render_download_hypermedia_response(oid)
+          lfs.render_unsupported_deprecated_api
         when "gitlab-lfs"
           lfs.render_download_object_response(oid)
         else
@@ -48,7 +48,9 @@ module Gitlab
 
         # Check for Batch API
         if post_path[0].ends_with?("/info/lfs/objects/batch")
-          lfs.render_lfs_api_auth
+          lfs.render_batch_operation_response
+        elsif post_path[0].ends_with?("/info/lfs/objects")
+          lfs.render_unsupported_deprecated_api
         else
           nil
         end

lib/gitlab/sql/union.rb

+module Gitlab
+  module SQL
+    # Class for building SQL UNION statements.
+    #
+    # ORDER BYs are dropped from the relations as the final sort order is not
+    # guaranteed any way.
+    #
+    # Example usage:
+    #
+    #     union = Gitlab::SQL::Union.new(user.personal_projects, user.projects)
+    #     sql   = union.to_sql
+    #
+    #     Project.where("id IN (#{sql})")
+    class Union
+      def initialize(relations)
+        @relations = relations
+      end
+
+      def to_sql
+        # Some relations may include placeholders for prepared statements, these
+        # aren't incremented properly when joining relations together this way.
+        # By using "unprepared_statements" we remove the usage of placeholders
+        # (thus fixing this problem), at a slight performance cost.
+        fragments = ActiveRecord::Base.connection.unprepared_statement do
+          @relations.map do |rel|
+            rel.reorder(nil).to_sql
+          end
+        end
+
+        fragments.join("\nUNION\n")
+      end
+    end
+  end
+end

lib/tasks/gitlab/backup.rake

@@ -13,6 +13,7 @@ namespace :gitlab do
       Rake::Task["gitlab:backup:uploads:create"].invoke
       Rake::Task["gitlab:backup:builds:create"].invoke
       Rake::Task["gitlab:backup:artifacts:create"].invoke
+      Rake::Task["gitlab:backup:lfs:create"].invoke
 
       backup = Backup::Manager.new
       backup.pack
@@ -34,6 +35,7 @@ namespace :gitlab do
       Rake::Task["gitlab:backup:uploads:restore"].invoke unless backup.skipped?("uploads")
       Rake::Task["gitlab:backup:builds:restore"].invoke unless backup.skipped?("builds")
       Rake::Task["gitlab:backup:artifacts:restore"].invoke unless backup.skipped?("artifacts")
+      Rake::Task["gitlab:backup:lfs:restore"].invoke unless backup.skipped?("lfs")
       Rake::Task["gitlab:shell:setup"].invoke
 
       backup.cleanup
@@ -134,6 +136,25 @@ namespace :gitlab do
       end
     end
 
+    namespace :lfs do
+      task create: :environment do
+        $progress.puts "Dumping lfs objects ... ".blue
+
+        if ENV["SKIP"] && ENV["SKIP"].include?("lfs")
+          $progress.puts "[SKIPPED]".cyan
+        else
+          Backup::Lfs.new.dump
+          $progress.puts "done".green
+        end
+      end
+
+      task restore: :environment do
+        $progress.puts "Restoring lfs objects ... ".blue
+        Backup::Lfs.new.restore
+        $progress.puts "done".green
+      end
+    end
+
     def configure_cron_mode
       if ENV['CRON']
         # We need an object we can say 'puts' and 'print' to; let's use a

spec/controllers/snippets_controller_spec.rb

+require 'spec_helper'
+
+describe SnippetsController do
+  describe 'GET #show' do
+    let(:user) { create(:user) }
+
+    context 'when the personal snippet is private' do
+      let(:personal_snippet) { create(:personal_snippet, :private, author: user) }
+
+      context 'when signed in' do
+        before do
+          sign_in(user)
+        end
+
+        context 'when signed in user is not the author' do
+          let(:other_author) { create(:author) }
+          let(:other_personal_snippet) { create(:personal_snippet, :private, author: other_author) }
+
+          it 'responds with status 404' do
+            get :show, id: other_personal_snippet.to_param
+
+            expect(response.status).to eq(404)
+          end
+        end
+
+        context 'when signed in user is the author' do
+          it 'renders the snippet' do
+            get :show, id: personal_snippet.to_param
+
+            expect(assigns(:snippet)).to eq(personal_snippet)
+            expect(response.status).to eq(200)
+          end
+        end
+      end
+
+      context 'when not signed in' do
+        it 'redirects to the sign in page' do
+          get :show, id: personal_snippet.to_param
+
+          expect(response).to redirect_to(new_user_session_path)
+        end
+      end
+    end
+
+    context 'when the personal snippet is internal' do
+      let(:personal_snippet) { create(:personal_snippet, :internal, author: user) }
+
+      context 'when signed in' do
+        before do
+          sign_in(user)
+        end
+
+        it 'renders the snippet' do
+          get :show, id: personal_snippet.to_param
+
+          expect(assigns(:snippet)).to eq(personal_snippet)
+          expect(response.status).to eq(200)
+        end
+      end
+
+      context 'when not signed in' do
+        it 'redirects to the sign in page' do
+          get :show, id: personal_snippet.to_param
+
+          expect(response).to redirect_to(new_user_session_path)
+        end
+      end
+    end
+
+    context 'when the personal snippet is public' do
+      let(:personal_snippet) { create(:personal_snippet, :public, author: user) }
+
+      context 'when signed in' do
+        before do
+          sign_in(user)
+        end
+
+        it 'renders the snippet' do
+          get :show, id: personal_snippet.to_param
+
+          expect(assigns(:snippet)).to eq(personal_snippet)
+          expect(response.status).to eq(200)
+        end
+      end
+
+      context 'when not signed in' do
+        it 'renders the snippet' do
+          get :show, id: personal_snippet.to_param
+
+          expect(assigns(:snippet)).to eq(personal_snippet)
+          expect(response.status).to eq(200)
+        end
+      end
+    end
+
+    context 'when the personal snippet does not exist' do
+      context 'when signed in' do
+        before do
+          sign_in(user)
+        end
+
+        it 'responds with status 404' do
+          get :show, id: 'doesntexist'
+
+          expect(response.status).to eq(404)
+        end
+      end
+
+      context 'when not signed in' do
+        it 'responds with status 404' do
+          get :show, id: 'doesntexist'
+
+          expect(response.status).to eq(404)
+        end
+      end
+    end
+  end
+end

spec/controllers/users_controller_spec.rb

@@ -16,13 +16,26 @@ describe UsersController do
     context 'with rendered views' do
       render_views
 
-      it 'renders the show template' do
-        sign_in(user)
+      describe 'when logged in' do
+        before do
+          sign_in(user)
+        end
 
-        get :show, username: user.username
+        it 'renders the show template' do
+          get :show, username: user.username
 
-        expect(response).to be_success
-        expect(response).to render_template('show')
+          expect(response).to be_success
+          expect(response).to render_template('show')
+        end
+      end
+
+      describe 'when logged out' do
+        it 'renders the show template' do
+          get :show, username: user.username
+
+          expect(response).to be_success
+          expect(response).to render_template('show')
+        end
       end
     end
   end

spec/factories.rb

@@ -169,6 +169,18 @@ FactoryGirl.define do
     title
     content
     file_name
+
+    trait :public do
+      visibility_level Gitlab::VisibilityLevel::PUBLIC
+    end
+
+    trait :internal do
+      visibility_level Gitlab::VisibilityLevel::INTERNAL
+    end
+
+    trait :private do
+      visibility_level Gitlab::VisibilityLevel::PRIVATE
+    end
   end
 
   factory :snippet do

spec/finders/contributed_projects_finder_spec.rb

+require 'spec_helper'
+
+describe ContributedProjectsFinder do
+  let(:source_user) { create(:user) }
+  let(:current_user) { create(:user) }
+
+  let(:finder) { described_class.new(source_user) }
+
+  let!(:public_project) { create(:project, :public) }
+  let!(:private_project) { create(:project, :private) }
+
+  before do
+    private_project.team << [source_user, Gitlab::Access::MASTER]
+    private_project.team << [current_user, Gitlab::Access::DEVELOPER]
+    public_project.team << [source_user, Gitlab::Access::MASTER]
+
+    create(:event, action: Event::PUSHED, project: public_project,
+                   target: public_project, author: source_user)
+
+    create(:event, action: Event::PUSHED, project: private_project,
+                   target: private_project, author: source_user)
+  end
+
+  describe 'without a current user' do
+    subject { finder.execute }
+
+    it { is_expected.to eq([public_project]) }
+  end
+
+  describe 'with a current user' do
+    subject { finder.execute(current_user) }
+
+    it { is_expected.to eq([private_project, public_project]) }
+  end
+end

spec/finders/group_finder_spec.rb

-require 'spec_helper'
-
-describe GroupsFinder do
-  let(:user) { create :user }
-  let!(:group) { create :group }
-  let!(:public_group) { create :group, public: true }
-  
-  describe :execute do
-    it 'finds public group' do
-      groups = GroupsFinder.new.execute(user)
-      expect(groups.size).to eq(1)
-      expect(groups.first).to eq(public_group)
-    end
-  end
-end

spec/finders/groups_finder_spec.rb

+require 'spec_helper'
+
+describe GroupsFinder do
+  describe '#execute' do
+    let(:user) { create(:user) }
+
+    let(:group1) { create(:group) }
+    let(:group2) { create(:group) }
+    let(:group3) { create(:group) }
+    let(:group4) { create(:group, public: true) }
+
+    let!(:public_project)   { create(:project, :public, group: group1) }
+    let!(:internal_project) { create(:project, :internal, group: group2) }
+    let!(:private_project)  { create(:project, :private, group: group3) }
+
+    let(:finder) { described_class.new }
+
+    describe 'with a user' do
+      subject { finder.execute(user) }
+
+      describe 'when the user is not a member of any groups' do
+        it { is_expected.to eq([group4, group2, group1]) }
+      end
+
+      describe 'when the user is a member of a group' do
+        before do
+          group3.add_user(user, Gitlab::Access::DEVELOPER)
+        end
+
+        it { is_expected.to eq([group4, group3, group2, group1]) }
+      end
+
+      describe 'when the user is a member of a private project' do
+        before do
+          private_project.team.add_user(user, Gitlab::Access::DEVELOPER)
+        end
+
+        it { is_expected.to eq([group4, group3, group2, group1]) }
+      end
+    end
+
+    describe 'without a user' do
+      subject { finder.execute }
+
+      it { is_expected.to eq([group4, group1]) }
+    end
+  end
+end

spec/finders/joined_groups_finder_spec.rb

+require 'spec_helper'
+
+describe JoinedGroupsFinder do
+  describe '#execute' do
+    let(:source_user) { create(:user) }
+    let(:current_user) { create(:user) }
+
+    let(:group1) { create(:group) }
+    let(:group2) { create(:group) }
+    let(:group3) { create(:group) }
+    let(:group4) { create(:group, public: true) }
+
+    let!(:public_project)   { create(:project, :public, group: group1) }
+    let!(:internal_project) { create(:project, :internal, group: group2) }
+    let!(:private_project)  { create(:project, :private, group: group3) }
+
+    let(:finder) { described_class.new(source_user) }
+
+    before do
+      [group1, group2, group3, group4].each do |group|
+        group.add_user(source_user, Gitlab::Access::MASTER)
+      end
+    end
+
+    describe 'with a current user' do
+      describe 'when the current user has access to the projects of the source user' do
+        before do
+          private_project.team.add_user(current_user, Gitlab::Access::DEVELOPER)
+        end
+
+        subject { finder.execute(current_user) }
+
+        it { is_expected.to eq([group4, group3, group2, group1]) }
+      end
+
+      describe 'when the current user does not have access to the projects of the source user' do
+        subject { finder.execute(current_user) }
+
+        it { is_expected.to eq([group4, group2, group1]) }
+      end
+    end
+
+    describe 'without a current user' do
+      subject { finder.execute }
+
+      it { is_expected.to eq([group4, group1]) }
+    end
+  end
+end

spec/finders/personal_projects_finder_spec.rb

+require 'spec_helper'
+
+describe PersonalProjectsFinder do
+  let(:source_user) { create(:user) }
+  let(:current_user) { create(:user) }
+
+  let(:finder) { described_class.new(source_user) }
+
+  let!(:public_project) do
+    create(:project, :public, namespace: source_user.namespace, name: 'A',
+                              path: 'A')
+  end
+
+  let!(:private_project) do
+    create(:project, :private, namespace: source_user.namespace, name: 'B',
+                               path: 'B')
+  end
+
+  before do
+    private_project.team << [current_user, Gitlab::Access::DEVELOPER]
+  end
+
+  describe 'without a current user' do
+    subject { finder.execute }
+
+    it { is_expected.to eq([public_project]) }
+  end
+
+  describe 'with a current user' do
+    subject { finder.execute(current_user) }
+
+    it { is_expected.to eq([private_project, public_project]) }
+  end
+end

spec/finders/projects_finder_spec.rb

 require 'spec_helper'
 
 describe ProjectsFinder do
+<<<<<<< HEAD
   let(:user) { create :user }
   let(:group) { create :group }
   let(:group2) { create :group }
@@ -13,45 +14,59 @@ describe ProjectsFinder do
   let(:project6) { create(:empty_project, :internal,  group: group2) }
   let(:project7) { create(:empty_project, :public,  group: group2) }
   let(:project8) { create(:empty_project, :private,  group: group2) }
+=======
+  describe '#execute' do
+    let(:user) { create(:user) }
 
-  context 'non authenticated' do
-    subject { ProjectsFinder.new.execute(nil, group: group) }
+    let!(:private_project)  { create(:project, :private) }
+    let!(:internal_project) { create(:project, :internal) }
+    let!(:public_project)   { create(:project, :public) }
+>>>>>>> b6f0eddce552d7423869e9072a7a0706e309dbdf
 
-    it { is_expected.to include(project1) }
-    it { is_expected.not_to include(project2) }
-    it { is_expected.not_to include(project3) }
-    it { is_expected.not_to include(project4) }
-  end
+    let(:finder) { described_class.new }
 
-  context 'authenticated' do
-    subject { ProjectsFinder.new.execute(user, group: group) }
+    describe 'without a group' do
+      describe 'without a user' do
+        subject { finder.execute }
 
-    it { is_expected.to include(project1) }
-    it { is_expected.to include(project2) }
-    it { is_expected.not_to include(project3) }
-    it { is_expected.not_to include(project4) }
-  end
+        it { is_expected.to eq([public_project]) }
+      end
 
-  context 'authenticated, project member' do
-    before { project3.team << [user, :developer] }
+      describe 'with a user' do
+        subject { finder.execute(user) }
 
-    subject { ProjectsFinder.new.execute(user, group: group) }
+        describe 'without private projects' do
+          it { is_expected.to eq([public_project, internal_project]) }
+        end
 
-    it { is_expected.to include(project1) }
-    it { is_expected.to include(project2) }
-    it { is_expected.to include(project3) }
-    it { is_expected.not_to include(project4) }
-  end
+        describe 'with private projects' do
+          before do
+            private_project.team.add_user(user, Gitlab::Access::MASTER)
+          end
+
+          it do
+            is_expected.to eq([public_project, internal_project,
+                               private_project])
+          end
+        end
+      end
+    end
+
+    describe 'with a group' do
+      let(:group) { public_project.group }
 
-  context 'authenticated, group member' do
-    before { group.add_developer(user) }
+      describe 'without a user' do
+        subject { finder.execute(nil, group: group) }
 
-    subject { ProjectsFinder.new.execute(user, group: group) }
+        it { is_expected.to eq([public_project]) }
+      end
 
-    it { is_expected.to include(project1) }
-    it { is_expected.to include(project2) }
-    it { is_expected.to include(project3) }
-    it { is_expected.to include(project4) }
+      describe 'with a user' do
+        subject { finder.execute(user, group: group) }
+
+        it { is_expected.to eq([public_project, internal_project]) }
+      end
+    end
   end
 
   context 'authenticated, group member with project shared with group' do

spec/helpers/issues_helper_spec.rb

@@ -127,4 +127,30 @@ describe IssuesHelper do
     it { is_expected.to eq("!1, !2, or !3") }
   end
 
+  describe "#url_to_emoji" do
+    it "returns url" do
+      expect(url_to_emoji("smile")).to include("emoji/1F604.png")
+    end
+  end
+
+  describe "#emoji_list" do
+    it "returns url" do
+      expect(emoji_list).to be_kind_of(Array)
+    end
+  end
+
+  describe "#note_active_class" do
+    before do
+      @note = create :note
+      @note1 = create :note
+    end
+
+    it "returns empty string for unauthenticated user" do
+      expect(note_active_class(Note.all, nil)).to eq("")
+    end
+
+    it "returns active string for author" do
+      expect(note_active_class(Note.all, @note.author)).to eq("active")
+    end
+  end
 end

spec/lib/ci/gitlab_ci_yaml_processor_spec.rb

@@ -425,8 +425,12 @@ module Ci
     end
 
     describe "Error handling" do
+      it "fails to parse YAML" do
+        expect{GitlabCiYamlProcessor.new("invalid: yaml: test")}.to raise_error(Psych::SyntaxError)
+      end
+
       it "indicates that object is invalid" do
-        expect{GitlabCiYamlProcessor.new("invalid_yaml\n!ccdvlf%612334@@@@")}.to raise_error(GitlabCiYamlProcessor::ValidationError)
+        expect{GitlabCiYamlProcessor.new("invalid_yaml")}.to raise_error(GitlabCiYamlProcessor::ValidationError)
       end
 
       it "returns errors if tags parameter is invalid" do

spec/lib/gitlab/lfs/lfs_router_spec.rb

@@ -26,113 +26,52 @@ describe Gitlab::Lfs::Router do
 
   let(:sample_oid) { "b68143e6463773b1b6c6fd009a76c32aeec041faff32ba2ed42fd7f708a17f80" }
   let(:sample_size) { 499013 }
+  let(:respond_with_deprecated) {[ 501, { "Content-Type"=>"application/json; charset=utf-8" }, ["{\"message\":\"Server supports batch API only, please update your Git LFS client to version 0.6.0 and up.\",\"documentation_url\":\"#{Gitlab.config.gitlab.url}/help\"}"]]}
+  let(:respond_with_disabled) {[ 501, { "Content-Type"=>"application/json; charset=utf-8" }, ["{\"message\":\"Git LFS is not enabled on this GitLab server, contact your admin.\",\"documentation_url\":\"#{Gitlab.config.gitlab.url}/help\"}"]]}
 
   describe 'when lfs is disabled' do
     before do
       allow(Gitlab.config.lfs).to receive(:enabled).and_return(false)
-      env["PATH_INFO"] = "#{project.repository.path_with_namespace}.git/info/lfs/objects/#{sample_oid}"
+      env['REQUEST_METHOD'] = 'POST'
+      body = {
+                'objects' => [
+                  { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
+                    'size' => 1575078
+                  },
+                  { 'oid' => sample_oid,
+                    'size' => sample_size
+                  }
+                ],
+                'operation' => 'upload'
+              }.to_json
+      env['rack.input'] = StringIO.new(body)
+      env["PATH_INFO"] = "#{project.repository.path_with_namespace}.git/info/lfs/objects/batch"
     end
 
     it 'responds with 501' do
-      respond_with_disabled = [ 501,
-                                { "Content-Type"=>"application/vnd.git-lfs+json" },
-                                ["{\"message\":\"Git LFS is not enabled on this GitLab server, contact your admin.\",\"documentation_url\":\"#{Gitlab.config.gitlab.url}/help\"}"]
-                              ]
       expect(lfs_router_auth.try_call).to match_array(respond_with_disabled)
     end
   end
 
-  describe 'when fetching lfs object' do
+  describe 'when fetching lfs object using deprecated API' do
     before do
       enable_lfs
-      env['HTTP_ACCEPT'] = "application/vnd.git-lfs+json; charset=utf-8"
       env["PATH_INFO"] = "#{project.repository.path_with_namespace}.git/info/lfs/objects/#{sample_oid}"
     end
 
-    describe 'when user is authenticated' do
-      context 'and user has project download access' do
-        before do
-          @auth = authorize(user)
-          env["HTTP_AUTHORIZATION"] = @auth
-          project.lfs_objects << lfs_object
-          project.team << [user, :master]
-        end
-
-        it "responds with status 200" do
-          expect(lfs_router_auth.try_call.first).to eq(200)
-        end
-
-        it "responds with download hypermedia" do
-          json_response = ActiveSupport::JSON.decode(lfs_router_auth.try_call.last.first)
-
-          expect(json_response['_links']['download']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}.git/gitlab-lfs/objects/#{sample_oid}")
-          expect(json_response['_links']['download']['header']).to eq("Authorization" => @auth, "Accept" => "application/vnd.git-lfs+json; charset=utf-8")
-        end
-      end
-
-      context 'and user does not have project access' do
-        it "responds with status 403" do
-          expect(lfs_router_auth.try_call.first).to eq(403)
-        end
-      end
-    end
-
-    describe 'when user is unauthenticated' do
-      context 'and user does not have download access' do
-        it "responds with status 401" do
-          expect(lfs_router_noauth.try_call.first).to eq(401)
-        end
-      end
-
-      context 'and user has download access' do
-        before do
-          project.team << [user, :master]
-        end
-
-        it "responds with status 401" do
-          expect(lfs_router_noauth.try_call.first).to eq(401)
-        end
-      end
+    it 'responds with 501' do
+      expect(lfs_router_auth.try_call).to match_array(respond_with_deprecated)
     end
+  end
 
-    describe 'and project is public' do
-      context 'and project has access to the lfs object' do
-        before do
-          public_project.lfs_objects << lfs_object
-        end
-
-        context 'and user is authenticated' do
-          it "responds with status 200 and sends download hypermedia" do
-            expect(lfs_router_public_auth.try_call.first).to eq(200)
-            json_response = ActiveSupport::JSON.decode(lfs_router_public_auth.try_call.last.first)
-
-            expect(json_response['_links']['download']['href']).to eq("#{Gitlab.config.gitlab.url}/#{public_project.path_with_namespace}.git/gitlab-lfs/objects/#{sample_oid}")
-            expect(json_response['_links']['download']['header']).to eq("Accept" => "application/vnd.git-lfs+json; charset=utf-8")
-          end
-        end
-
-        context 'and user is unauthenticated' do
-          it "responds with status 200 and sends download hypermedia" do
-            expect(lfs_router_public_noauth.try_call.first).to eq(200)
-            json_response = ActiveSupport::JSON.decode(lfs_router_public_noauth.try_call.last.first)
-
-            expect(json_response['_links']['download']['href']).to eq("#{Gitlab.config.gitlab.url}/#{public_project.path_with_namespace}.git/gitlab-lfs/objects/#{sample_oid}")
-            expect(json_response['_links']['download']['header']).to eq("Accept" => "application/vnd.git-lfs+json; charset=utf-8")
-          end
-        end
-      end
-
-      context 'and project does not have access to the lfs object' do
-        it "responds with status 404" do
-          expect(lfs_router_public_auth.try_call.first).to eq(404)
-        end
-      end
+  describe 'when fetching lfs object' do
+    before do
+      enable_lfs
+      env['HTTP_ACCEPT'] = "application/vnd.git-lfs+json; charset=utf-8"
+      env["PATH_INFO"] = "#{project.repository.path_with_namespace}.git/gitlab-lfs/objects/#{sample_oid}"
     end
 
     describe 'and request comes from gitlab-workhorse' do
-      before do
-        env["PATH_INFO"] = "#{project.repository.path_with_namespace}.git/gitlab-lfs/objects/#{sample_oid}"
-      end
       context 'without user being authorized' do
         it "responds with status 401" do
           expect(lfs_router_noauth.try_call.first).to eq(401)
@@ -173,200 +112,376 @@ describe Gitlab::Lfs::Router do
         end
       end
     end
+  end
 
-    describe 'from a forked public project' do
-      before do
-        env['HTTP_ACCEPT'] = "application/vnd.git-lfs+json; charset=utf-8"
-        env["PATH_INFO"] = "#{forked_project.repository.path_with_namespace}.git/info/lfs/objects/#{sample_oid}"
-      end
+  describe 'when handling lfs request using deprecated API' do
+    before do
+      enable_lfs
+      env['REQUEST_METHOD'] = 'POST'
+      env["PATH_INFO"] = "#{project.repository.path_with_namespace}.git/info/lfs/objects"
+    end
+
+    it 'responds with 501' do
+      expect(lfs_router_auth.try_call).to match_array(respond_with_deprecated)
+    end
+  end
+
+  describe 'when handling lfs batch request' do
+    before do
+      enable_lfs
+      env['REQUEST_METHOD'] = 'POST'
+      env['PATH_INFO'] = "#{project.repository.path_with_namespace}.git/info/lfs/objects/batch"
+    end
+
+    describe 'download' do
+      describe 'when user is authenticated' do
+        before do
+          body = { 'operation' => 'download',
+                   'objects' => [
+                     { 'oid' => sample_oid,
+                       'size' => sample_size
+                     }]
+          }.to_json
+          env['rack.input'] = StringIO.new(body)
+        end
 
-      context "when fetching a lfs object" do
-        context "and user has project download access" do
+        describe 'when user has download access' do
           before do
-            public_project.lfs_objects << lfs_object
+            @auth = authorize(user)
+            env["HTTP_AUTHORIZATION"] = @auth
+            project.team << [user, :reporter]
           end
 
-          it "can download the lfs object" do
-            expect(lfs_router_forked_auth.try_call.first).to eq(200)
-            json_response = ActiveSupport::JSON.decode(lfs_router_forked_auth.try_call.last.first)
+          context 'when downloading an lfs object that is assigned to our project' do
+            before do
+              project.lfs_objects << lfs_object
+            end
+
+            it 'responds with status 200 and href to download' do
+              response = lfs_router_auth.try_call
+              expect(response.first).to eq(200)
+              response_body = ActiveSupport::JSON.decode(response.last.first)
 
-            expect(json_response['_links']['download']['href']).to eq("#{Gitlab.config.gitlab.url}/#{forked_project.path_with_namespace}.git/gitlab-lfs/objects/#{sample_oid}")
-            expect(json_response['_links']['download']['header']).to eq("Accept" => "application/vnd.git-lfs+json; charset=utf-8")
+              expect(response_body).to eq('objects' => [
+                { 'oid' => sample_oid,
+                  'size' => sample_size,
+                  'actions' => {
+                    'download' => {
+                      'href' => "#{project.http_url_to_repo}/gitlab-lfs/objects/#{sample_oid}",
+                      'header' => { 'Authorization' => @auth }
+                    }
+                  }
+                }])
+            end
           end
-        end
 
-        context "and user is not authenticated but project is public" do
-          before do
-            public_project.lfs_objects << lfs_object
+          context 'when downloading an lfs object that is assigned to other project' do
+            before do
+              public_project.lfs_objects << lfs_object
+            end
+
+            it 'responds with status 200 and error message' do
+              response = lfs_router_auth.try_call
+              expect(response.first).to eq(200)
+              response_body = ActiveSupport::JSON.decode(response.last.first)
+
+              expect(response_body).to eq('objects' => [
+                { 'oid' => sample_oid,
+                  'size' => sample_size,
+                  'error' => {
+                    'code' => 404,
+                    'message' => "Object does not exist on the server or you don't have permissions to access it",
+                  }
+                }])
+            end
           end
 
-          it "can download the lfs object" do
-            expect(lfs_router_forked_auth.try_call.first).to eq(200)
+          context 'when downloading a lfs object that does not exist' do
+            before do
+              body = { 'operation' => 'download',
+                       'objects' => [
+                         { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
+                           'size' => 1575078
+                         }]
+              }.to_json
+              env['rack.input'] = StringIO.new(body)
+            end
+
+            it "responds with status 200 and error message" do
+              response = lfs_router_auth.try_call
+              expect(response.first).to eq(200)
+              response_body = ActiveSupport::JSON.decode(response.last.first)
+
+              expect(response_body).to eq('objects' => [
+                { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
+                  'size' => 1575078,
+                  'error' => {
+                    'code' => 404,
+                    'message' => "Object does not exist on the server or you don't have permissions to access it",
+                  }
+                }])
+            end
+          end
+
+          context 'when downloading one new and one existing lfs object' do
+            before do
+              body = { 'operation' => 'download',
+                       'objects' => [
+                         { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
+                           'size' => 1575078
+                         },
+                         { 'oid' => sample_oid,
+                           'size' => sample_size
+                         }
+                       ]
+              }.to_json
+              env['rack.input'] = StringIO.new(body)
+              project.lfs_objects << lfs_object
+            end
+
+            it "responds with status 200 with upload hypermedia link for the new object" do
+              response = lfs_router_auth.try_call
+              expect(response.first).to eq(200)
+              response_body = ActiveSupport::JSON.decode(response.last.first)
+
+              expect(response_body).to eq('objects' => [
+                { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
+                  'size' => 1575078,
+                  'error' => {
+                    'code' => 404,
+                    'message' => "Object does not exist on the server or you don't have permissions to access it",
+                  }
+                },
+                { 'oid' => sample_oid,
+                  'size' => sample_size,
+                  'actions' => {
+                    'download' => {
+                      'href' => "#{project.http_url_to_repo}/gitlab-lfs/objects/#{sample_oid}",
+                      'header' => { 'Authorization' => @auth }
+                    }
+                  }
+                }])
+            end
           end
         end
 
-        context "and user has project download access" do
+        context 'when user does is not member of the project' do
           before do
-            env["PATH_INFO"] = "#{forked_project.repository.path_with_namespace}.git/info/lfs/objects/91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897"
-            @auth = ActionController::HttpAuthentication::Basic.encode_credentials(user.username, user.password)
+            @auth = authorize(user)
             env["HTTP_AUTHORIZATION"] = @auth
-            lfs_object_two = create(:lfs_object, :with_file, oid: "91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897", size: 1575078)
-            public_project.lfs_objects << lfs_object_two
+            project.team << [user, :guest]
           end
 
-          it "can get a lfs object that is not in the forked project" do
-            expect(lfs_router_forked_auth.try_call.first).to eq(200)
-
-            json_response = ActiveSupport::JSON.decode(lfs_router_forked_auth.try_call.last.first)
-            expect(json_response['_links']['download']['href']).to eq("#{Gitlab.config.gitlab.url}/#{forked_project.path_with_namespace}.git/gitlab-lfs/objects/91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897")
-            expect(json_response['_links']['download']['header']).to eq("Accept" => "application/vnd.git-lfs+json; charset=utf-8", "Authorization" => @auth)
+          it 'responds with 403' do
+            expect(lfs_router_auth.try_call.first).to eq(403)
           end
         end
 
-        context "and user has project download access" do
+        context 'when user does not have download access' do
           before do
-            env["PATH_INFO"] = "#{forked_project.repository.path_with_namespace}.git/info/lfs/objects/267c8b1d876743971e3a9978405818ff5ca731c4c870b06507619cd9b1847b6b"
-            lfs_object_three = create(:lfs_object, :with_file, oid: "267c8b1d876743971e3a9978405818ff5ca731c4c870b06507619cd9b1847b6b", size: 127192524)
-            project.lfs_objects << lfs_object_three
+            @auth = authorize(user)
+            env["HTTP_AUTHORIZATION"] = @auth
+            project.team << [user, :guest]
           end
 
-          it "cannot get a lfs object that is not in the project" do
-            expect(lfs_router_forked_auth.try_call.first).to eq(404)
+          it 'responds with 403' do
+            expect(lfs_router_auth.try_call.first).to eq(403)
           end
         end
       end
-    end
-  end
-
-  describe 'when initiating pushing of the lfs object' do
-    before do
-      enable_lfs
-      env['REQUEST_METHOD'] = 'POST'
-      env["PATH_INFO"] = "#{project.repository.path_with_namespace}.git/info/lfs/objects/batch"
-    end
-
-    describe 'when user is authenticated' do
-      before do
-        body = { 'objects' => [{
-                   'oid' => sample_oid,
-                   'size' => sample_size
-                  }]
-                }.to_json
-        env['rack.input'] = StringIO.new(body)
-      end
 
-      describe 'when user has project push access' do
+      context 'when user is not authenticated' do
         before do
-          @auth = authorize(user)
-          env["HTTP_AUTHORIZATION"] = @auth
-          project.team << [user, :master]
+          body = { 'operation' => 'download',
+                   'objects' => [
+                     { 'oid' => sample_oid,
+                       'size' => sample_size
+                     }],
+
+          }.to_json
+          env['rack.input'] = StringIO.new(body)
         end
 
-        context 'when pushing an lfs object that already exists' do
+        describe 'is accessing public project' do
           before do
             public_project.lfs_objects << lfs_object
           end
 
-          it "responds with status 200 and links the object to the project" do
-            response_body = lfs_router_auth.try_call.last
-            response = ActiveSupport::JSON.decode(response_body.first)
+          it 'responds with status 200 and href to download' do
+            response = lfs_router_public_noauth.try_call
+            expect(response.first).to eq(200)
+            response_body = ActiveSupport::JSON.decode(response.last.first)
 
-            expect(response['objects']).to be_kind_of(Array)
-            expect(response['objects'].first['oid']).to eq(sample_oid)
-            expect(response['objects'].first['size']).to eq(sample_size)
-            expect(lfs_object.projects.pluck(:id)).to_not include(project.id)
-            expect(lfs_object.projects.pluck(:id)).to include(public_project.id)
-            expect(response['objects'].first).to have_key('_links')
+            expect(response_body).to eq('objects' => [
+              { 'oid' => sample_oid,
+                'size' => sample_size,
+                'actions' => {
+                  'download' => {
+                    'href' => "#{public_project.http_url_to_repo}/gitlab-lfs/objects/#{sample_oid}",
+                    'header' => {}
+                  }
+                }
+              }])
           end
         end
 
-        context 'when pushing a lfs object that does not exist' do
+        describe 'is accessing non-public project' do
           before do
-            body = {
-              'objects' => [{
-                'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
-                'size' => 1575078
-                }]
-                }.to_json
-            env['rack.input'] = StringIO.new(body)
+            project.lfs_objects << lfs_object
           end
 
-          it "responds with status 200 and upload hypermedia link" do
-            response = lfs_router_auth.try_call
-            expect(response.first).to eq(200)
-
-            response_body = ActiveSupport::JSON.decode(response.last.first)
-            expect(response_body['objects']).to be_kind_of(Array)
-            expect(response_body['objects'].first['oid']).to eq("91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897")
-            expect(response_body['objects'].first['size']).to eq(1575078)
-            expect(lfs_object.projects.pluck(:id)).not_to include(project.id)
-            expect(response_body['objects'].first['_links']['upload']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}.git/gitlab-lfs/objects/91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897/1575078")
-            expect(response_body['objects'].first['_links']['upload']['header']).to eq("Authorization" => @auth)
+          it 'responds with authorization required' do
+            expect(lfs_router_noauth.try_call.first).to eq(401)
           end
         end
+      end
+    end
 
-        context 'when pushing one new and one existing lfs object' do
+    describe 'upload' do
+      describe 'when user is authenticated' do
+        before do
+          body = { 'operation' => 'upload',
+                   'objects' => [
+                     { 'oid' => sample_oid,
+                       'size' => sample_size
+                     }]
+          }.to_json
+          env['rack.input'] = StringIO.new(body)
+        end
+
+        describe 'when user has project push access' do
           before do
-            body = {
-              'objects' => [
-                { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
-                  'size' => 1575078
-                },
-                { 'oid' => sample_oid,
-                  'size' => sample_size
-                }
-              ]
-            }.to_json
-            env['rack.input'] = StringIO.new(body)
-            public_project.lfs_objects << lfs_object
+            @auth = authorize(user)
+            env["HTTP_AUTHORIZATION"] = @auth
+            project.team << [user, :developer]
           end
 
-          it "responds with status 200 with upload hypermedia link for the new object" do
-            response = lfs_router_auth.try_call
-            expect(response.first).to eq(200)
+          context 'when pushing an lfs object that already exists' do
+            before do
+              public_project.lfs_objects << lfs_object
+            end
 
-            response_body = ActiveSupport::JSON.decode(response.last.first)
-            expect(response_body['objects']).to be_kind_of(Array)
+            it "responds with status 200 and links the object to the project" do
+              response_body = lfs_router_auth.try_call.last
+              response = ActiveSupport::JSON.decode(response_body.first)
 
+              expect(response['objects']).to be_kind_of(Array)
+              expect(response['objects'].first['oid']).to eq(sample_oid)
+              expect(response['objects'].first['size']).to eq(sample_size)
+              expect(lfs_object.projects.pluck(:id)).to_not include(project.id)
+              expect(lfs_object.projects.pluck(:id)).to include(public_project.id)
+              expect(response['objects'].first['actions']['upload']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}.git/gitlab-lfs/objects/#{sample_oid}/#{sample_size}")
+              expect(response['objects'].first['actions']['upload']['header']).to eq('Authorization' => @auth)
+            end
+          end
 
-            expect(response_body['objects'].first['oid']).to eq("91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897")
-            expect(response_body['objects'].first['size']).to eq(1575078)
-            expect(response_body['objects'].first['_links']['upload']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}.git/gitlab-lfs/objects/91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897/1575078")
-            expect(response_body['objects'].first['_links']['upload']['header']).to eq("Authorization" => @auth)
+          context 'when pushing a lfs object that does not exist' do
+            before do
+              body = { 'operation' => 'upload',
+                       'objects' => [
+                         { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
+                           'size' => 1575078
+                         }]
+              }.to_json
+              env['rack.input'] = StringIO.new(body)
+            end
 
-            expect(response_body['objects'].last['oid']).to eq(sample_oid)
-            expect(response_body['objects'].last['size']).to eq(sample_size)
-            expect(lfs_object.projects.pluck(:id)).to_not include(project.id)
-            expect(lfs_object.projects.pluck(:id)).to include(public_project.id)
-            expect(response_body['objects'].last).to have_key('_links')
+            it "responds with status 200 and upload hypermedia link" do
+              response = lfs_router_auth.try_call
+              expect(response.first).to eq(200)
+
+              response_body = ActiveSupport::JSON.decode(response.last.first)
+              expect(response_body['objects']).to be_kind_of(Array)
+              expect(response_body['objects'].first['oid']).to eq("91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897")
+              expect(response_body['objects'].first['size']).to eq(1575078)
+              expect(lfs_object.projects.pluck(:id)).not_to include(project.id)
+              expect(response_body['objects'].first['actions']['upload']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}.git/gitlab-lfs/objects/91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897/1575078")
+              expect(response_body['objects'].first['actions']['upload']['header']).to eq('Authorization' => @auth)
+            end
+          end
+
+          context 'when pushing one new and one existing lfs object' do
+            before do
+              body = { 'operation' => 'upload',
+                       'objects' => [
+                         { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
+                           'size' => 1575078
+                         },
+                         { 'oid' => sample_oid,
+                           'size' => sample_size
+                         }
+                       ]
+              }.to_json
+              env['rack.input'] = StringIO.new(body)
+              project.lfs_objects << lfs_object
+            end
+
+            it "responds with status 200 with upload hypermedia link for the new object" do
+              response = lfs_router_auth.try_call
+              expect(response.first).to eq(200)
+
+              response_body = ActiveSupport::JSON.decode(response.last.first)
+              expect(response_body['objects']).to be_kind_of(Array)
+
+              expect(response_body['objects'].first['oid']).to eq("91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897")
+              expect(response_body['objects'].first['size']).to eq(1575078)
+              expect(response_body['objects'].first['actions']['upload']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}.git/gitlab-lfs/objects/91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897/1575078")
+              expect(response_body['objects'].first['actions']['upload']['header']).to eq("Authorization" => @auth)
+
+              expect(response_body['objects'].last['oid']).to eq(sample_oid)
+              expect(response_body['objects'].last['size']).to eq(sample_size)
+              expect(response_body['objects'].last).to_not have_key('actions')
+            end
           end
         end
-      end
 
-      context 'when user does not have push access' do
-        it 'responds with 403' do
-          expect(lfs_router_auth.try_call.first).to eq(403)
+        context 'when user does not have push access' do
+          it 'responds with 403' do
+            expect(lfs_router_auth.try_call.first).to eq(403)
+          end
         end
       end
-    end
 
-    context 'when user is not authenticated' do
-      context 'when user has push access' do
+      context 'when user is not authenticated' do
         before do
-          project.team << [user, :master]
+          env['rack.input'] = StringIO.new(
+            { 'objects' => [], 'operation' => 'upload' }.to_json
+          )
         end
 
-        it "responds with status 401" do
-          expect(lfs_router_public_noauth.try_call.first).to eq(401)
+        context 'when user has push access' do
+          before do
+            project.team << [user, :master]
+          end
+
+          it "responds with status 401" do
+            expect(lfs_router_public_noauth.try_call.first).to eq(401)
+          end
         end
-      end
 
-      context 'when user does not have push access' do
-        it "responds with status 401" do
-          expect(lfs_router_public_noauth.try_call.first).to eq(401)
+        context 'when user does not have push access' do
+          it "responds with status 401" do
+            expect(lfs_router_public_noauth.try_call.first).to eq(401)
+          end
         end
       end
     end
+
+    describe 'unsupported' do
+      before do
+        body = { 'operation' => 'other',
+                 'objects' => [
+                   { 'oid' => sample_oid,
+                     'size' => sample_size
+                   }]
+        }.to_json
+        env['rack.input'] = StringIO.new(body)
+      end
+
+      it 'responds with status 404' do
+        expect(lfs_router_public_noauth.try_call.first).to eq(404)
+      end
+    end
   end
 
   describe 'when pushing a lfs object' do

spec/lib/gitlab/sql/union_spec.rb

+require 'spec_helper'
+
+describe Gitlab::SQL::Union do
+  describe '#to_sql' do
+    it 'returns a String joining relations together using a UNION' do
+      rel1  = User.where(email: 'alice@example.com')
+      rel2  = User.where(email: 'bob@example.com')
+      union = described_class.new([rel1, rel2])
+
+      sql1 = rel1.reorder(nil).to_sql
+      sql2 = rel2.reorder(nil).to_sql
+
+      expect(union.to_sql).to eq("#{sql1}\nUNION\n#{sql2}")
+    end
+  end
+end

spec/lib/votes_spec.rb

-require 'spec_helper'
-
-describe Issue, 'Votes' do
-  let(:issue) { create(:issue) }
-
-  describe "#upvotes" do
-    it "with no notes has a 0/0 score" do
-      expect(issue.upvotes).to eq(0)
-    end
-
-    it "should recognize non-+1 notes" do
-      add_note "No +1 here"
-      expect(issue.notes.size).to eq(1)
-      expect(issue.notes.first.upvote?).to be_falsey
-      expect(issue.upvotes).to eq(0)
-    end
-
-    it "should recognize a single +1 note" do
-      add_note "+1 This is awesome"
-      expect(issue.upvotes).to eq(1)
-    end
-
-    it 'should recognize multiple +1 notes' do
-      add_note '+1 This is awesome', create(:user)
-      add_note '+1 I want this', create(:user)
-      expect(issue.upvotes).to eq(2)
-    end
-
-    it 'should not count 2 +1 votes from the same user' do
-      add_note '+1 This is awesome'
-      add_note '+1 I want this'
-      expect(issue.upvotes).to eq(1)
-    end
-  end
-
-  describe "#downvotes" do
-    it "with no notes has a 0/0 score" do
-      expect(issue.downvotes).to eq(0)
-    end
-
-    it "should recognize non--1 notes" do
-      add_note "Almost got a -1"
-      expect(issue.notes.size).to eq(1)
-      expect(issue.notes.first.downvote?).to be_falsey
-      expect(issue.downvotes).to eq(0)
-    end
-
-    it "should recognize a single -1 note" do
-      add_note "-1 This is bad"
-      expect(issue.downvotes).to eq(1)
-    end
-
-    it "should recognize multiple -1 notes" do
-      add_note('-1 This is bad', create(:user))
-      add_note('-1 Away with this', create(:user))
-      expect(issue.downvotes).to eq(2)
-    end
-  end
-
-  describe "#votes_count" do
-    it "with no notes has a 0/0 score" do
-      expect(issue.votes_count).to eq(0)
-    end
-
-    it "should recognize non notes" do
-      add_note "No +1 here"
-      expect(issue.notes.size).to eq(1)
-      expect(issue.votes_count).to eq(0)
-    end
-
-    it "should recognize a single +1 note" do
-      add_note "+1 This is awesome"
-      expect(issue.votes_count).to eq(1)
-    end
-
-    it "should recognize a single -1 note" do
-      add_note "-1 This is bad"
-      expect(issue.votes_count).to eq(1)
-    end
-
-    it "should recognize multiple notes" do
-      add_note('+1 This is awesome', create(:user))
-      add_note('-1 This is bad', create(:user))
-      add_note('+1 I want this', create(:user))
-      expect(issue.votes_count).to eq(3)
-    end
-
-    it 'should not count 2 -1 votes from the same user' do
-      add_note '-1 This is suspicious'
-      add_note '-1 This is bad'
-      expect(issue.votes_count).to eq(1)
-    end
-  end
-
-  describe "#upvotes_in_percent" do
-    it "with no notes has a 0% score" do
-      expect(issue.upvotes_in_percent).to eq(0)
-    end
-
-    it "should count a single 1 note as 100%" do
-      add_note "+1 This is awesome"
-      expect(issue.upvotes_in_percent).to eq(100)
-    end
-
-    it 'should count multiple +1 notes as 100%' do
-      add_note('+1 This is awesome', create(:user))
-      add_note('+1 I want this', create(:user))
-      expect(issue.upvotes_in_percent).to eq(100)
-    end
-
-    it 'should count fractions for multiple +1 and -1 notes correctly' do
-      add_note('+1 This is awesome', create(:user))
-      add_note('+1 I want this', create(:user))
-      add_note('-1 This is bad', create(:user))
-      add_note('+1 me too', create(:user))
-      expect(issue.upvotes_in_percent).to eq(75)
-    end
-  end
-
-  describe "#downvotes_in_percent" do
-    it "with no notes has a 0% score" do
-      expect(issue.downvotes_in_percent).to eq(0)
-    end
-
-    it "should count a single -1 note as 100%" do
-      add_note "-1 This is bad"
-      expect(issue.downvotes_in_percent).to eq(100)
-    end
-
-    it 'should count multiple -1 notes as 100%' do
-      add_note('-1 This is bad', create(:user))
-      add_note('-1 Away with this', create(:user))
-      expect(issue.downvotes_in_percent).to eq(100)
-    end
-
-    it 'should count fractions for multiple +1 and -1 notes correctly' do
-      add_note('+1 This is awesome', create(:user))
-      add_note('+1 I want this', create(:user))
-      add_note('-1 This is bad', create(:user))
-      add_note('+1 me too', create(:user))
-      expect(issue.downvotes_in_percent).to eq(25)
-    end
-  end
-
-  describe '#filter_superceded_votes' do
-
-    it 'should count a users vote only once amongst multiple votes' do
-      add_note('-1 This needs work before I will accept it')
-      add_note('+1 I want this', create(:user))
-      add_note('+1 This is is awesome', create(:user))
-      add_note('+1 this looks good now')
-      add_note('+1 This is awesome', create(:user))
-      add_note('+1 me too', create(:user))
-      expect(issue.downvotes).to eq(0)
-      expect(issue.upvotes).to eq(5)
-    end
-
-    it 'should count each users vote only once' do
-      add_note '-1 This needs work before it will be accepted'
-      add_note '+1 I like this'
-      add_note '+1 I still like this'
-      add_note '+1 I really like this'
-      add_note '+1 Give me this now!!!!'
-      expect(issue.downvotes).to eq(0)
-      expect(issue.upvotes).to eq(1)
-    end
-
-    it 'should count a users vote only once without caring about comments' do
-      add_note '-1 This needs work before it will be accepted'
-      add_note 'Comment 1'
-      add_note 'Another comment'
-      add_note '+1 vote'
-      add_note 'final comment'
-      expect(issue.downvotes).to eq(0)
-      expect(issue.upvotes).to eq(1)
-    end
-
-  end
-
-  def add_note(text, author = issue.author)
-    created_at = Time.now - 1.hour + Note.count.seconds
-    issue.notes << create(:note,
-                          note: text,
-                          project: issue.project,
-                          author_id: author.id,
-                          created_at: created_at)
-  end
-end

spec/models/event_spec.rb

@@ -64,4 +64,42 @@ describe Event do
     it { expect(@event.branch_name).to eq("master") }
     it { expect(@event.author).to eq(@user) }
   end
+
+  describe '.latest_update_time' do
+    describe 'when events are present' do
+      let(:time) { Time.utc(2015, 1, 1) }
+
+      before do
+        create(:closed_issue_event, updated_at: time)
+        create(:closed_issue_event, updated_at: time + 5)
+      end
+
+      it 'returns the latest update time' do
+        expect(Event.latest_update_time).to eq(time + 5)
+      end
+    end
+
+    describe 'when no events exist' do
+      it 'returns nil' do
+        expect(Event.latest_update_time).to be_nil
+      end
+    end
+  end
+
+  describe '.limit_recent' do
+    let!(:event1) { create(:closed_issue_event) }
+    let!(:event2) { create(:closed_issue_event) }
+
+    describe 'without an explicit limit' do
+      subject { Event.limit_recent }
+
+      it { is_expected.to eq([event2, event1]) }
+    end
+
+    describe 'with an explicit limit' do
+      subject { Event.limit_recent(1) }
+
+      it { is_expected.to eq([event2]) }
+    end
+  end
 end

spec/models/group_spec.rb

@@ -38,6 +38,33 @@ describe Group do
     it { is_expected.not_to validate_presence_of :owner }
   end
 
+  describe '.public_and_given_groups' do
+    let!(:public_group) { create(:group, public: true) }
+
+    subject { described_class.public_and_given_groups([group.id]) }
+
+    it { is_expected.to eq([public_group, group]) }
+  end
+
+  describe '.visible_to_user' do
+    let!(:group) { create(:group) }
+    let!(:user)  { create(:user) }
+
+    subject { described_class.visible_to_user(user) }
+
+    describe 'when the user has access to a group' do
+      before do
+        group.add_user(user, Gitlab::Access::MASTER)
+      end
+
+      it { is_expected.to eq([group]) }
+    end
+
+    describe 'when the user does not have access to any groups' do
+      it { is_expected.to eq([]) }
+    end
+  end
+
   describe '#to_reference' do
     it 'returns a String reference to the object' do
       expect(group.to_reference).to eq "@#{group.name}"

spec/models/note_spec.rb

@@ -32,77 +32,6 @@ describe Note do
     it { is_expected.to validate_presence_of(:project) }
   end
 
-  describe '#votable?' do
-    it 'is true for issue notes' do
-      note = build(:note_on_issue)
-      expect(note).to be_votable
-    end
-
-    it 'is true for merge request notes' do
-      note = build(:note_on_merge_request)
-      expect(note).to be_votable
-    end
-
-    it 'is false for merge request diff notes' do
-      note = build(:note_on_merge_request_diff)
-      expect(note).not_to be_votable
-    end
-
-    it 'is false for commit notes' do
-      note = build(:note_on_commit)
-      expect(note).not_to be_votable
-    end
-
-    it 'is false for commit diff notes' do
-      note = build(:note_on_commit_diff)
-      expect(note).not_to be_votable
-    end
-  end
-
-  describe 'voting score' do
-    it 'recognizes a neutral note' do
-      note = build(:votable_note, note: 'This is not a +1 note')
-      expect(note).not_to be_upvote
-      expect(note).not_to be_downvote
-    end
-
-    it 'recognizes a neutral emoji note' do
-      note = build(:votable_note, note: "I would :+1: this, but I don't want to")
-      expect(note).not_to be_upvote
-      expect(note).not_to be_downvote
-    end
-
-    it 'recognizes a +1 note' do
-      note = build(:votable_note, note: '+1 for this')
-      expect(note).to be_upvote
-    end
-
-    it 'recognizes a +1 emoji as a vote' do
-      note = build(:votable_note, note: ':+1: for this')
-      expect(note).to be_upvote
-    end
-
-    it 'recognizes a thumbsup emoji as a vote' do
-      note = build(:votable_note, note: ':thumbsup: for this')
-      expect(note).to be_upvote
-    end
-
-    it 'recognizes a -1 note' do
-      note = build(:votable_note, note: '-1 for this')
-      expect(note).to be_downvote
-    end
-
-    it 'recognizes a -1 emoji as a vote' do
-      note = build(:votable_note, note: ':-1: for this')
-      expect(note).to be_downvote
-    end
-
-    it 'recognizes a thumbsdown emoji as a vote' do
-      note = build(:votable_note, note: ':thumbsdown: for this')
-      expect(note).to be_downvote
-    end
-  end
-
   describe "Commit notes" do
     let!(:note) { create(:note_on_commit, note: "+1 from me") }
     let!(:commit) { note.noteable }
@@ -139,10 +68,6 @@ describe Note do
     it "should be recognized by #for_commit_diff_line?" do
       expect(note).to be_for_commit_diff_line
     end
-
-    it "should not be votable" do
-      expect(note).not_to be_votable
-    end
   end
 
   describe 'authorization' do
@@ -204,4 +129,16 @@ describe Note do
 
     it { expect(Note.search('wow')).to include(note) }
   end
+
+  describe :grouped_awards do
+    before do
+      create :note, note: "smile", is_award: true
+      create :note, note: "smile", is_award: true
+    end
+
+    it "returns grouped array of notes" do
+      expect(Note.grouped_awards.first.first).to eq("smile")
+      expect(Note.grouped_awards.first.last).to match_array(Note.all)
+    end
+  end
 end

spec/models/project_spec.rb

@@ -345,17 +345,6 @@ describe Project do
       expect(project1.star_count).to eq(0)
       expect(project2.star_count).to eq(0)
     end
-
-    it 'is decremented when an upvoter account is deleted' do
-      user = create :user
-      project = create :project, :public
-      user.toggle_star(project)
-      project.reload
-      expect(project.star_count).to eq(1)
-      user.destroy
-      project.reload
-      expect(project.star_count).to eq(0)
-    end
   end
 
   describe :avatar_type do
@@ -494,4 +483,23 @@ describe Project do
       end
     end
   end
+
+  describe '.visible_to_user' do
+    let!(:project) { create(:project, :private) }
+    let!(:user)    { create(:user) }
+
+    subject { described_class.visible_to_user(user) }
+
+    describe 'when a user has access to a project' do
+      before do
+        project.team.add_user(user, Gitlab::Access::MASTER)
+      end
+
+      it { is_expected.to eq([project]) }
+    end
+
+    describe 'when a user does not have access to any projects' do
+      it { is_expected.to eq([]) }
+    end
+  end
 end

spec/models/user_spec.rb

@@ -720,7 +720,7 @@ describe User do
     end
   end
 
-  describe "#contributed_projects_ids" do
+  describe "#contributed_projects" do
     subject { create(:user) }
     let!(:project1) { create(:project) }
     let!(:project2) { create(:project, forked_from_project: project3) }
@@ -735,15 +735,15 @@ describe User do
     end
 
     it "includes IDs for projects the user has pushed to" do
-      expect(subject.contributed_projects_ids).to include(project1.id)
+      expect(subject.contributed_projects).to include(project1)
     end
 
     it "includes IDs for projects the user has had merge requests merged into" do
-      expect(subject.contributed_projects_ids).to include(project3.id)
+      expect(subject.contributed_projects).to include(project3)
     end
 
     it "doesn't include IDs for unrelated projects" do
-      expect(subject.contributed_projects_ids).not_to include(project2.id)
+      expect(subject.contributed_projects).not_to include(project2)
     end
   end
 
@@ -792,4 +792,30 @@ describe User do
       expect(subject.recent_push).to eq(nil)
     end
   end
+
+  describe '#authorized_groups' do
+    let!(:user) { create(:user) }
+    let!(:private_group) { create(:group) }
+
+    before do
+      private_group.add_user(user, Gitlab::Access::MASTER)
+    end
+
+    subject { user.authorized_groups }
+
+    it { is_expected.to eq([private_group]) }
+  end
+
+  describe '#authorized_projects' do
+    let!(:user) { create(:user) }
+    let!(:private_project) { create(:project, :private) }
+
+    before do
+      private_project.team << [user, Gitlab::Access::MASTER]
+    end
+
+    subject { user.authorized_projects }
+
+    it { is_expected.to eq([private_project]) }
+  end
 end

spec/services/ci/create_commit_service_spec.rb

@@ -53,7 +53,7 @@ module Ci
         end
       end
 
-      it 'fails commits without .gitlab-ci.yml' do
+      it 'skips commits without .gitlab-ci.yml' do
         stub_ci_commit_yaml_file(nil)
         result = service.execute(project, user,
                                  ref: 'refs/heads/0_1',
@@ -63,7 +63,24 @@ module Ci
         )
         expect(result).to be_persisted
         expect(result.builds.any?).to be_falsey
-        expect(result.status).to eq('failed')
+        expect(result.status).to eq('skipped')
+        expect(result.yaml_errors).to be_nil
+      end
+
+      it 'skips commits if yaml is invalid' do
+        message = 'message'
+        allow_any_instance_of(Ci::Commit).to receive(:git_commit_message) { message }
+        stub_ci_commit_yaml_file('invalid: file: file')
+        commits = [{ message: message }]
+        commit = service.execute(project, user,
+                                 ref: 'refs/tags/0_1',
+                                 before: '00000000',
+                                 after: '31das312',
+                                 commits: commits
+        )
+        expect(commit.builds.any?).to be false
+        expect(commit.status).to eq('failed')
+        expect(commit.yaml_errors).to_not be_nil
       end
 
       describe :ci_skip? do
@@ -100,7 +117,7 @@ module Ci
         end
 
         it "skips builds creation if there is [ci skip] tag in commit message and yaml is invalid" do
-          stub_ci_commit_yaml_file('invalid: file')
+          stub_ci_commit_yaml_file('invalid: file: fiile')
           commits = [{ message: message }]
           commit = service.execute(project, user,
                                    ref: 'refs/tags/0_1',
@@ -110,6 +127,7 @@ module Ci
           )
           expect(commit.builds.any?).to be false
           expect(commit.status).to eq("skipped")
+          expect(commit.yaml_errors).to be_nil
         end
       end
 

spec/services/notes/create_service_spec.rb

@@ -24,4 +24,38 @@ describe Notes::CreateService do
       it { expect(@note.note).to eq('Awesome comment') }
     end
   end
+
+  describe "award emoji" do
+    before do
+      project.team << [user, :master]
+    end
+
+    it "creates emoji note" do
+      opts = {
+        note: ':smile: ',
+        noteable_type: 'Issue',
+        noteable_id: issue.id
+      }
+
+      @note = Notes::CreateService.new(project, user, opts).execute
+
+      expect(@note).to be_valid
+      expect(@note.note).to eq('smile')
+      expect(@note.is_award).to be_truthy
+    end
+
+    it "creates regular note if emoji name is invalid" do
+      opts = {
+        note: ':smile: moretext: ',
+        noteable_type: 'Issue',
+        noteable_id: issue.id
+      }
+
+      @note = Notes::CreateService.new(project, user, opts).execute
+
+      expect(@note).to be_valid
+      expect(@note.note).to eq(opts[:note])
+      expect(@note.is_award).to be_falsy
+    end
+  end
 end

spec/tasks/gitlab/backup_rake_spec.rb

@@ -16,7 +16,7 @@ describe 'gitlab:app namespace rake task' do
   end
 
   def reenable_backup_sub_tasks
-    %w{db repo uploads builds artifacts}.each do |subtask|
+    %w{db repo uploads builds artifacts lfs}.each do |subtask|
       Rake::Task["gitlab:backup:#{subtask}:create"].reenable
     end
   end
@@ -49,7 +49,7 @@ describe 'gitlab:app namespace rake task' do
           to raise_error(SystemExit)
       end
 
-      it 'should invoke restoration on mach' do
+      it 'should invoke restoration on match' do
         allow(YAML).to receive(:load_file).
           and_return({ gitlab_version: gitlab_version })
         expect(Rake::Task["gitlab:backup:db:restore"]).to receive(:invoke)
@@ -57,6 +57,7 @@ describe 'gitlab:app namespace rake task' do
         expect(Rake::Task["gitlab:backup:builds:restore"]).to receive(:invoke)
         expect(Rake::Task["gitlab:backup:uploads:restore"]).to receive(:invoke)
         expect(Rake::Task["gitlab:backup:artifacts:restore"]).to receive(:invoke)
+        expect(Rake::Task["gitlab:backup:lfs:restore"]).to receive(:invoke)
         expect(Rake::Task["gitlab:shell:setup"]).to receive(:invoke)
         expect { run_rake_task('gitlab:backup:restore') }.not_to raise_error
       end
@@ -114,7 +115,7 @@ describe 'gitlab:app namespace rake task' do
 
     it 'should set correct permissions on the tar contents' do
       tar_contents, exit_status = Gitlab::Popen.popen(
-        %W{tar -tvf #{@backup_tar} db uploads.tar.gz repositories builds.tar.gz artifacts.tar.gz}
+        %W{tar -tvf #{@backup_tar} db uploads.tar.gz repositories builds.tar.gz artifacts.tar.gz lfs.tar.gz}
       )
       expect(exit_status).to eq(0)
       expect(tar_contents).to match('db/')
@@ -122,12 +123,13 @@ describe 'gitlab:app namespace rake task' do
       expect(tar_contents).to match('repositories/')
       expect(tar_contents).to match('builds.tar.gz')
       expect(tar_contents).to match('artifacts.tar.gz')
+      expect(tar_contents).to match('lfs.tar.gz')
       expect(tar_contents).not_to match(/^.{4,9}[rwx].* (database.sql.gz|uploads.tar.gz|repositories|builds.tar.gz|artifacts.tar.gz)\/$/)
     end
 
     it 'should delete temp directories' do
       temp_dirs = Dir.glob(
-        File.join(Gitlab.config.backup.path, '{db,repositories,uploads,builds,artifacts}')
+        File.join(Gitlab.config.backup.path, '{db,repositories,uploads,builds,artifacts,lfs}')
       )
 
       expect(temp_dirs).to be_empty
@@ -163,13 +165,14 @@ describe 'gitlab:app namespace rake task' do
 
     it "does not contain skipped item" do
       tar_contents, _exit_status = Gitlab::Popen.popen(
-        %W{tar -tvf #{@backup_tar} db uploads.tar.gz repositories builds.tar.gz artifacts.tar.gz}
+        %W{tar -tvf #{@backup_tar} db uploads.tar.gz repositories builds.tar.gz artifacts.tar.gz lfs.tar.gz}
       )
 
       expect(tar_contents).to match('db/')
       expect(tar_contents).to match('uploads.tar.gz')
       expect(tar_contents).to match('builds.tar.gz')
       expect(tar_contents).to match('artifacts.tar.gz')
+      expect(tar_contents).to match('lfs.tar.gz')
       expect(tar_contents).not_to match('repositories/')
     end
 
@@ -183,6 +186,7 @@ describe 'gitlab:app namespace rake task' do
       expect(Rake::Task["gitlab:backup:uploads:restore"]).not_to receive :invoke
       expect(Rake::Task["gitlab:backup:builds:restore"]).to receive :invoke
       expect(Rake::Task["gitlab:backup:artifacts:restore"]).to receive :invoke
+      expect(Rake::Task["gitlab:backup:lfs:restore"]).to receive :invoke
       expect(Rake::Task["gitlab:shell:setup"]).to receive :invoke
       expect { run_rake_task('gitlab:backup:restore') }.not_to raise_error
     end