Merge branch 'refactoring/context_into_services' into 'master'

Refactoring context Into services To prevent confusion where to write logic. Context or Service?

Merge branch 'refactoring/context_into_services' into 'master'
Refactoring context Into services To prevent confusion where to write logic. Context or Service?
Dmitriy Zaporozhets
2 parents 7527408a 4d82e9ed
Showing 50 changed files with 985 additions and 985 deletions Show diff stats
app/contexts/base_context.rb
app/contexts/files/base_context.rb
app/contexts/files/create_context.rb
app/contexts/files/delete_context.rb
app/contexts/files/update_context.rb
app/contexts/issues/bulk_update_context.rb
app/contexts/notes/create_context.rb
app/contexts/notes/load_context.rb
app/contexts/projects/create_context.rb
app/contexts/projects/fork_context.rb
app/contexts/projects/transfer_context.rb
app/contexts/projects/update_context.rb
app/contexts/search/global_context.rb
app/contexts/search/project_context.rb
app/controllers/admin/projects_controller.rb
app/controllers/projects/blob_controller.rb
app/controllers/projects/edit_tree_controller.rb
app/controllers/projects/issues_controller.rb
app/controllers/projects/new_tree_controller.rb
app/controllers/projects/notes_controller.rb
@@ -1,19 +0,0 @@
-class BaseContext
-  attr_accessor :project, :current_user, :params
-
-  def initialize(project, user, params)
-    @project, @current_user, @params = project, user, params.dup
-  end
-
-  def abilities
-    @abilities ||= begin
-                     abilities = Six.new
-                     abilities << Ability
-                     abilities
-                   end
-  end
-
-  def can?(object, action, subject)
-    abilities.allowed?(object, action, subject)
-  end
-end
@@ -1,31 +0,0 @@
-module Files
-  class BaseContext < ::BaseContext
-    attr_reader :ref, :path
-
-    def initialize(project, user, params, ref, path = nil)
-      @project, @current_user, @params = project, user, params.dup
-      @ref = ref
-      @path = path
-    end
-
-    private
-
-    def error(message)
-      {
-        error: message,
-        status: :error
-      }
-    end
-
-    def success
-      {
-        error: '',
-        status: :success
-      }
-    end
-
-    def repository
-      project.repository
-    end
-  end
-end
@@ -1,47 +0,0 @@
-require_relative "base_context"
-
-module Files
-  class CreateContext < BaseContext
-    def execute
-      allowed = if project.protected_branch?(ref)
-                  can?(current_user, :push_code_to_protected_branches, project)
-                else
-                  can?(current_user, :push_code, project)
-                end
-
-      unless allowed
-        return error("You are not allowed to create file in this branch")
-      end
-
-      unless repository.branch_names.include?(ref)
-        return error("You can only create files if you are on top of a branch")
-      end
-
-      file_name = File.basename(path)
-      file_path = path
-
-      unless file_name =~ Gitlab::Regex.path_regex
-        return error("Your changes could not be committed, because file name contains not allowed characters")
-      end
-
-      blob = repository.blob_at(ref, file_path)
-
-      if blob
-        return error("Your changes could not be committed, because file with such name exists")
-      end
-
-      new_file_action = Gitlab::Satellite::NewFileAction.new(current_user, project, ref, file_path)
-      created_successfully = new_file_action.commit!(
-        params[:content],
-        params[:commit_message],
-        params[:encoding]
-      )
-
-      if created_successfully
-        success
-      else
-        error("Your changes could not be committed, because the file has been changed")
-      end
-    end
-  end
-end
@@ -1,40 +0,0 @@
-require_relative "base_context"
-
-module Files
-  class DeleteContext < BaseContext
-    def execute
-      allowed = if project.protected_branch?(ref)
-                  can?(current_user, :push_code_to_protected_branches, project)
-                else
-                  can?(current_user, :push_code, project)
-                end
-
-      unless allowed
-        return error("You are not allowed to push into this branch")
-      end
-
-      unless repository.branch_names.include?(ref)
-        return error("You can only create files if you are on top of a branch")
-      end
-
-      blob = repository.blob_at(ref, path)
-
-      unless blob
-        return error("You can only edit text files")
-      end
-
-      delete_file_action = Gitlab::Satellite::DeleteFileAction.new(current_user, project, ref, path)
-
-      deleted_successfully = delete_file_action.commit!(
-        nil,
-        params[:commit_message]
-      )
-
-      if deleted_successfully
-        success
-      else
-        error("Your changes could not be committed, because the file has been changed")
-      end
-    end
-  end
-end
@@ -1,40 +0,0 @@
-require_relative "base_context"
-
-module Files
-  class UpdateContext < BaseContext
-    def execute
-      allowed = if project.protected_branch?(ref)
-                  can?(current_user, :push_code_to_protected_branches, project)
-                else
-                  can?(current_user, :push_code, project)
-                end
-
-      unless allowed
-        return error("You are not allowed to push into this branch")
-      end
-
-      unless repository.branch_names.include?(ref)
-        return error("You can only create files if you are on top of a branch")
-      end
-
-      blob = repository.blob_at(ref, path)
-
-      unless blob
-        return error("You can only edit text files")
-      end
-
-      edit_file_action = Gitlab::Satellite::EditFileAction.new(current_user, project, ref, path)
-      created_successfully = edit_file_action.commit!(
-        params[:content],
-        params[:commit_message],
-        params[:encoding]
-      )
-
-      if created_successfully
-        success
-      else
-        error("Your changes could not be committed, because the file has been changed")
-      end
-    end
-  end
-end
@@ -1,39 +0,0 @@
-module Issues
-  class BulkUpdateContext < BaseContext
-    def execute
-      update_data = params[:update]
-
-      issues_ids   = update_data[:issues_ids].split(",")
-      milestone_id = update_data[:milestone_id]
-      assignee_id  = update_data[:assignee_id]
-      status       = update_data[:status]
-
-      new_state = nil
-
-      if status.present?
-        if status == 'closed'
-          new_state = :close
-        else
-          new_state = :reopen
-        end
-      end
-
-      opts = {}
-      opts[:milestone_id] = milestone_id if milestone_id.present?
-      opts[:assignee_id] = assignee_id if assignee_id.present?
-
-      issues = Issue.where(id: issues_ids)
-      issues = issues.select { |issue| can?(current_user, :modify_issue, issue) }
-
-      issues.each do |issue|
-        issue.update_attributes(opts)
-        issue.send new_state if new_state
-      end
-
-      {
-        count: issues.count,
-        success: !issues.count.zero?
-      }
-    end
-  end
-end
@@ -1,10 +0,0 @@
-module Notes
-  class CreateContext < BaseContext
-    def execute
-      note = project.notes.new(params[:note])
-      note.author = current_user
-      note.save
-      note
-    end
-  end
-end
@@ -1,20 +0,0 @@
-module Notes
-  class LoadContext < BaseContext
-    def execute
-      target_type = params[:target_type]
-      target_id   = params[:target_id]
-
-
-      @notes = case target_type
-               when "commit"
-                 project.notes.for_commit_id(target_id).not_inline.fresh
-               when "issue"
-                 project.issues.find(target_id).notes.inc_author.fresh
-               when "merge_request"
-                 project.merge_requests.find(target_id).mr_and_commit_notes.inc_author.fresh
-               when "snippet"
-                 project.snippets.find(target_id).notes.fresh
-               end
-    end
-  end
-end
@@ -1,80 +0,0 @@
-module Projects
-  class CreateContext < BaseContext
-    def initialize(user, params)
-      @current_user, @params = user, params.dup
-    end
-
-    def execute
-      # get namespace id
-      namespace_id = params.delete(:namespace_id)
-
-      # check that user is allowed to set specified visibility_level
-      unless Gitlab::VisibilityLevel.allowed_for?(current_user, params[:visibility_level])
-        params.delete(:visibility_level)
-      end
-
-      # Load default feature settings
-      default_features = Gitlab.config.gitlab.default_projects_features
-
-      default_opts = {
-        issues_enabled: default_features.issues,
-        wiki_enabled: default_features.wiki,
-        wall_enabled: default_features.wall,
-        snippets_enabled: default_features.snippets,
-        merge_requests_enabled: default_features.merge_requests,
-        visibility_level: default_features.visibility_level
-      }.stringify_keys
-
-      @project = Project.new(default_opts.merge(params))
-
-      # Parametrize path for project
-      #
-      # Ex.
-      #  'GitLab HQ'.parameterize => "gitlab-hq"
-      #
-      @project.path = @project.name.dup.parameterize unless @project.path.present?
-
-
-      if namespace_id
-        # Find matching namespace and check if it allowed
-        # for current user if namespace_id passed.
-        if allowed_namespace?(current_user, namespace_id)
-          @project.namespace_id = namespace_id
-        else
-          deny_namespace
-          return @project
-        end
-      else
-        # Set current user namespace if namespace_id is nil
-        @project.namespace_id = current_user.namespace_id
-      end
-
-      @project.creator = current_user
-
-      if @project.save
-        unless @project.group
-          @project.users_projects.create(
-            project_access: UsersProject::MASTER,
-            user: current_user
-          )
-        end
-      end
-
-      @project
-    rescue => ex
-      @project.errors.add(:base, "Can't save project. Please try again later")
-      @project
-    end
-
-    protected
-
-    def deny_namespace
-      @project.errors.add(:namespace, "is not valid")
-    end
-
-    def allowed_namespace?(user, namespace_id)
-      namespace = Namespace.find_by_id(namespace_id)
-      current_user.can?(:manage_namespace, namespace)
-    end
-  end
-end
@@ -1,44 +0,0 @@
-module Projects
-  class ForkContext < BaseContext
-    include Gitlab::ShellAdapter
-
-    def initialize(project, user)
-      @from_project, @current_user = project, user
-    end
-
-    def execute
-      project = @from_project.dup
-      project.name = @from_project.name
-      project.path = @from_project.path
-      project.namespace = current_user.namespace
-      project.creator = current_user
-
-      # If the project cannot save, we do not want to trigger the project destroy
-      # as this can have the side effect of deleting a repo attached to an existing
-      # project with the same name and namespace
-      if project.valid?
-        begin
-          Project.transaction do
-            #First save the DB entries as they can be rolled back if the repo fork fails
-            project.build_forked_project_link(forked_to_project_id: project.id, forked_from_project_id: @from_project.id)
-            if project.save
-              project.users_projects.create(project_access: UsersProject::MASTER, user: current_user)
-            end
-            #Now fork the repo
-            unless gitlab_shell.fork_repository(@from_project.path_with_namespace, project.namespace.path)
-              raise "forking failed in gitlab-shell"
-            end
-            project.ensure_satellite_exists
-          end
-        rescue => ex
-          project.errors.add(:base, "Fork transaction failed.")
-          project.destroy
-        end
-      else
-        project.errors.add(:base, "Invalid fork destination")
-      end
-      project
-
-    end
-  end
-end
@@ -1,22 +0,0 @@
-module Projects
-  class TransferContext < BaseContext
-    def execute(role = :default)
-      namespace_id = params[:project].delete(:namespace_id)
-      allowed_transfer = can?(current_user, :change_namespace, project) || role == :admin
-
-      if allowed_transfer && namespace_id.present?
-        if namespace_id.to_i != project.namespace_id
-          # Transfer to someone namespace
-          namespace = Namespace.find(namespace_id)
-          project.transfer(namespace)
-        end
-      end
-
-    rescue ProjectTransferService::TransferError => ex
-      project.reload
-      project.errors.add(:namespace_id, ex.message)
-      false
-    end
-  end
-end
-
@@ -1,19 +0,0 @@
-module Projects
-  class UpdateContext < BaseContext
-    def execute(role = :default)
-      params[:project].delete(:namespace_id)
-      # check that user is allowed to set specified visibility_level
-      unless can?(current_user, :change_visibility_level, project) && Gitlab::VisibilityLevel.allowed_for?(current_user, params[:project][:visibility_level])
-        params[:project].delete(:visibility_level)
-      end
-
-      new_branch = params[:project].delete(:default_branch)
-
-      if project.repository.exists? && new_branch && new_branch != project.default_branch
-        project.change_head(new_branch)
-      end
-
-      project.update_attributes(params[:project], as: role)
-    end
-  end
-end
@@ -1,40 +0,0 @@
-module Search
-  class GlobalContext
-    attr_accessor :current_user, :params
-
-    def initialize(user, params)
-      @current_user, @params = user, params.dup
-    end
-
-    def execute
-      query = params[:search]
-      query = Shellwords.shellescape(query) if query.present?
-      return result unless query.present?
-
-      authorized_projects_ids = []
-      authorized_projects_ids += current_user.authorized_projects.pluck(:id) if current_user
-      authorized_projects_ids += Project.public_or_internal_only(current_user).pluck(:id)
-
-      group = Group.find_by_id(params[:group_id]) if params[:group_id].present?
-      projects = Project.where(id: authorized_projects_ids)
-      projects = projects.where(namespace_id: group.id) if group
-      projects = projects.search(query)
-      project_ids = projects.pluck(:id)
-
-      result[:projects] = projects.limit(20)
-      result[:merge_requests] = MergeRequest.in_projects(project_ids).search(query).order('updated_at DESC').limit(20)
-      result[:issues] = Issue.where(project_id: project_ids).search(query).order('updated_at DESC').limit(20)
-      result[:total_results] = %w(projects issues merge_requests).sum { |items| result[items.to_sym].size }
-      result
-    end
-
-    def result
-      @result ||= {
-        projects: [],
-        merge_requests: [],
-        issues: [],
-        total_results: 0,
-      }
-    end
-  end
-end
@@ -1,37 +0,0 @@
-module Search
-  class ProjectContext
-    attr_accessor :project, :current_user, :params
-
-    def initialize(project, user, params)
-      @project, @current_user, @params = project, user, params.dup
-    end
-
-    def execute
-      query = params[:search]
-      query = Shellwords.shellescape(query) if query.present?
-      return result unless query.present?
-
-      if params[:search_code].present?
-        blobs = project.repository.search_files(query, params[:repository_ref]) unless project.empty_repo?
-        blobs = Kaminari.paginate_array(blobs).page(params[:page]).per(20)
-        result[:blobs] = blobs
-        result[:total_results] = blobs.total_count
-      else
-        result[:merge_requests] = project.merge_requests.search(query).order('updated_at DESC').limit(20)
-        result[:issues] = project.issues.search(query).order('updated_at DESC').limit(20)
-        result[:total_results] = %w(issues merge_requests).sum { |items| result[items.to_sym].size }
-      end
-
-      result
-    end
-
-    def result
-      @result ||= {
-        merge_requests: [],
-        issues: [],
-        blobs: [],
-        total_results: 0,
-      }
-    end
-  end
-end
@@ -19,7 +19,7 @@ class Admin::ProjectsController &lt; Admin::ApplicationController
   end
  
   def transfer
-    result = ::Projects::TransferContext.new(@project, current_user, project: params).execute(:admin)
+    result = ::Projects::TransferService.new(@project, current_user, project: params).execute(:admin)
  
     if result
       redirect_to [:admin, @project]
@@ -13,7 +13,7 @@ class Projects::BlobController &lt; Projects::ApplicationController
   end
  
   def destroy
-    result = Files::DeleteContext.new(@project, current_user, params, @ref, @path).execute
+    result = Files::DeleteService.new(@project, current_user, params, @ref, @path).execute
  
     if result[:status] == :success
       flash[:notice] = "Your changes have been successfully committed"
@@ -7,7 +7,7 @@ class Projects::EditTreeController &lt; Projects::BaseTreeController
   end
  
   def update
-    result = Files::UpdateContext.new(@project, current_user, params, @ref, @path).execute
+    result = Files::UpdateService.new(@project, current_user, params, @ref, @path).execute
  
     if result[:status] == :success
       flash[:notice] = "Your changes have been successfully committed"
@@ -89,7 +89,7 @@ class Projects::IssuesController &lt; Projects::ApplicationController
   end
  
   def bulk_update
-    result = Issues::BulkUpdateContext.new(project, current_user, params).execute
+    result = Issues::BulkUpdateService.new(project, current_user, params).execute
     redirect_to :back, notice: "#{result[:count]} issues updated"
   end
  
@@ -6,7 +6,7 @@ class Projects::NewTreeController &lt; Projects::BaseTreeController
  
   def update
     file_path = File.join(@path, File.basename(params[:file_name]))
-    result = Files::CreateContext.new(@project, current_user, params, @ref, file_path).execute
+    result = Files::CreateService.new(@project, current_user, params, @ref, file_path).execute
  
     if result[:status] == :success
       flash[:notice] = "Your changes have been successfully committed"
@@ -5,7 +5,7 @@ class Projects::NotesController &lt; Projects::ApplicationController
   before_filter :authorize_admin_note!, only: [:update, :destroy]
  
   def index
-    @notes = Notes::LoadContext.new(project, current_user, params).execute
+    @notes = Notes::LoadService.new(project, current_user, params).execute
  
     notes_json = { notes: [] }
  
@@ -20,7 +20,7 @@ class Projects::NotesController &lt; Projects::ApplicationController
   end
  
   def create
-    @note = Notes::CreateContext.new(project, current_user, params).execute
+    @note = Notes::CreateService.new(project, current_user, params).execute
  
     respond_to do |format|
       format.json { render_note_json(@note) }
@@ -20,7 +20,7 @@ class ProjectsController &lt; ApplicationController
   end
  
   def create
-    @project = ::Projects::CreateContext.new(current_user, params[:project]).execute
+    @project = ::Projects::CreateService.new(current_user, params[:project]).execute
  
     respond_to do |format|
       flash[:notice] = 'Project was successfully created.' if @project.saved?
@@ -36,7 +36,7 @@ class ProjectsController &lt; ApplicationController
   end
  
   def update
-    status = ::Projects::UpdateContext.new(@project, current_user, params).execute
+    status = ::Projects::UpdateService.new(@project, current_user, params).execute
  
     respond_to do |format|
       if status
@@ -51,7 +51,7 @@ class ProjectsController &lt; ApplicationController
   end
  
   def transfer
-    ::Projects::TransferContext.new(project, current_user, params).execute
+    ::Projects::TransferService.new(project, current_user, params).execute
   end
  
   def show
@@ -89,7 +89,7 @@ class ProjectsController &lt; ApplicationController
   end
  
   def fork
-    @forked_project = ::Projects::ForkContext.new(project, current_user).execute
+    @forked_project = ::Projects::ForkService.new(project, current_user).execute
  
     respond_to do |format|
       format.html do
@@ -5,9 +5,9 @@ class SearchController &lt; ApplicationController
  
     if @project
       return access_denied! unless can?(current_user, :download_code, @project)
-      @search_results = Search::ProjectContext.new(@project, current_user, params).execute
+      @search_results = Search::ProjectService.new(@project, current_user, params).execute
     else
-      @search_results = Search::GlobalContext.new(current_user, params).execute
+      @search_results = Search::GlobalService.new(current_user, params).execute
     end
   end
 end
@@ -0,0 +1,19 @@
+class BaseService
+  attr_accessor :project, :current_user, :params
+
+  def initialize(project, user, params)
+    @project, @current_user, @params = project, user, params.dup
+  end
+
+  def abilities
+    @abilities ||= begin
+                     abilities = Six.new
+                     abilities << Ability
+                     abilities
+                   end
+  end
+
+  def can?(object, action, subject)
+    abilities.allowed?(object, action, subject)
+  end
+end
@@ -0,0 +1,31 @@
+module Files
+  class BaseService < ::BaseService
+    attr_reader :ref, :path
+
+    def initialize(project, user, params, ref, path = nil)
+      @project, @current_user, @params = project, user, params.dup
+      @ref = ref
+      @path = path
+    end
+
+    private
+
+    def error(message)
+      {
+        error: message,
+        status: :error
+      }
+    end
+
+    def success
+      {
+        error: '',
+        status: :success
+      }
+    end
+
+    def repository
+      project.repository
+    end
+  end
+end
@@ -0,0 +1,47 @@
+require_relative "base_service"
+
+module Files
+  class CreateService < BaseService
+    def execute
+      allowed = if project.protected_branch?(ref)
+                  can?(current_user, :push_code_to_protected_branches, project)
+                else
+                  can?(current_user, :push_code, project)
+                end
+
+      unless allowed
+        return error("You are not allowed to create file in this branch")
+      end
+
+      unless repository.branch_names.include?(ref)
+        return error("You can only create files if you are on top of a branch")
+      end
+
+      file_name = File.basename(path)
+      file_path = path
+
+      unless file_name =~ Gitlab::Regex.path_regex
+        return error("Your changes could not be committed, because file name contains not allowed characters")
+      end
+
+      blob = repository.blob_at(ref, file_path)
+
+      if blob
+        return error("Your changes could not be committed, because file with such name exists")
+      end
+
+      new_file_action = Gitlab::Satellite::NewFileAction.new(current_user, project, ref, file_path)
+      created_successfully = new_file_action.commit!(
+        params[:content],
+        params[:commit_message],
+        params[:encoding]
+      )
+
+      if created_successfully
+        success
+      else
+        error("Your changes could not be committed, because the file has been changed")
+      end
+    end
+  end
+end
@@ -0,0 +1,40 @@
+require_relative "base_service"
+
+module Files
+  class DeleteService < BaseService
+    def execute
+      allowed = if project.protected_branch?(ref)
+                  can?(current_user, :push_code_to_protected_branches, project)
+                else
+                  can?(current_user, :push_code, project)
+                end
+
+      unless allowed
+        return error("You are not allowed to push into this branch")
+      end
+
+      unless repository.branch_names.include?(ref)
+        return error("You can only create files if you are on top of a branch")
+      end
+
+      blob = repository.blob_at(ref, path)
+
+      unless blob
+        return error("You can only edit text files")
+      end
+
+      delete_file_action = Gitlab::Satellite::DeleteFileAction.new(current_user, project, ref, path)
+
+      deleted_successfully = delete_file_action.commit!(
+        nil,
+        params[:commit_message]
+      )
+
+      if deleted_successfully
+        success
+      else
+        error("Your changes could not be committed, because the file has been changed")
+      end
+    end
+  end
+end
@@ -0,0 +1,40 @@
+require_relative "base_service"
+
+module Files
+  class UpdateService < BaseService
+    def execute
+      allowed = if project.protected_branch?(ref)
+                  can?(current_user, :push_code_to_protected_branches, project)
+                else
+                  can?(current_user, :push_code, project)
+                end
+
+      unless allowed
+        return error("You are not allowed to push into this branch")
+      end
+
+      unless repository.branch_names.include?(ref)
+        return error("You can only create files if you are on top of a branch")
+      end
+
+      blob = repository.blob_at(ref, path)
+
+      unless blob
+        return error("You can only edit text files")
+      end
+
+      edit_file_action = Gitlab::Satellite::EditFileAction.new(current_user, project, ref, path)
+      created_successfully = edit_file_action.commit!(
+        params[:content],
+        params[:commit_message],
+        params[:encoding]
+      )
+
+      if created_successfully
+        success
+      else
+        error("Your changes could not be committed, because the file has been changed")
+      end
+    end
+  end
+end
@@ -0,0 +1,39 @@
+module Issues
+  class BulkUpdateService < BaseService
+    def execute
+      update_data = params[:update]
+
+      issues_ids   = update_data[:issues_ids].split(",")
+      milestone_id = update_data[:milestone_id]
+      assignee_id  = update_data[:assignee_id]
+      status       = update_data[:status]
+
+      new_state = nil
+
+      if status.present?
+        if status == 'closed'
+          new_state = :close
+        else
+          new_state = :reopen
+        end
+      end
+
+      opts = {}
+      opts[:milestone_id] = milestone_id if milestone_id.present?
+      opts[:assignee_id] = assignee_id if assignee_id.present?
+
+      issues = Issue.where(id: issues_ids)
+      issues = issues.select { |issue| can?(current_user, :modify_issue, issue) }
+
+      issues.each do |issue|
+        issue.update_attributes(opts)
+        issue.send new_state if new_state
+      end
+
+      {
+        count: issues.count,
+        success: !issues.count.zero?
+      }
+    end
+  end
+end
@@ -0,0 +1,10 @@
+module Notes
+  class CreateService < BaseService
+    def execute
+      note = project.notes.new(params[:note])
+      note.author = current_user
+      note.save
+      note
+    end
+  end
+end
@@ -0,0 +1,20 @@
+module Notes
+  class LoadService < BaseService
+    def execute
+      target_type = params[:target_type]
+      target_id   = params[:target_id]
+
+
+      @notes = case target_type
+               when "commit"
+                 project.notes.for_commit_id(target_id).not_inline.fresh
+               when "issue"
+                 project.issues.find(target_id).notes.inc_author.fresh
+               when "merge_request"
+                 project.merge_requests.find(target_id).mr_and_commit_notes.inc_author.fresh
+               when "snippet"
+                 project.snippets.find(target_id).notes.fresh
+               end
+    end
+  end
+end
@@ -0,0 +1,80 @@
+module Projects
+  class CreateService < BaseService
+    def initialize(user, params)
+      @current_user, @params = user, params.dup
+    end
+
+    def execute
+      # get namespace id
+      namespace_id = params.delete(:namespace_id)
+
+      # check that user is allowed to set specified visibility_level
+      unless Gitlab::VisibilityLevel.allowed_for?(current_user, params[:visibility_level])
+        params.delete(:visibility_level)
+      end
+
+      # Load default feature settings
+      default_features = Gitlab.config.gitlab.default_projects_features
+
+      default_opts = {
+        issues_enabled: default_features.issues,
+        wiki_enabled: default_features.wiki,
+        wall_enabled: default_features.wall,
+        snippets_enabled: default_features.snippets,
+        merge_requests_enabled: default_features.merge_requests,
+        visibility_level: default_features.visibility_level
+      }.stringify_keys
+
+      @project = Project.new(default_opts.merge(params))
+
+      # Parametrize path for project
+      #
+      # Ex.
+      #  'GitLab HQ'.parameterize => "gitlab-hq"
+      #
+      @project.path = @project.name.dup.parameterize unless @project.path.present?
+
+
+      if namespace_id
+        # Find matching namespace and check if it allowed
+        # for current user if namespace_id passed.
+        if allowed_namespace?(current_user, namespace_id)
+          @project.namespace_id = namespace_id
+        else
+          deny_namespace
+          return @project
+        end
+      else
+        # Set current user namespace if namespace_id is nil
+        @project.namespace_id = current_user.namespace_id
+      end
+
+      @project.creator = current_user
+
+      if @project.save
+        unless @project.group
+          @project.users_projects.create(
+            project_access: UsersProject::MASTER,
+            user: current_user
+          )
+        end
+      end
+
+      @project
+    rescue => ex
+      @project.errors.add(:base, "Can't save project. Please try again later")
+      @project
+    end
+
+    protected
+
+    def deny_namespace
+      @project.errors.add(:namespace, "is not valid")
+    end
+
+    def allowed_namespace?(user, namespace_id)
+      namespace = Namespace.find_by_id(namespace_id)
+      current_user.can?(:manage_namespace, namespace)
+    end
+  end
+end
@@ -0,0 +1,44 @@
+module Projects
+  class ForkService < BaseService
+    include Gitlab::ShellAdapter
+
+    def initialize(project, user)
+      @from_project, @current_user = project, user
+    end
+
+    def execute
+      project = @from_project.dup
+      project.name = @from_project.name
+      project.path = @from_project.path
+      project.namespace = current_user.namespace
+      project.creator = current_user
+
+      # If the project cannot save, we do not want to trigger the project destroy
+      # as this can have the side effect of deleting a repo attached to an existing
+      # project with the same name and namespace
+      if project.valid?
+        begin
+          Project.transaction do
+            #First save the DB entries as they can be rolled back if the repo fork fails
+            project.build_forked_project_link(forked_to_project_id: project.id, forked_from_project_id: @from_project.id)
+            if project.save
+              project.users_projects.create(project_access: UsersProject::MASTER, user: current_user)
+            end
+            #Now fork the repo
+            unless gitlab_shell.fork_repository(@from_project.path_with_namespace, project.namespace.path)
+              raise "forking failed in gitlab-shell"
+            end
+            project.ensure_satellite_exists
+          end
+        rescue => ex
+          project.errors.add(:base, "Fork transaction failed.")
+          project.destroy
+        end
+      else
+        project.errors.add(:base, "Invalid fork destination")
+      end
+      project
+
+    end
+  end
+end
@@ -0,0 +1,22 @@
+module Projects
+  class TransferService < BaseService
+    def execute(role = :default)
+      namespace_id = params[:project].delete(:namespace_id)
+      allowed_transfer = can?(current_user, :change_namespace, project) || role == :admin
+
+      if allowed_transfer && namespace_id.present?
+        if namespace_id.to_i != project.namespace_id
+          # Transfer to someone namespace
+          namespace = Namespace.find(namespace_id)
+          project.transfer(namespace)
+        end
+      end
+
+    rescue ProjectTransferService::TransferError => ex
+      project.reload
+      project.errors.add(:namespace_id, ex.message)
+      false
+    end
+  end
+end
+
@@ -0,0 +1,19 @@
+module Projects
+  class UpdateService < BaseService
+    def execute(role = :default)
+      params[:project].delete(:namespace_id)
+      # check that user is allowed to set specified visibility_level
+      unless can?(current_user, :change_visibility_level, project) && Gitlab::VisibilityLevel.allowed_for?(current_user, params[:project][:visibility_level])
+        params[:project].delete(:visibility_level)
+      end
+
+      new_branch = params[:project].delete(:default_branch)
+
+      if project.repository.exists? && new_branch && new_branch != project.default_branch
+        project.change_head(new_branch)
+      end
+
+      project.update_attributes(params[:project], as: role)
+    end
+  end
+end
@@ -0,0 +1,40 @@
+module Search
+  class GlobalService
+    attr_accessor :current_user, :params
+
+    def initialize(user, params)
+      @current_user, @params = user, params.dup
+    end
+
+    def execute
+      query = params[:search]
+      query = Shellwords.shellescape(query) if query.present?
+      return result unless query.present?
+
+      authorized_projects_ids = []
+      authorized_projects_ids += current_user.authorized_projects.pluck(:id) if current_user
+      authorized_projects_ids += Project.public_or_internal_only(current_user).pluck(:id)
+
+      group = Group.find_by_id(params[:group_id]) if params[:group_id].present?
+      projects = Project.where(id: authorized_projects_ids)
+      projects = projects.where(namespace_id: group.id) if group
+      projects = projects.search(query)
+      project_ids = projects.pluck(:id)
+
+      result[:projects] = projects.limit(20)
+      result[:merge_requests] = MergeRequest.in_projects(project_ids).search(query).order('updated_at DESC').limit(20)
+      result[:issues] = Issue.where(project_id: project_ids).search(query).order('updated_at DESC').limit(20)
+      result[:total_results] = %w(projects issues merge_requests).sum { |items| result[items.to_sym].size }
+      result
+    end
+
+    def result
+      @result ||= {
+        projects: [],
+        merge_requests: [],
+        issues: [],
+        total_results: 0,
+      }
+    end
+  end
+end
@@ -0,0 +1,37 @@
+module Search
+  class ProjectService
+    attr_accessor :project, :current_user, :params
+
+    def initialize(project, user, params)
+      @project, @current_user, @params = project, user, params.dup
+    end
+
+    def execute
+      query = params[:search]
+      query = Shellwords.shellescape(query) if query.present?
+      return result unless query.present?
+
+      if params[:search_code].present?
+        blobs = project.repository.search_files(query, params[:repository_ref]) unless project.empty_repo?
+        blobs = Kaminari.paginate_array(blobs).page(params[:page]).per(20)
+        result[:blobs] = blobs
+        result[:total_results] = blobs.total_count
+      else
+        result[:merge_requests] = project.merge_requests.search(query).order('updated_at DESC').limit(20)
+        result[:issues] = project.issues.search(query).order('updated_at DESC').limit(20)
+        result[:total_results] = %w(issues merge_requests).sum { |items| result[items.to_sym].size }
+      end
+
+      result
+    end
+
+    def result
+      @result ||= {
+        merge_requests: [],
+        issues: [],
+        blobs: [],
+        total_results: 0,
+      }
+    end
+  end
+end
@@ -21,7 +21,7 @@ module API
         attrs = attributes_for_keys [:file_path, :branch_name, :content, :commit_message, :encoding]
         branch_name = attrs.delete(:branch_name)
         file_path = attrs.delete(:file_path)
-        result = ::Files::CreateContext.new(user_project, current_user, attrs, branch_name, file_path).execute
+        result = ::Files::CreateService.new(user_project, current_user, attrs, branch_name, file_path).execute
  
         if result[:status] == :success
           status(201)
@@ -51,7 +51,7 @@ module API
         attrs = attributes_for_keys [:file_path, :branch_name, :content, :commit_message, :encoding]
         branch_name = attrs.delete(:branch_name)
         file_path = attrs.delete(:file_path)
-        result = ::Files::UpdateContext.new(user_project, current_user, attrs, branch_name, file_path).execute
+        result = ::Files::UpdateService.new(user_project, current_user, attrs, branch_name, file_path).execute
  
         if result[:status] == :success
           status(200)
@@ -81,7 +81,7 @@ module API
         attrs = attributes_for_keys [:file_path, :branch_name, :commit_message]
         branch_name = attrs.delete(:branch_name)
         file_path = attrs.delete(:file_path)
-        result = ::Files::DeleteContext.new(user_project, current_user, attrs, branch_name, file_path).execute
+        result = ::Files::DeleteService.new(user_project, current_user, attrs, branch_name, file_path).execute
  
         if result[:status] == :success
           status(200)
@@ -102,7 +102,7 @@ module API
                                      :visibility_level,
                                      :import_url]
         attrs = map_public_to_visibility_level(attrs)
-        @project = ::Projects::CreateContext.new(current_user, attrs).execute
+        @project = ::Projects::CreateService.new(current_user, attrs).execute
         if @project.saved?
           present @project, with: Entities::Project
         else
@@ -143,7 +143,7 @@ module API
                                      :public,
                                      :visibility_level]
         attrs = map_public_to_visibility_level(attrs)
-        @project = ::Projects::CreateContext.new(user, attrs).execute
+        @project = ::Projects::CreateService.new(user, attrs).execute
         if @project.saved?
           present @project, with: Entities::Project
         else
@@ -66,7 +66,7 @@ namespace :gitlab do
             project_params[:namespace_id] = group.id
           end
  
-          project = Projects::CreateContext.new(user, project_params).execute
+          project = Projects::CreateService.new(user, project_params).execute
  
           if project.valid?
             puts " * Created #{project.name} (#{repo_path})".green
@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe Projects::ForkContext do
-  describe :fork_by_user do
-    before do
-      @from_namespace = create(:namespace)
-      @from_user = create(:user, namespace: @from_namespace )
-      @from_project = create(:project, creator_id: @from_user.id, namespace: @from_namespace)
-      @to_namespace = create(:namespace)
-      @to_user = create(:user, namespace: @to_namespace)
-    end
-
-    context 'fork project' do
-
-      it "successfully creates project in the user namespace" do
-        @to_project = fork_project(@from_project, @to_user)
-
-        @to_project.owner.should == @to_user
-        @to_project.namespace.should == @to_user.namespace
-      end
-    end
-
-    context 'fork project failure' do
-
-      it "fails due to transaction failure" do
-        # make the mock gitlab-shell fail
-        @to_project = fork_project(@from_project, @to_user, false)
-
-        @to_project.errors.should_not be_empty
-        @to_project.errors[:base].should include("Fork transaction failed.")
-      end
-
-    end
-
-    context 'project already exists' do
-
-      it "should fail due to validation, not transaction failure" do
-        @existing_project = create(:project, creator_id: @to_user.id, name: @from_project.name, namespace: @to_namespace)
-        @to_project = fork_project(@from_project, @to_user)
-
-        @existing_project.persisted?.should be_true
-        @to_project.errors[:base].should include("Invalid fork destination")
-        @to_project.errors[:base].should_not include("Fork transaction failed.")
-      end
-
-    end
-  end
-
-  def fork_project(from_project, user, fork_success = true)
-    context = Projects::ForkContext.new(from_project, user)
-    shell = double("gitlab_shell")
-    shell.stub(fork_repository: fork_success)
-    context.stub(gitlab_shell: shell)
-    context.execute
-  end
-
-end
@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-describe Issues::BulkUpdateContext do
-  before(:each) { ActiveRecord::Base.observers.enable(:user_observer) }
-  after(:each) { ActiveRecord::Base.observers.disable(:user_observer) }
-
-  let(:issue) {
-    create(:issue, project: @project)
-  } 
-
-  before do
-    @user = create :user
-    opts = {
-      name: "GitLab",
-      namespace: @user.namespace
-    }
-    @project = Projects::CreateContext.new(@user, opts).execute
-  end
-
-  describe :close_issue do
-
-    before do
-      @issues = 5.times.collect do
-        create(:issue, project: @project)
-      end
-      @params = { 
-        update: {
-          status: 'closed',
-          issues_ids: @issues.map(&:id)
-        }
-      }
-    end
-
-    it {
-      result = Issues::BulkUpdateContext.new(@project, @user, @params).execute
-      result[:success].should be_true
-      result[:count].should == @issues.count
-
-      @project.issues.opened.should be_empty
-      @project.issues.closed.should_not be_empty
-    }
-
-  end
-
-  describe :reopen_issues do
-
-    before do
-      @issues = 5.times.collect do
-        create(:closed_issue, project: @project)
-      end
-      @params = { 
-        update: {
-          status: 'reopen',
-          issues_ids: @issues.map(&:id)
-        }
-      }
-    end
-
-    it {
-      result = Issues::BulkUpdateContext.new(@project, @user, @params).execute
-      result[:success].should be_true
-      result[:count].should == @issues.count
-
-      @project.issues.closed.should be_empty
-      @project.issues.opened.should_not be_empty
-    }
-
-  end
-
-  describe :update_assignee do
-
-    before do
-      @new_assignee = create :user
-      @params = { 
-        update: {
-          issues_ids: [issue.id],
-          assignee_id: @new_assignee.id
-        }
-      }
-    end
-
-    it {
-      result = Issues::BulkUpdateContext.new(@project, @user, @params).execute
-      result[:success].should be_true
-      result[:count].should == 1
-
-      @project.issues.first.assignee.should == @new_assignee
-    }
-
-  end
-
-  describe :update_milestone do
-
-    before do
-      @milestone = create :milestone
-      @params = { 
-        update: {
-          issues_ids: [issue.id],
-          milestone_id: @milestone.id
-        }
-      }
-    end
-
-    it {
-      result = Issues::BulkUpdateContext.new(@project, @user, @params).execute
-      result[:success].should be_true
-      result[:count].should == 1
-
-      @project.issues.first.milestone.should == @milestone
-    }
-  end
-
-end
@@ -1,142 +0,0 @@
-require 'spec_helper'
-
-describe Projects::CreateContext do
-  before(:each) { ActiveRecord::Base.observers.enable(:user_observer) }
-  after(:each) { ActiveRecord::Base.observers.disable(:user_observer) }
-
-  describe :create_by_user do
-    before do
-      @user = create :user
-      @admin = create :user, admin: true
-      @opts = {
-        name: "GitLab",
-        namespace: @user.namespace
-      }
-    end
-
-    context 'user namespace' do
-      before do
-        @project = create_project(@user, @opts)
-      end
-
-      it { @project.should be_valid }
-      it { @project.owner.should == @user }
-      it { @project.namespace.should == @user.namespace }
-    end
-
-    context 'group namespace' do
-      before do
-        @group = create :group
-        @group.add_owner(@user)
-
-        @opts.merge!(namespace_id: @group.id)
-        @project = create_project(@user, @opts)
-      end
-
-      it { @project.should be_valid }
-      it { @project.owner.should == @group }
-      it { @project.namespace.should == @group }
-    end
-
-    context 'respect configured visibility setting' do
-      before(:each) do
-        @settings = double("settings")
-        @settings.stub(:issues) { true }
-        @settings.stub(:merge_requests) { true }
-        @settings.stub(:wiki) { true }
-        @settings.stub(:wall) { true }
-        @settings.stub(:snippets) { true }
-        stub_const("Settings", Class.new)
-        @restrictions = double("restrictions")
-        @restrictions.stub(:restricted_visibility_levels) { [] }
-        Settings.stub_chain(:gitlab).and_return(@restrictions)
-        Settings.stub_chain(:gitlab, :default_projects_features).and_return(@settings)
-      end
-
-      context 'should be public when setting is public' do
-        before do
-          @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::PUBLIC }
-          @project = create_project(@user, @opts)
-        end
-
-        it { @project.public?.should be_true }
-      end
-
-      context 'should be private when setting is private' do
-        before do
-          @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::PRIVATE }
-          @project = create_project(@user, @opts)
-        end
-
-        it { @project.private?.should be_true }
-      end
-
-      context 'should be internal when setting is internal' do
-        before do
-          @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::INTERNAL }
-          @project = create_project(@user, @opts)
-        end
-
-        it { @project.internal?.should be_true }
-      end
-    end
-
-    context 'respect configured visibility restrictions setting' do
-      before(:each) do
-        @settings = double("settings")
-        @settings.stub(:issues) { true }
-        @settings.stub(:merge_requests) { true }
-        @settings.stub(:wiki) { true }
-        @settings.stub(:wall) { true }
-        @settings.stub(:snippets) { true }
-        @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::PRIVATE }
-        stub_const("Settings", Class.new)
-        @restrictions = double("restrictions")
-        @restrictions.stub(:restricted_visibility_levels) { [ Gitlab::VisibilityLevel::PUBLIC ] }
-        Settings.stub_chain(:gitlab).and_return(@restrictions)
-        Settings.stub_chain(:gitlab, :default_projects_features).and_return(@settings)
-      end
-
-      context 'should be private when option is public' do
-        before do
-          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
-          @project = create_project(@user, @opts)
-        end
-
-        it { @project.private?.should be_true }
-      end
-
-      context 'should be public when option is public for admin' do
-        before do
-          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
-          @project = create_project(@admin, @opts)
-        end
-
-        it { @project.public?.should be_true }
-      end
-
-      context 'should be private when option is private' do
-        before do
-          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
-          @project = create_project(@user, @opts)
-        end
-
-        it { @project.private?.should be_true }
-      end
-
-      context 'should be internal when option is internal' do
-        before do
-          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
-          @project = create_project(@user, @opts)
-        end
-
-        it { @project.internal?.should be_true }
-      end
-    end
-  end
-
-  def create_project(user, opts)
-    Projects::CreateContext.new(user, opts).execute
-  end
-end
-
@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe Projects::UpdateContext do
-  before(:each) { ActiveRecord::Base.observers.enable(:user_observer) }
-  after(:each) { ActiveRecord::Base.observers.disable(:user_observer) }
-
-  describe :update_by_user do
-    before do
-      @user = create :user
-      @admin = create :user, admin: true
-      @project = create :project, creator_id: @user.id, namespace: @user.namespace
-      @opts = { project: {} }
-    end
-
-    context 'should be private when updated to private' do
-      before do
-       @created_private = @project.private?
-
-        @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
-        update_project(@project, @user, @opts)
-      end
-
-      it { @created_private.should be_true }
-      it { @project.private?.should be_true }
-    end
-
-    context 'should be internal when updated to internal' do
-      before do
-        @created_private = @project.private?
-
-        @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
-        update_project(@project, @user, @opts)
-      end
-
-      it { @created_private.should be_true }
-      it { @project.internal?.should be_true }
-    end
-
-    context 'should be public when updated to public' do
-      before do
-        @created_private = @project.private?
-
-        @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
-        update_project(@project, @user, @opts)
-      end
-
-      it { @created_private.should be_true }
-      it { @project.public?.should be_true }
-    end
-
-    context 'respect configured visibility restrictions setting' do
-      before(:each) do
-        @restrictions = double("restrictions")
-        @restrictions.stub(:restricted_visibility_levels) { [ Gitlab::VisibilityLevel::PUBLIC ] }
-        Settings.stub_chain(:gitlab).and_return(@restrictions)
-      end
-
-      context 'should be private when updated to private' do
-        before do
-          @created_private = @project.private?
-
-          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
-          update_project(@project, @user, @opts)
-        end
-
-        it { @created_private.should be_true }
-        it { @project.private?.should be_true }
-      end
-
-      context 'should be internal when updated to internal' do
-        before do
-          @created_private = @project.private?
-
-          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
-          update_project(@project, @user, @opts)
-        end
-
-        it { @created_private.should be_true }
-        it { @project.internal?.should be_true }
-      end
-
-      context 'should be private when updated to public' do
-        before do
-          @created_private = @project.private?
-
-          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
-          update_project(@project, @user, @opts)
-        end
-
-        it { @created_private.should be_true }
-        it { @project.private?.should be_true }
-      end
-
-      context 'should be public when updated to public by admin' do
-        before do
-          @created_private = @project.private?
-
-          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
-          update_project(@project, @admin, @opts)
-        end
-
-        it { @created_private.should be_true }
-        it { @project.public?.should be_true }
-      end
-    end
-  end
-
-  def update_project(project, user, opts)
-    Projects::UpdateContext.new(project, user, opts).execute
-  end
-end
 \ No newline at end of file
@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe 'Search::GlobalContext' do
-  let(:found_namespace) { create(:namespace, name: 'searchable namespace', path:'another_thing') }
-  let(:user) { create(:user, namespace: found_namespace) }
-  let!(:found_project) { create(:project, name: 'searchable_project', creator_id: user.id, namespace: found_namespace, visibility_level: Gitlab::VisibilityLevel::PRIVATE) }
-
-  let(:unfound_namespace) { create(:namespace, name: 'unfound namespace', path: 'yet_something_else') }
-  let!(:unfound_project) { create(:project, name: 'unfound_project', creator_id: user.id, namespace: unfound_namespace, visibility_level: Gitlab::VisibilityLevel::PRIVATE) }
-
-  let(:internal_namespace) { create(:namespace, path: 'something_internal',name: 'searchable internal namespace') }
-  let(:internal_user) { create(:user, namespace: internal_namespace) }
-  let!(:internal_project) { create(:project, name: 'searchable_internal_project', creator_id: internal_user.id, namespace: internal_namespace, visibility_level: Gitlab::VisibilityLevel::INTERNAL) }
-
-  let(:public_namespace) { create(:namespace, path: 'something_public',name: 'searchable public namespace') }
-  let(:public_user) { create(:user, namespace: public_namespace) }
-  let!(:public_project) { create(:project, name: 'searchable_public_project', creator_id: public_user.id, namespace: public_namespace, visibility_level: Gitlab::VisibilityLevel::PUBLIC) }
-
-  describe '#execute' do
-    context 'unauthenticated' do
-      it 'should return public projects only' do
-        context = Search::GlobalContext.new(nil, search: "searchable")
-        results = context.execute
-        results[:projects].should have(1).items
-        results[:projects].should include(public_project)
-      end
-    end
-
-    context 'authenticated' do
-      it 'should return public, internal and private projects' do
-        context = Search::GlobalContext.new(user, search: "searchable")
-        results = context.execute
-        results[:projects].should have(3).items
-        results[:projects].should include(public_project)
-        results[:projects].should include(found_project)
-        results[:projects].should include(internal_project)
-      end
-
-      it 'should return only public & internal projects' do
-        context = Search::GlobalContext.new(internal_user, search: "searchable")
-        results = context.execute
-        results[:projects].should have(2).items
-        results[:projects].should include(internal_project)
-        results[:projects].should include(public_project)
-      end
-
-      it 'namespace name should be searchable' do
-        context = Search::GlobalContext.new(user, search: "searchable namespace")
-        results = context.execute
-        results[:projects].should == [found_project]
-      end
-    end
-  end
-end
@@ -58,7 +58,7 @@ describe :forked_from_project do
 end
  
 def fork_project(from_project, user)
-  context = Projects::ForkContext.new(from_project, user)
+  context = Projects::ForkService.new(from_project, user)
   shell = double("gitlab_shell")
   shell.stub(fork_repository: true)
   context.stub(gitlab_shell: shell)
@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Projects::ForkService do
+  describe :fork_by_user do
+    before do
+      @from_namespace = create(:namespace)
+      @from_user = create(:user, namespace: @from_namespace )
+      @from_project = create(:project, creator_id: @from_user.id, namespace: @from_namespace)
+      @to_namespace = create(:namespace)
+      @to_user = create(:user, namespace: @to_namespace)
+    end
+
+    context 'fork project' do
+
+      it "successfully creates project in the user namespace" do
+        @to_project = fork_project(@from_project, @to_user)
+
+        @to_project.owner.should == @to_user
+        @to_project.namespace.should == @to_user.namespace
+      end
+    end
+
+    context 'fork project failure' do
+
+      it "fails due to transaction failure" do
+        # make the mock gitlab-shell fail
+        @to_project = fork_project(@from_project, @to_user, false)
+
+        @to_project.errors.should_not be_empty
+        @to_project.errors[:base].should include("Fork transaction failed.")
+      end
+
+    end
+
+    context 'project already exists' do
+
+      it "should fail due to validation, not transaction failure" do
+        @existing_project = create(:project, creator_id: @to_user.id, name: @from_project.name, namespace: @to_namespace)
+        @to_project = fork_project(@from_project, @to_user)
+
+        @existing_project.persisted?.should be_true
+        @to_project.errors[:base].should include("Invalid fork destination")
+        @to_project.errors[:base].should_not include("Fork transaction failed.")
+      end
+
+    end
+  end
+
+  def fork_project(from_project, user, fork_success = true)
+    context = Projects::ForkService.new(from_project, user)
+    shell = double("gitlab_shell")
+    shell.stub(fork_repository: fork_success)
+    context.stub(gitlab_shell: shell)
+    context.execute
+  end
+
+end
@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Issues::BulkUpdateService do
+  before(:each) { ActiveRecord::Base.observers.enable(:user_observer) }
+  after(:each) { ActiveRecord::Base.observers.disable(:user_observer) }
+
+  let(:issue) {
+    create(:issue, project: @project)
+  } 
+
+  before do
+    @user = create :user
+    opts = {
+      name: "GitLab",
+      namespace: @user.namespace
+    }
+    @project = Projects::CreateService.new(@user, opts).execute
+  end
+
+  describe :close_issue do
+
+    before do
+      @issues = 5.times.collect do
+        create(:issue, project: @project)
+      end
+      @params = { 
+        update: {
+          status: 'closed',
+          issues_ids: @issues.map(&:id)
+        }
+      }
+    end
+
+    it {
+      result = Issues::BulkUpdateService.new(@project, @user, @params).execute
+      result[:success].should be_true
+      result[:count].should == @issues.count
+
+      @project.issues.opened.should be_empty
+      @project.issues.closed.should_not be_empty
+    }
+
+  end
+
+  describe :reopen_issues do
+
+    before do
+      @issues = 5.times.collect do
+        create(:closed_issue, project: @project)
+      end
+      @params = { 
+        update: {
+          status: 'reopen',
+          issues_ids: @issues.map(&:id)
+        }
+      }
+    end
+
+    it {
+      result = Issues::BulkUpdateService.new(@project, @user, @params).execute
+      result[:success].should be_true
+      result[:count].should == @issues.count
+
+      @project.issues.closed.should be_empty
+      @project.issues.opened.should_not be_empty
+    }
+
+  end
+
+  describe :update_assignee do
+
+    before do
+      @new_assignee = create :user
+      @params = { 
+        update: {
+          issues_ids: [issue.id],
+          assignee_id: @new_assignee.id
+        }
+      }
+    end
+
+    it {
+      result = Issues::BulkUpdateService.new(@project, @user, @params).execute
+      result[:success].should be_true
+      result[:count].should == 1
+
+      @project.issues.first.assignee.should == @new_assignee
+    }
+
+  end
+
+  describe :update_milestone do
+
+    before do
+      @milestone = create :milestone
+      @params = { 
+        update: {
+          issues_ids: [issue.id],
+          milestone_id: @milestone.id
+        }
+      }
+    end
+
+    it {
+      result = Issues::BulkUpdateService.new(@project, @user, @params).execute
+      result[:success].should be_true
+      result[:count].should == 1
+
+      @project.issues.first.milestone.should == @milestone
+    }
+  end
+
+end
@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Projects::CreateService do
+  before(:each) { ActiveRecord::Base.observers.enable(:user_observer) }
+  after(:each) { ActiveRecord::Base.observers.disable(:user_observer) }
+
+  describe :create_by_user do
+    before do
+      @user = create :user
+      @admin = create :user, admin: true
+      @opts = {
+        name: "GitLab",
+        namespace: @user.namespace
+      }
+    end
+
+    context 'user namespace' do
+      before do
+        @project = create_project(@user, @opts)
+      end
+
+      it { @project.should be_valid }
+      it { @project.owner.should == @user }
+      it { @project.namespace.should == @user.namespace }
+    end
+
+    context 'group namespace' do
+      before do
+        @group = create :group
+        @group.add_owner(@user)
+
+        @opts.merge!(namespace_id: @group.id)
+        @project = create_project(@user, @opts)
+      end
+
+      it { @project.should be_valid }
+      it { @project.owner.should == @group }
+      it { @project.namespace.should == @group }
+    end
+
+    context 'respect configured visibility setting' do
+      before(:each) do
+        @settings = double("settings")
+        @settings.stub(:issues) { true }
+        @settings.stub(:merge_requests) { true }
+        @settings.stub(:wiki) { true }
+        @settings.stub(:wall) { true }
+        @settings.stub(:snippets) { true }
+        stub_const("Settings", Class.new)
+        @restrictions = double("restrictions")
+        @restrictions.stub(:restricted_visibility_levels) { [] }
+        Settings.stub_chain(:gitlab).and_return(@restrictions)
+        Settings.stub_chain(:gitlab, :default_projects_features).and_return(@settings)
+      end
+
+      context 'should be public when setting is public' do
+        before do
+          @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::PUBLIC }
+          @project = create_project(@user, @opts)
+        end
+
+        it { @project.public?.should be_true }
+      end
+
+      context 'should be private when setting is private' do
+        before do
+          @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::PRIVATE }
+          @project = create_project(@user, @opts)
+        end
+
+        it { @project.private?.should be_true }
+      end
+
+      context 'should be internal when setting is internal' do
+        before do
+          @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::INTERNAL }
+          @project = create_project(@user, @opts)
+        end
+
+        it { @project.internal?.should be_true }
+      end
+    end
+
+    context 'respect configured visibility restrictions setting' do
+      before(:each) do
+        @settings = double("settings")
+        @settings.stub(:issues) { true }
+        @settings.stub(:merge_requests) { true }
+        @settings.stub(:wiki) { true }
+        @settings.stub(:wall) { true }
+        @settings.stub(:snippets) { true }
+        @settings.stub(:visibility_level) { Gitlab::VisibilityLevel::PRIVATE }
+        stub_const("Settings", Class.new)
+        @restrictions = double("restrictions")
+        @restrictions.stub(:restricted_visibility_levels) { [ Gitlab::VisibilityLevel::PUBLIC ] }
+        Settings.stub_chain(:gitlab).and_return(@restrictions)
+        Settings.stub_chain(:gitlab, :default_projects_features).and_return(@settings)
+      end
+
+      context 'should be private when option is public' do
+        before do
+          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
+          @project = create_project(@user, @opts)
+        end
+
+        it { @project.private?.should be_true }
+      end
+
+      context 'should be public when option is public for admin' do
+        before do
+          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
+          @project = create_project(@admin, @opts)
+        end
+
+        it { @project.public?.should be_true }
+      end
+
+      context 'should be private when option is private' do
+        before do
+          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
+          @project = create_project(@user, @opts)
+        end
+
+        it { @project.private?.should be_true }
+      end
+
+      context 'should be internal when option is internal' do
+        before do
+          @opts.merge!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
+          @project = create_project(@user, @opts)
+        end
+
+        it { @project.internal?.should be_true }
+      end
+    end
+  end
+
+  def create_project(user, opts)
+    Projects::CreateService.new(user, opts).execute
+  end
+end
+
@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Projects::UpdateService do
+  before(:each) { ActiveRecord::Base.observers.enable(:user_observer) }
+  after(:each) { ActiveRecord::Base.observers.disable(:user_observer) }
+
+  describe :update_by_user do
+    before do
+      @user = create :user
+      @admin = create :user, admin: true
+      @project = create :project, creator_id: @user.id, namespace: @user.namespace
+      @opts = { project: {} }
+    end
+
+    context 'should be private when updated to private' do
+      before do
+       @created_private = @project.private?
+
+        @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
+        update_project(@project, @user, @opts)
+      end
+
+      it { @created_private.should be_true }
+      it { @project.private?.should be_true }
+    end
+
+    context 'should be internal when updated to internal' do
+      before do
+        @created_private = @project.private?
+
+        @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
+        update_project(@project, @user, @opts)
+      end
+
+      it { @created_private.should be_true }
+      it { @project.internal?.should be_true }
+    end
+
+    context 'should be public when updated to public' do
+      before do
+        @created_private = @project.private?
+
+        @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
+        update_project(@project, @user, @opts)
+      end
+
+      it { @created_private.should be_true }
+      it { @project.public?.should be_true }
+    end
+
+    context 'respect configured visibility restrictions setting' do
+      before(:each) do
+        @restrictions = double("restrictions")
+        @restrictions.stub(:restricted_visibility_levels) { [ Gitlab::VisibilityLevel::PUBLIC ] }
+        Settings.stub_chain(:gitlab).and_return(@restrictions)
+      end
+
+      context 'should be private when updated to private' do
+        before do
+          @created_private = @project.private?
+
+          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
+          update_project(@project, @user, @opts)
+        end
+
+        it { @created_private.should be_true }
+        it { @project.private?.should be_true }
+      end
+
+      context 'should be internal when updated to internal' do
+        before do
+          @created_private = @project.private?
+
+          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
+          update_project(@project, @user, @opts)
+        end
+
+        it { @created_private.should be_true }
+        it { @project.internal?.should be_true }
+      end
+
+      context 'should be private when updated to public' do
+        before do
+          @created_private = @project.private?
+
+          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
+          update_project(@project, @user, @opts)
+        end
+
+        it { @created_private.should be_true }
+        it { @project.private?.should be_true }
+      end
+
+      context 'should be public when updated to public by admin' do
+        before do
+          @created_private = @project.private?
+
+          @opts[:project].merge!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
+          update_project(@project, @admin, @opts)
+        end
+
+        it { @created_private.should be_true }
+        it { @project.public?.should be_true }
+      end
+    end
+  end
+
+  def update_project(project, user, opts)
+    Projects::UpdateService.new(project, user, opts).execute
+  end
+end
@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe 'Search::GlobalService' do
+  let(:found_namespace) { create(:namespace, name: 'searchable namespace', path:'another_thing') }
+  let(:user) { create(:user, namespace: found_namespace) }
+  let!(:found_project) { create(:project, name: 'searchable_project', creator_id: user.id, namespace: found_namespace, visibility_level: Gitlab::VisibilityLevel::PRIVATE) }
+
+  let(:unfound_namespace) { create(:namespace, name: 'unfound namespace', path: 'yet_something_else') }
+  let!(:unfound_project) { create(:project, name: 'unfound_project', creator_id: user.id, namespace: unfound_namespace, visibility_level: Gitlab::VisibilityLevel::PRIVATE) }
+
+  let(:internal_namespace) { create(:namespace, path: 'something_internal',name: 'searchable internal namespace') }
+  let(:internal_user) { create(:user, namespace: internal_namespace) }
+  let!(:internal_project) { create(:project, name: 'searchable_internal_project', creator_id: internal_user.id, namespace: internal_namespace, visibility_level: Gitlab::VisibilityLevel::INTERNAL) }
+
+  let(:public_namespace) { create(:namespace, path: 'something_public',name: 'searchable public namespace') }
+  let(:public_user) { create(:user, namespace: public_namespace) }
+  let!(:public_project) { create(:project, name: 'searchable_public_project', creator_id: public_user.id, namespace: public_namespace, visibility_level: Gitlab::VisibilityLevel::PUBLIC) }
+
+  describe '#execute' do
+    context 'unauthenticated' do
+      it 'should return public projects only' do
+        context = Search::GlobalService.new(nil, search: "searchable")
+        results = context.execute
+        results[:projects].should have(1).items
+        results[:projects].should include(public_project)
+      end
+    end
+
+    context 'authenticated' do
+      it 'should return public, internal and private projects' do
+        context = Search::GlobalService.new(user, search: "searchable")
+        results = context.execute
+        results[:projects].should have(3).items
+        results[:projects].should include(public_project)
+        results[:projects].should include(found_project)
+        results[:projects].should include(internal_project)
+      end
+
+      it 'should return only public & internal projects' do
+        context = Search::GlobalService.new(internal_user, search: "searchable")
+        results = context.execute
+        results[:projects].should have(2).items
+        results[:projects].should include(internal_project)
+        results[:projects].should include(public_project)
+      end
+
+      it 'namespace name should be searchable' do
+        context = Search::GlobalService.new(user, search: "searchable namespace")
+        results = context.execute
+        results[:projects].should == [found_project]
+      end
+    end
+  end
+end
...	...	@@ -1,19 +0,0 @@
1		-class BaseContext
2		- attr_accessor :project, :current_user, :params
3		-
4		- def initialize(project, user, params)
5		- @project, @current_user, @params = project, user, params.dup
6		- end
7		-
8		- def abilities
9		- @abilities \|\|= begin
10		- abilities = Six.new
11		- abilities << Ability
12		- abilities
13		- end
14		- end
15		-
16		- def can?(object, action, subject)
17		- abilities.allowed?(object, action, subject)
18		- end
19		-end
...	...	@@ -1,31 +0,0 @@
1		-module Files
2		- class BaseContext < ::BaseContext
3		- attr_reader :ref, :path
4		-
5		- def initialize(project, user, params, ref, path = nil)
6		- @project, @current_user, @params = project, user, params.dup
7		- @ref = ref
8		- @path = path
9		- end
10		-
11		- private
12		-
13		- def error(message)
14		- {
15		- error: message,
16		- status: :error
17		- }
18		- end
19		-
20		- def success
21		- {
22		- error: '',
23		- status: :success
24		- }
25		- end
26		-
27		- def repository
28		- project.repository
29		- end
30		- end
31		-end
...	...	@@ -1,47 +0,0 @@
1		-require_relative "base_context"
2		-
3		-module Files
4		- class CreateContext < BaseContext
5		- def execute
6		- allowed = if project.protected_branch?(ref)
7		- can?(current_user, :push_code_to_protected_branches, project)
8		- else
9		- can?(current_user, :push_code, project)
10		- end
11		-
12		- unless allowed
13		- return error("You are not allowed to create file in this branch")
14		- end
15		-
16		- unless repository.branch_names.include?(ref)
17		- return error("You can only create files if you are on top of a branch")
18		- end
19		-
20		- file_name = File.basename(path)
21		- file_path = path
22		-
23		- unless file_name =~ Gitlab::Regex.path_regex
24		- return error("Your changes could not be committed, because file name contains not allowed characters")
25		- end
26		-
27		- blob = repository.blob_at(ref, file_path)
28		-
29		- if blob
30		- return error("Your changes could not be committed, because file with such name exists")
31		- end
32		-
33		- new_file_action = Gitlab::Satellite::NewFileAction.new(current_user, project, ref, file_path)
34		- created_successfully = new_file_action.commit!(
35		- params[:content],
36		- params[:commit_message],
37		- params[:encoding]
38		- )
39		-
40		- if created_successfully
41		- success
42		- else
43		- error("Your changes could not be committed, because the file has been changed")
44		- end
45		- end
46		- end
47		-end
...	...	@@ -1,40 +0,0 @@
1		-require_relative "base_context"
2		-
3		-module Files
4		- class DeleteContext < BaseContext
5		- def execute
6		- allowed = if project.protected_branch?(ref)
7		- can?(current_user, :push_code_to_protected_branches, project)
8		- else
9		- can?(current_user, :push_code, project)
10		- end
11		-
12		- unless allowed
13		- return error("You are not allowed to push into this branch")
14		- end
15		-
16		- unless repository.branch_names.include?(ref)
17		- return error("You can only create files if you are on top of a branch")
18		- end
19		-
20		- blob = repository.blob_at(ref, path)
21		-
22		- unless blob
23		- return error("You can only edit text files")
24		- end
25		-
26		- delete_file_action = Gitlab::Satellite::DeleteFileAction.new(current_user, project, ref, path)
27		-
28		- deleted_successfully = delete_file_action.commit!(
29		- nil,
30		- params[:commit_message]
31		- )
32		-
33		- if deleted_successfully
34		- success
35		- else
36		- error("Your changes could not be committed, because the file has been changed")
37		- end
38		- end
39		- end
40		-end
...	...	@@ -1,39 +0,0 @@
1		-module Issues
2		- class BulkUpdateContext < BaseContext
3		- def execute
4		- update_data = params[:update]
5		-
6		- issues_ids = update_data[:issues_ids].split(",")
7		- milestone_id = update_data[:milestone_id]
8		- assignee_id = update_data[:assignee_id]
9		- status = update_data[:status]
10		-
11		- new_state = nil
12		-
13		- if status.present?
14		- if status == 'closed'
15		- new_state = :close
16		- else
17		- new_state = :reopen
18		- end
19		- end
20		-
21		- opts = {}
22		- opts[:milestone_id] = milestone_id if milestone_id.present?
23		- opts[:assignee_id] = assignee_id if assignee_id.present?
24		-
25		- issues = Issue.where(id: issues_ids)
26		- issues = issues.select { \|issue\| can?(current_user, :modify_issue, issue) }
27		-
28		- issues.each do \|issue\|
29		- issue.update_attributes(opts)
30		- issue.send new_state if new_state
31		- end
32		-
33		- {
34		- count: issues.count,
35		- success: !issues.count.zero?
36		- }
37		- end
38		- end
39		-end
...	...	@@ -1,10 +0,0 @@
1		-module Notes
2		- class CreateContext < BaseContext
3		- def execute
4		- note = project.notes.new(params[:note])
5		- note.author = current_user
6		- note.save
7		- note
8		- end
9		- end
10		-end
...	...	@@ -1,20 +0,0 @@
1		-module Notes
2		- class LoadContext < BaseContext
3		- def execute
4		- target_type = params[:target_type]
5		- target_id = params[:target_id]
6		-
7		-
8		- @notes = case target_type
9		- when "commit"
10		- project.notes.for_commit_id(target_id).not_inline.fresh
11		- when "issue"
12		- project.issues.find(target_id).notes.inc_author.fresh
13		- when "merge_request"
14		- project.merge_requests.find(target_id).mr_and_commit_notes.inc_author.fresh
15		- when "snippet"
16		- project.snippets.find(target_id).notes.fresh
17		- end
18		- end
19		- end
20		-end
...	...	@@ -1,80 +0,0 @@
1		-module Projects
2		- class CreateContext < BaseContext
3		- def initialize(user, params)
4		- @current_user, @params = user, params.dup
5		- end
6		-
7		- def execute
8		- # get namespace id
9		- namespace_id = params.delete(:namespace_id)
10		-
11		- # check that user is allowed to set specified visibility_level
12		- unless Gitlab::VisibilityLevel.allowed_for?(current_user, params[:visibility_level])
13		- params.delete(:visibility_level)
14		- end
15		-
16		- # Load default feature settings
17		- default_features = Gitlab.config.gitlab.default_projects_features
18		-
19		- default_opts = {
20		- issues_enabled: default_features.issues,
21		- wiki_enabled: default_features.wiki,
22		- wall_enabled: default_features.wall,
23		- snippets_enabled: default_features.snippets,
24		- merge_requests_enabled: default_features.merge_requests,
25		- visibility_level: default_features.visibility_level
26		- }.stringify_keys
27		-
28		- @project = Project.new(default_opts.merge(params))
29		-
30		- # Parametrize path for project
31		- #
32		- # Ex.
33		- # 'GitLab HQ'.parameterize => "gitlab-hq"
34		- #
35		- @project.path = @project.name.dup.parameterize unless @project.path.present?
36		-
37		-
38		- if namespace_id
39		- # Find matching namespace and check if it allowed
40		- # for current user if namespace_id passed.
41		- if allowed_namespace?(current_user, namespace_id)
42		- @project.namespace_id = namespace_id
43		- else
44		- deny_namespace
45		- return @project
46		- end
47		- else
48		- # Set current user namespace if namespace_id is nil
49		- @project.namespace_id = current_user.namespace_id
50		- end
51		-
52		- @project.creator = current_user
53		-
54		- if @project.save
55		- unless @project.group
56		- @project.users_projects.create(
57		- project_access: UsersProject::MASTER,
58		- user: current_user
59		- )
60		- end
61		- end
62		-
63		- @project
64		- rescue => ex
65		- @project.errors.add(:base, "Can't save project. Please try again later")
66		- @project
67		- end
68		-
69		- protected
70		-
71		- def deny_namespace
72		- @project.errors.add(:namespace, "is not valid")
73		- end
74		-
75		- def allowed_namespace?(user, namespace_id)
76		- namespace = Namespace.find_by_id(namespace_id)
77		- current_user.can?(:manage_namespace, namespace)
78		- end
79		- end
80		-end
...	...	@@ -1,44 +0,0 @@
1		-module Projects
2		- class ForkContext < BaseContext
3		- include Gitlab::ShellAdapter
4		-
5		- def initialize(project, user)
6		- @from_project, @current_user = project, user
7		- end
8		-
9		- def execute
10		- project = @from_project.dup
11		- project.name = @from_project.name
12		- project.path = @from_project.path
13		- project.namespace = current_user.namespace
14		- project.creator = current_user
15		-
16		- # If the project cannot save, we do not want to trigger the project destroy
17		- # as this can have the side effect of deleting a repo attached to an existing
18		- # project with the same name and namespace
19		- if project.valid?
20		- begin
21		- Project.transaction do
22		- #First save the DB entries as they can be rolled back if the repo fork fails
23		- project.build_forked_project_link(forked_to_project_id: project.id, forked_from_project_id: @from_project.id)
24		- if project.save
25		- project.users_projects.create(project_access: UsersProject::MASTER, user: current_user)
26		- end
27		- #Now fork the repo
28		- unless gitlab_shell.fork_repository(@from_project.path_with_namespace, project.namespace.path)
29		- raise "forking failed in gitlab-shell"
30		- end
31		- project.ensure_satellite_exists
32		- end
33		- rescue => ex
34		- project.errors.add(:base, "Fork transaction failed.")
35		- project.destroy
36		- end
37		- else
38		- project.errors.add(:base, "Invalid fork destination")
39		- end
40		- project
41		-
42		- end
43		- end
44		-end
...	...	@@ -1,22 +0,0 @@
1		-module Projects
2		- class TransferContext < BaseContext
3		- def execute(role = :default)
4		- namespace_id = params[:project].delete(:namespace_id)
5		- allowed_transfer = can?(current_user, :change_namespace, project) \|\| role == :admin
6		-
7		- if allowed_transfer && namespace_id.present?
8		- if namespace_id.to_i != project.namespace_id
9		- # Transfer to someone namespace
10		- namespace = Namespace.find(namespace_id)
11		- project.transfer(namespace)
12		- end
13		- end
14		-
15		- rescue ProjectTransferService::TransferError => ex
16		- project.reload
17		- project.errors.add(:namespace_id, ex.message)
18		- false
19		- end
20		- end
21		-end
22		-