Merge pull request #2461 from gitlabhq/remove_roles

Remove models/roles and return to fat models

Merge pull request #2461 from gitlabhq/remove_roles
Remove models/roles and return to fat models
Dmitriy Zaporozhets
2 parents 1b25a8f4 da03a5c7
Showing 33 changed files with 1276 additions and 1380 deletions Show diff stats
app/models/concerns/issuable.rb
app/models/event.rb
app/models/issue.rb
app/models/merge_request.rb
app/models/project.rb
app/models/protected_branch.rb
app/models/user.rb
app/models/users_project.rb
app/observers/key_observer.rb
app/roles/account.rb
app/roles/authority.rb
app/roles/git_host.rb
app/roles/issue_commonality.rb
app/roles/namespaced_project.rb
app/roles/note_event.rb
app/roles/push_event.rb
app/roles/push_observer.rb
app/roles/repository.rb
app/roles/static_model.rb
app/roles/team.rb
@@ -0,0 +1,102 @@
+# == Issuable concern
+#
+# Contains common functionality shared between Issues and MergeRequests
+#
+# Used by Issue, MergeRequest
+#
+module Issuable
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :project
+    belongs_to :author, class_name: "User"
+    belongs_to :assignee, class_name: "User"
+    belongs_to :milestone
+    has_many :notes, as: :noteable, dependent: :destroy
+
+    validates :project, presence: true
+    validates :author, presence: true
+    validates :title, presence: true, length: { within: 0..255 }
+    validates :closed, inclusion: { in: [true, false] }
+
+    scope :opened, where(closed: false)
+    scope :closed, where(closed: true)
+    scope :of_group, ->(group) { where(project_id: group.project_ids) }
+    scope :assigned, ->(u) { where(assignee_id: u.id)}
+    scope :recent, order("created_at DESC")
+
+    delegate :name,
+             :email,
+             to: :author,
+             prefix: true
+
+    delegate :name,
+             :email,
+             to: :assignee,
+             allow_nil: true,
+             prefix: true
+
+    attr_accessor :author_id_of_changes
+  end
+
+  module ClassMethods
+    def search(query)
+      where("title like :query", query: "%#{query}%")
+    end
+  end
+
+  def today?
+    Date.today == created_at.to_date
+  end
+
+  def new?
+    today? && created_at == updated_at
+  end
+
+  def is_assigned?
+    !!assignee_id
+  end
+
+  def is_being_reassigned?
+    assignee_id_changed?
+  end
+
+  def is_being_closed?
+    closed_changed? && closed
+  end
+
+  def is_being_reopened?
+    closed_changed? && !closed
+  end
+
+  # Return the number of +1 comments (upvotes)
+  def upvotes
+    notes.select(&:upvote?).size
+  end
+
+  def upvotes_in_percent
+    if votes_count.zero?
+      0
+    else
+      100.0 / votes_count * upvotes
+    end
+  end
+
+  # Return the number of -1 comments (downvotes)
+  def downvotes
+    notes.select(&:downvote?).size
+  end
+
+  def downvotes_in_percent
+    if votes_count.zero?
+      0
+    else
+      100.0 - upvotes_in_percent
+    end
+  end
+
+  # Return the total number of votes
+  def votes_count
+    upvotes + downvotes
+  end
+end
@@ -15,9 +15,6 @@
 #
 class Event < ActiveRecord::Base
-  include NoteEvent
-  include PushEvent
-
   attr_accessible :project, :action, :data, :author_id, :project_id,
                   :target_id, :target_type
@@ -170,4 +167,139 @@ class Event &lt; ActiveRecord::Base
       "opened"
     end
   end
+
+  def valid_push?
+    data[:ref]
+  rescue => ex
+    false
+  end
+
+  def tag?
+    data[:ref]["refs/tags"]
+  end
+
+  def branch?
+    data[:ref]["refs/heads"]
+  end
+
+  def new_branch?
+    commit_from =~ /^00000/
+  end
+
+  def new_ref?
+    commit_from =~ /^00000/
+  end
+
+  def rm_ref?
+    commit_to =~ /^00000/
+  end
+
+  def md_ref?
+    !(rm_ref? || new_ref?)
+  end
+
+  def commit_from
+    data[:before]
+  end
+
+  def commit_to
+    data[:after]
+  end
+
+  def ref_name
+    if tag?
+      tag_name
+    else
+      branch_name
+    end
+  end
+
+  def branch_name
+    @branch_name ||= data[:ref].gsub("refs/heads/", "")
+  end
+
+  def tag_name
+    @tag_name ||= data[:ref].gsub("refs/tags/", "")
+  end
+
+  # Max 20 commits from push DESC
+  def commits
+    @commits ||= data[:commits].map { |commit| project.commit(commit[:id]) }.reverse
+  end
+
+  def commits_count
+    data[:total_commits_count] || commits.count || 0
+  end
+
+  def ref_type
+    tag? ? "tag" : "branch"
+  end
+
+  def push_action_name
+    if new_ref?
+      "pushed new"
+    elsif rm_ref?
+      "deleted"
+    else
+      "pushed to"
+    end
+  end
+
+  def parent_commit
+    project.commit(commit_from)
+  rescue => ex
+    nil
+  end
+
+  def last_commit
+    project.commit(commit_to)
+  rescue => ex
+    nil
+  end
+
+  def push_with_commits?
+    md_ref? && commits.any? && parent_commit && last_commit
+  rescue Grit::NoSuchPathError
+    false
+  end
+
+  def last_push_to_non_root?
+    branch? && project.default_branch != branch_name
+  end
+
+  def note_commit_id
+    target.commit_id
+  end
+
+  def note_short_commit_id
+    note_commit_id[0..8]
+  end
+
+  def note_commit?
+    target.noteable_type == "Commit"
+  end
+
+  def note_target
+    target.noteable
+  end
+
+  def note_target_id
+    if note_commit?
+      target.commit_id
+    else
+      target.noteable_id.to_s
+    end
+  end
+
+  def wall_note?
+    target.noteable_type.blank?
+  end
+
+  def note_target_type
+    if target.noteable_type.present?
+      target.noteable_type.titleize
+    else
+      "Wall"
+    end.downcase
+  end
 end
@@ -17,8 +17,7 @@
 #
 class Issue < ActiveRecord::Base
-  include IssueCommonality
-  include Votes
+  include Issuable
   attr_accessible :title, :assignee_id, :closed, :position, :description,
                   :milestone_id, :label_list, :author_id_of_changes
@@ -20,11 +20,10 @@
 #
 require Rails.root.join("app/models/commit")
-require Rails.root.join("app/roles/static_model")
+require Rails.root.join("lib/static_model")
 class MergeRequest < ActiveRecord::Base
-  include IssueCommonality
-  include Votes
+  include Issuable
   attr_accessible :title, :assignee_id, :closed, :target_branch, :source_branch, :milestone_id,
                   :author_id_of_changes
@@ -21,11 +21,7 @@
 require "grit"
 class Project < ActiveRecord::Base
-  include Repository
-  include PushObserver
-  include Authority
-  include Team
-  include NamespacedProject
+  include Gitolited
   class TransferError < StandardError; end
@@ -277,4 +273,514 @@ class Project &lt; ActiveRecord::Base
       creator
     end
   end
+
+  def team_member_by_name_or_email(name = nil, email = nil)
+    user = users.where("name like ? or email like ?", name, email).first
+    users_projects.where(user: user) if user
+  end
+
+  # Get Team Member record by user id
+  def team_member_by_id(user_id)
+    users_projects.find_by_user_id(user_id)
+  end
+
+  # Add user to project
+  # with passed access role
+  def add_user_to_team(user, access_role)
+    add_user_id_to_team(user.id, access_role)
+  end
+
+  # Add multiple users to project
+  # with same access role
+  def add_users_to_team(users, access_role)
+    add_users_ids_to_team(users.map(&:id), access_role)
+  end
+
+  # Add user to project
+  # with passed access role by user id
+  def add_user_id_to_team(user_id, access_role)
+    users_projects.create(
+      user_id: user_id,
+      project_access: access_role
+    )
+  end
+
+  # Add multiple users to project
+  # with same access role by user ids
+  def add_users_ids_to_team(users_ids, access_role)
+    UsersProject.bulk_import(self, users_ids, access_role)
+  end
+
+  # Update multiple project users
+  # to same access role by user ids
+  def update_users_ids_to_role(users_ids, access_role)
+    UsersProject.bulk_update(self, users_ids, access_role)
+  end
+
+  # Delete multiple users from project by user ids
+  def delete_users_ids_from_team(users_ids)
+    UsersProject.bulk_delete(self, users_ids)
+  end
+
+  # Remove all users from project team
+  def truncate_team
+    UsersProject.truncate_team(self)
+  end
+
+  # Compatible with all access rights
+  # Should be rewrited for new access rights
+  def add_access(user, *access)
+    access = if access.include?(:admin)
+               { project_access: UsersProject::MASTER }
+             elsif access.include?(:write)
+               { project_access: UsersProject::DEVELOPER }
+             else
+               { project_access: UsersProject::REPORTER }
+             end
+    opts = { user: user }
+    opts.merge!(access)
+    users_projects.create(opts)
+  end
+
+  def reset_access(user)
+    users_projects.where(project_id: self.id, user_id: user.id).destroy if self.id
+  end
+
+  def repository_readers
+    repository_members[UsersProject::REPORTER]
+  end
+
+  def repository_writers
+    repository_members[UsersProject::DEVELOPER]
+  end
+
+  def repository_masters
+    repository_members[UsersProject::MASTER]
+  end
+
+  def repository_members
+    keys = Hash.new {|h,k| h[k] = [] }
+    UsersProject.select("keys.identifier, project_access").
+        joins(user: :keys).where(project_id: id).
+        each {|row| keys[row.project_access] << [row.identifier] }
+
+    keys[UsersProject::REPORTER] += deploy_keys.pluck(:identifier)
+    keys
+  end
+
+  def allow_read_for?(user)
+    !users_projects.where(user_id: user.id).empty?
+  end
+
+  def guest_access_for?(user)
+    !users_projects.where(user_id: user.id).empty?
+  end
+
+  def report_access_for?(user)
+    !users_projects.where(user_id: user.id, project_access: [UsersProject::REPORTER, UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
+  end
+
+  def dev_access_for?(user)
+    !users_projects.where(user_id: user.id, project_access: [UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
+  end
+
+  def master_access_for?(user)
+    !users_projects.where(user_id: user.id, project_access: [UsersProject::MASTER]).empty?
+  end
+
+  def transfer(new_namespace)
+    Project.transaction do
+      old_namespace = namespace
+      self.namespace = new_namespace
+
+      old_dir = old_namespace.try(:path) || ''
+      new_dir = new_namespace.try(:path) || ''
+
+      old_repo = if old_dir.present?
+                   File.join(old_dir, self.path)
+                 else
+                   self.path
+                 end
+
+      if Project.where(path: self.path, namespace_id: new_namespace.try(:id)).present?
+        raise TransferError.new("Project with same path in target namespace already exists")
+      end
+
+      Gitlab::ProjectMover.new(self, old_dir, new_dir).execute
+
+      gitolite.move_repository(old_repo, self)
+
+      save!
+    end
+  rescue Gitlab::ProjectMover::ProjectMoveError => ex
+    raise Project::TransferError.new(ex.message)
+  end
+
+  def name_with_namespace
+    @name_with_namespace ||= begin
+                               if namespace
+                                 namespace.human_name + " / " + name
+                               else
+                                 name
+                               end
+                             end
+  end
+
+  def namespace_owner
+    namespace.try(:owner)
+  end
+
+  def path_with_namespace
+    if namespace
+      namespace.path + '/' + path
+    else
+      path
+    end
+  end
+
+  # This method will be called after each post receive and only if the provided
+  # user is present in GitLab.
+  #
+  # All callbacks for post receive should be placed here.
+  def trigger_post_receive(oldrev, newrev, ref, user)
+    data = post_receive_data(oldrev, newrev, ref, user)
+
+    # Create push event
+    self.observe_push(data)
+
+    if push_to_branch? ref, oldrev
+      # Close merged MR
+      self.update_merge_requests(oldrev, newrev, ref, user)
+
+      # Execute web hooks
+      self.execute_hooks(data.dup)
+
+      # Execute project services
+      self.execute_services(data.dup)
+    end
+
+    # Create satellite
+    self.satellite.create unless self.satellite.exists?
+
+    # Discover the default branch, but only if it hasn't already been set to
+    # something else
+    if default_branch.nil?
+      update_attributes(default_branch: discover_default_branch)
+    end
+  end
+
+  def push_to_branch? ref, oldrev
+    ref_parts = ref.split('/')
+
+    # Return if this is not a push to a branch (e.g. new commits)
+    !(ref_parts[1] !~ /heads/ || oldrev == "00000000000000000000000000000000")
+  end
+
+  def observe_push(data)
+    Event.create(
+      project: self,
+      action: Event::Pushed,
+      data: data,
+      author_id: data[:user_id]
+    )
+  end
+
+  def execute_hooks(data)
+    hooks.each { |hook| hook.execute(data) }
+  end
+
+  def execute_services(data)
+    services.each do |service|
+
+      # Call service hook only if it is active
+      service.execute(data) if service.active
+    end
+  end
+
+  # Produce a hash of post-receive data
+  #
+  # data = {
+  #   before: String,
+  #   after: String,
+  #   ref: String,
+  #   user_id: String,
+  #   user_name: String,
+  #   repository: {
+  #     name: String,
+  #     url: String,
+  #     description: String,
+  #     homepage: String,
+  #   },
+  #   commits: Array,
+  #   total_commits_count: Fixnum
+  # }
+  #
+  def post_receive_data(oldrev, newrev, ref, user)
+
+    push_commits = commits_between(oldrev, newrev)
+
+    # Total commits count
+    push_commits_count = push_commits.size
+
+    # Get latest 20 commits ASC
+    push_commits_limited = push_commits.last(20)
+
+    # Hash to be passed as post_receive_data
+    data = {
+      before: oldrev,
+      after: newrev,
+      ref: ref,
+      user_id: user.id,
+      user_name: user.name,
+      repository: {
+        name: name,
+        url: url_to_repo,
+        description: description,
+        homepage: web_url,
+      },
+      commits: [],
+      total_commits_count: push_commits_count
+    }
+
+    # For perfomance purposes maximum 20 latest commits
+    # will be passed as post receive hook data.
+    #
+    push_commits_limited.each do |commit|
+      data[:commits] << {
+        id: commit.id,
+        message: commit.safe_message,
+        timestamp: commit.date.xmlschema,
+        url: "#{Gitlab.config.gitlab.url}/#{path_with_namespace}/commit/#{commit.id}",
+        author: {
+          name: commit.author_name,
+          email: commit.author_email
+        }
+      }
+    end
+
+    data
+  end
+
+  def update_merge_requests(oldrev, newrev, ref, user)
+    return true unless ref =~ /heads/
+    branch_name = ref.gsub("refs/heads/", "")
+    c_ids = self.commits_between(oldrev, newrev).map(&:id)
+
+    # Update code for merge requests
+    mrs = self.merge_requests.opened.find_all_by_branch(branch_name).all
+    mrs.each { |merge_request| merge_request.reload_code; merge_request.mark_as_unchecked }
+
+    # Close merge requests
+    mrs = self.merge_requests.opened.where(target_branch: branch_name).all
+    mrs = mrs.select(&:last_commit).select { |mr| c_ids.include?(mr.last_commit.id) }
+    mrs.each { |merge_request| merge_request.merge!(user.id) }
+
+    true
+  end
+
+  def valid_repo?
+    repo
+  rescue
+    errors.add(:path, "Invalid repository path")
+    false
+  end
+
+  def empty_repo?
+    !repo_exists? || !has_commits?
+  end
+
+  def commit(commit_id = nil)
+    Commit.find_or_first(repo, commit_id, root_ref)
+  end
+
+  def fresh_commits(n = 10)
+    Commit.fresh_commits(repo, n)
+  end
+
+  def commits_with_refs(n = 20)
+    Commit.commits_with_refs(repo, n)
+  end
+
+  def commits_since(date)
+    Commit.commits_since(repo, date)
+  end
+
+  def commits(ref, path = nil, limit = nil, offset = nil)
+    Commit.commits(repo, ref, path, limit, offset)
+  end
+
+  def last_commit_for(ref, path = nil)
+    commits(ref, path, 1).first
+  end
+
+  def commits_between(from, to)
+    Commit.commits_between(repo, from, to)
+  end
+
+  def satellite
+    @satellite ||= Gitlab::Satellite::Satellite.new(self)
+  end
+
+  def has_post_receive_file?
+    !!hook_file
+  end
+
+  def valid_post_receive_file?
+    valid_hook_file == hook_file
+  end
+
+  def valid_hook_file
+    @valid_hook_file ||= File.read(Rails.root.join('lib', 'hooks', 'post-receive'))
+  end
+
+  def hook_file
+    @hook_file ||= begin
+                     hook_path = File.join(path_to_repo, 'hooks', 'post-receive')
+                     File.read(hook_path) if File.exists?(hook_path)
+                   end
+  end
+
+  # Returns an Array of branch names
+  def branch_names
+    repo.branches.collect(&:name).sort
+  end
+
+  # Returns an Array of Branches
+  def branches
+    repo.branches.sort_by(&:name)
+  end
+
+  # Returns an Array of tag names
+  def tag_names
+    repo.tags.collect(&:name).sort.reverse
+  end
+
+  # Returns an Array of Tags
+  def tags
+    repo.tags.sort_by(&:name).reverse
+  end
+
+  # Returns an Array of branch and tag names
+  def ref_names
+    [branch_names + tag_names].flatten
+  end
+
+  def repo
+    @repo ||= Grit::Repo.new(path_to_repo)
+  end
+
+  def url_to_repo
+    gitolite.url_to_repo(path_with_namespace)
+  end
+
+  def path_to_repo
+    File.join(Gitlab.config.gitolite.repos_path, "#{path_with_namespace}.git")
+  end
+
+  def namespace_dir
+    namespace.try(:path) || ''
+  end
+
+  def update_repository
+    gitolite.update_repository(self)
+  end
+
+  def destroy_repository
+    gitolite.remove_repository(self)
+  end
+
+  def repo_exists?
+    @repo_exists ||= (repo && !repo.branches.empty?)
+  rescue
+    @repo_exists = false
+  end
+
+  def heads
+    @heads ||= repo.heads
+  end
+
+  def tree(fcommit, path = nil)
+    fcommit = commit if fcommit == :head
+    tree = fcommit.tree
+    path ? (tree / path) : tree
+  end
+
+  def open_branches
+    if protected_branches.empty?
+      self.repo.heads
+    else
+      pnames = protected_branches.map(&:name)
+      self.repo.heads.reject { |h| pnames.include?(h.name) }
+    end.sort_by(&:name)
+  end
+
+  # Discovers the default branch based on the repository's available branches
+  #
+  # - If no branches are present, returns nil
+  # - If one branch is present, returns its name
+  # - If two or more branches are present, returns the one that has a name
+  #   matching root_ref (default_branch or 'master' if default_branch is nil)
+  def discover_default_branch
+    if branch_names.length == 0
+      nil
+    elsif branch_names.length == 1
+      branch_names.first
+    else
+      branch_names.select { |v| v == root_ref }.first
+    end
+  end
+
+  def has_commits?
+    !!commit
+  rescue Grit::NoSuchPathError
+    false
+  end
+
+  def root_ref
+    default_branch || "master"
+  end
+
+  def root_ref?(branch)
+    root_ref == branch
+  end
+
+  # Archive Project to .tar.gz
+  #
+  # Already packed repo archives stored at
+  # app_root/tmp/repositories/project_name/project_name-commit-id.tag.gz
+  #
+  def archive_repo(ref)
+    ref = ref || self.root_ref
+    commit = self.commit(ref)
+    return nil unless commit
+
+    # Build file path
+    file_name = self.path + "-" + commit.id.to_s + ".tar.gz"
+    storage_path = Rails.root.join("tmp", "repositories", self.path_with_namespace)
+    file_path = File.join(storage_path, file_name)
+
+    # Put files into a directory before archiving
+    prefix = self.path + "/"
+
+    # Create file if not exists
+    unless File.exists?(file_path)
+      FileUtils.mkdir_p storage_path
+      file = self.repo.archive_to_file(ref, prefix,  file_path)
+    end
+
+    file_path
+  end
+
+  def ssh_url_to_repo
+    url_to_repo
+  end
+
+  def http_url_to_repo
+    http_url = [Gitlab.config.gitlab.url, "/", path_with_namespace, ".git"].join('')
+  end
+
+  # Check if current branch name is marked as protected in the system
+  def protected_branch? branch_name
+    protected_branches.map(&:name).include?(branch_name)
+  end
 end
@@ -10,7 +10,7 @@
 #
 class ProtectedBranch < ActiveRecord::Base
-  include GitHost
+  include Gitolited
   attr_accessible :name
@@ -22,7 +22,7 @@ class ProtectedBranch &lt; ActiveRecord::Base
   after_destroy :update_repository
   def update_repository
-    git_host.update_repository(project)
+    gitolite.update_repository(project)
   end
   def commit
@@ -34,8 +34,6 @@
 #
 class User < ActiveRecord::Base
-  include Account
-
   devise :database_authenticatable, :token_authenticatable, :lockable,
          :recoverable, :rememberable, :trackable, :validatable, :omniauthable
@@ -192,4 +190,92 @@ class User &lt; ActiveRecord::Base
   def tm_in_personal_projects
     personal_projects.users_projects.where(user_id: self.id)
   end
+
+  # Returns a string for use as a Gitolite user identifier
+  #
+  # Note that Gitolite 2.x requires the following pattern for users:
+  #
+  #   ^@?[0-9a-zA-Z][0-9a-zA-Z._\@+-]*$
+  def identifier
+    # Replace non-word chars with underscores, then make sure it starts with
+    # valid chars
+    email.gsub(/\W/, '_').gsub(/\A([\W\_])+/, '')
+  end
+
+  def is_admin?
+    admin
+  end
+
+  def require_ssh_key?
+    keys.count == 0
+  end
+
+  def can_create_project?
+    projects_limit > personal_projects.count
+  end
+
+  def can_create_group?
+    is_admin?
+  end
+
+  def abilities
+    @abilities ||= begin
+                     abilities = Six.new
+                     abilities << Ability
+                     abilities
+                   end
+  end
+
+  def can? action, subject
+    abilities.allowed?(self, action, subject)
+  end
+
+  def last_activity_project
+    projects.first
+  end
+
+  def first_name
+    name.split.first unless name.blank?
+  end
+
+  def cared_merge_requests
+    MergeRequest.where("author_id = :id or assignee_id = :id", id: self.id)
+  end
+
+  # Remove user from all projects and
+  # set blocked attribute to true
+  def block
+    users_projects.find_each do |membership|
+      return false unless membership.destroy
+    end
+
+    self.blocked = true
+    save
+  end
+
+  def projects_limit_percent
+    return 100 if projects_limit.zero?
+    (personal_projects.count.to_f / projects_limit) * 100
+  end
+
+  def recent_push project_id = nil
+    # Get push events not earlier than 2 hours ago
+    events = recent_events.code_push.where("created_at > ?", Time.now - 2.hours)
+    events = events.where(project_id: project_id) if project_id
+
+    # Take only latest one
+    events = events.recent.limit(1).first
+  end
+
+  def projects_sorted_by_activity
+    authorized_projects.sorted_by_activity
+  end
+
+  def several_namespaces?
+    namespaces.size > 1
+  end
+
+  def namespace_id
+    namespace.try :id
+  end
 end
@@ -11,7 +11,7 @@
 #
 class UsersProject < ActiveRecord::Base
-  include GitHost
+  include Gitolited
   GUEST     = 10
   REPORTER  = 20
@@ -152,7 +152,7 @@ class UsersProject &lt; ActiveRecord::Base
   end
   def update_repository
-    git_host.update_repository(project)
+    gitolite.update_repository(project)
   end
   def project_access_human
 class KeyObserver < ActiveRecord::Observer
-  include GitHost
+  include Gitolited
   def after_save(key)
-    git_host.set_key(key.identifier, key.key, key.projects)
+    gitolite.set_key(key.identifier, key.key, key.projects)
   end
   def after_destroy(key)
     return if key.is_deploy_key && !key.last_deploy?
-    git_host.remove_key(key.identifier, key.projects)
+    gitolite.remove_key(key.identifier, key.projects)
   end
 end
@@ -1,95 +0,0 @@
-# == Account role
-#
-# Describe behaviour of User in application
-#
-# Used by User
-#
-module Account
-  # Returns a string for use as a Gitolite user identifier
-  #
-  # Note that Gitolite 2.x requires the following pattern for users:
-  #
-  #   ^@?[0-9a-zA-Z][0-9a-zA-Z._\@+-]*$
-  def identifier
-    # Replace non-word chars with underscores, then make sure it starts with
-    # valid chars
-    email.gsub(/\W/, '_').gsub(/\A([\W\_])+/, '')
-  end
-
-  def is_admin?
-    admin
-  end
-
-  def require_ssh_key?
-    keys.count == 0
-  end
-
-  def can_create_project?
-    projects_limit > personal_projects.count
-  end
-
-  def can_create_group?
-    is_admin?
-  end
-
-  def abilities
-    @abilities ||= begin
-                     abilities = Six.new
-                     abilities << Ability
-                     abilities
-                   end
-  end
-
-  def can? action, subject
-    abilities.allowed?(self, action, subject)
-  end
-
-  def last_activity_project
-    projects.first
-  end
-
-  def first_name
-    name.split.first unless name.blank?
-  end
-
-  def cared_merge_requests
-    MergeRequest.where("author_id = :id or assignee_id = :id", id: self.id)
-  end
-
-  # Remove user from all projects and
-  # set blocked attribute to true
-  def block
-    users_projects.find_each do |membership|
-      return false unless membership.destroy
-    end
-
-    self.blocked = true
-    save
-  end
-
-  def projects_limit_percent
-    return 100 if projects_limit.zero?
-    (personal_projects.count.to_f / projects_limit) * 100
-  end
-
-  def recent_push project_id = nil
-    # Get push events not earlier than 2 hours ago
-    events = recent_events.code_push.where("created_at > ?", Time.now - 2.hours)
-    events = events.where(project_id: project_id) if project_id
-
-    # Take only latest one
-    events = events.recent.limit(1).first
-  end
-
-  def projects_sorted_by_activity
-    authorized_projects.sorted_by_activity
-  end
-
-  def several_namespaces?
-    namespaces.size > 1
-  end
-
-  def namespace_id
-    namespace.try :id
-  end
-end
@@ -1,68 +0,0 @@
-# == Authority role
-#
-# Control access to project repository based on users role in team
-#
-# Used by Project
-#
-module Authority
-  # Compatible with all access rights
-  # Should be rewrited for new access rights
-  def add_access(user, *access)
-    access = if access.include?(:admin)
-               { project_access: UsersProject::MASTER }
-             elsif access.include?(:write)
-               { project_access: UsersProject::DEVELOPER }
-             else
-               { project_access: UsersProject::REPORTER }
-             end
-    opts = { user: user }
-    opts.merge!(access)
-    users_projects.create(opts)
-  end
-
-  def reset_access(user)
-    users_projects.where(project_id: self.id, user_id: user.id).destroy if self.id
-  end
-
-  def repository_readers
-    repository_members[UsersProject::REPORTER]
-  end
-
-  def repository_writers
-    repository_members[UsersProject::DEVELOPER]
-  end
-
-  def repository_masters
-    repository_members[UsersProject::MASTER]
-  end
-
-  def repository_members
-    keys = Hash.new {|h,k| h[k] = [] }
-    UsersProject.select("keys.identifier, project_access").
-        joins(user: :keys).where(project_id: id).
-        each {|row| keys[row.project_access] << [row.identifier] }
-
-    keys[UsersProject::REPORTER] += deploy_keys.pluck(:identifier)
-    keys
-  end
-
-  def allow_read_for?(user)
-    !users_projects.where(user_id: user.id).empty?
-  end
-
-  def guest_access_for?(user)
-    !users_projects.where(user_id: user.id).empty?
-  end
-
-  def report_access_for?(user)
-    !users_projects.where(user_id: user.id, project_access: [UsersProject::REPORTER, UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
-  end
-
-  def dev_access_for?(user)
-    !users_projects.where(user_id: user.id, project_access: [UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
-  end
-
-  def master_access_for?(user)
-    !users_projects.where(user_id: user.id, project_access: [UsersProject::MASTER]).empty?
-  end
-end
@@ -1,11 +0,0 @@
-# == GitHost role
-#
-# Provide a shortcut to Gitlab::Gitolite instance
-#
-# Used by Project, UsersProject
-#
-module GitHost
-  def git_host
-    Gitlab::Gitolite.new
-  end
-end
@@ -1,72 +0,0 @@
-# == IssueCommonality role
-#
-# Contains common functionality shared between Issues and MergeRequests
-#
-# Used by Issue, MergeRequest
-#
-module IssueCommonality
-  extend ActiveSupport::Concern
-
-  included do
-    belongs_to :project
-    belongs_to :author, class_name: "User"
-    belongs_to :assignee, class_name: "User"
-    belongs_to :milestone
-    has_many :notes, as: :noteable, dependent: :destroy
-
-    validates :project, presence: true
-    validates :author, presence: true
-    validates :title, presence: true, length: { within: 0..255 }
-    validates :closed, inclusion: { in: [true, false] }
-
-    scope :opened, where(closed: false)
-    scope :closed, where(closed: true)
-    scope :of_group, ->(group) { where(project_id: group.project_ids) }
-    scope :assigned, ->(u) { where(assignee_id: u.id)}
-    scope :recent, order("created_at DESC")
-
-    delegate :name,
-             :email,
-             to: :author,
-             prefix: true
-
-    delegate :name,
-             :email,
-             to: :assignee,
-             allow_nil: true,
-             prefix: true
-
-    attr_accessor :author_id_of_changes
-  end
-
-  module ClassMethods
-    def search(query)
-      where("title like :query", query: "%#{query}%")
-    end
-  end
-
-  def today?
-    Date.today == created_at.to_date
-  end
-
-  def new?
-    today? && created_at == updated_at
-  end
-
-  def is_assigned?
-    !!assignee_id
-  end
-
-  def is_being_reassigned?
-    assignee_id_changed?
-  end
-
-  def is_being_closed?
-    closed_changed? && closed
-  end
-
-  def is_being_reopened?
-    closed_changed? && !closed
-  end
-
-end
@@ -1,60 +0,0 @@
-# == NamespacedProject role
-#
-# Provides extra functionality for Project related to namespaces like:
-#  - transfer project between namespaces
-#  - name, path including namespece
-#  - project owner based on namespace
-#
-# Used by Project
-#
-module NamespacedProject
-  def transfer(new_namespace)
-    Project.transaction do
-      old_namespace = namespace
-      self.namespace = new_namespace
-
-      old_dir = old_namespace.try(:path) || ''
-      new_dir = new_namespace.try(:path) || ''
-
-      old_repo = if old_dir.present?
-                   File.join(old_dir, self.path)
-                 else
-                   self.path
-                 end
-
-      if Project.where(path: self.path, namespace_id: new_namespace.try(:id)).present?
-        raise TransferError.new("Project with same path in target namespace already exists")
-      end
-
-      Gitlab::ProjectMover.new(self, old_dir, new_dir).execute
-
-      git_host.move_repository(old_repo, self)
-
-      save!
-    end
-  rescue Gitlab::ProjectMover::ProjectMoveError => ex
-    raise Project::TransferError.new(ex.message)
-  end
-
-  def name_with_namespace
-    @name_with_namespace ||= begin
-                               if namespace
-                                 namespace.human_name + " / " + name
-                               else
-                                 name
-                               end
-                             end
-  end
-
-  def namespace_owner
-    namespace.try(:owner)
-  end
-
-  def path_with_namespace
-    if namespace
-      namespace.path + '/' + path
-    else
-      path
-    end
-  end
-end
@@ -1,43 +0,0 @@
-# == NoteEvent role
-#
-# Extends Event model functionality by providing extra methods related to comment events
-#
-# Used by Event
-#
-module NoteEvent
-  def note_commit_id
-    target.commit_id
-  end
-
-  def note_short_commit_id
-    note_commit_id[0..8]
-  end
-
-  def note_commit?
-    target.noteable_type == "Commit"
-  end
-
-  def note_target
-    target.noteable
-  end
-
-  def note_target_id
-    if note_commit?
-      target.commit_id
-    else
-      target.noteable_id.to_s
-    end
-  end
-
-  def wall_note?
-    target.noteable_type.blank?
-  end
-
-  def note_target_type
-    if target.noteable_type.present?
-      target.noteable_type.titleize
-    else
-      "Wall"
-    end.downcase
-  end
-end
@@ -1,106 +0,0 @@
-# == PushEvent role
-#
-# Extends Event model functionality by providing extra methods related to push events
-#
-# Used by Event
-#
-module PushEvent
-  def valid_push?
-    data[:ref]
-  rescue => ex
-    false
-  end
-
-  def tag?
-    data[:ref]["refs/tags"]
-  end
-
-  def branch?
-    data[:ref]["refs/heads"]
-  end
-
-  def new_branch?
-    commit_from =~ /^00000/
-  end
-
-  def new_ref?
-    commit_from =~ /^00000/
-  end
-
-  def rm_ref?
-    commit_to =~ /^00000/
-  end
-
-  def md_ref?
-    !(rm_ref? || new_ref?)
-  end
-
-  def commit_from
-    data[:before]
-  end
-
-  def commit_to
-    data[:after]
-  end
-
-  def ref_name
-    if tag?
-      tag_name
-    else
-      branch_name
-    end
-  end
-
-  def branch_name
-    @branch_name ||= data[:ref].gsub("refs/heads/", "")
-  end
-
-  def tag_name
-    @tag_name ||= data[:ref].gsub("refs/tags/", "")
-  end
-
-  # Max 20 commits from push DESC
-  def commits
-    @commits ||= data[:commits].map { |commit| project.commit(commit[:id]) }.reverse
-  end
-
-  def commits_count
-    data[:total_commits_count] || commits.count || 0
-  end
-
-  def ref_type
-    tag? ? "tag" : "branch"
-  end
-
-  def push_action_name
-    if new_ref?
-      "pushed new"
-    elsif rm_ref?
-      "deleted"
-    else
-      "pushed to"
-    end
-  end
-
-  def parent_commit
-    project.commit(commit_from)
-  rescue => ex
-    nil
-  end
-
-  def last_commit
-    project.commit(commit_to)
-  rescue => ex
-    nil
-  end
-
-  def push_with_commits?
-    md_ref? && commits.any? && parent_commit && last_commit
-  rescue Grit::NoSuchPathError
-    false
-  end
-
-  def last_push_to_non_root?
-    branch? && project.default_branch != branch_name
-  end
-end
@@ -1,149 +0,0 @@
-# == PushObserver role
-#
-# Includes methods to be triggered on push to project repository.
-#
-#
-# Used by Project
-# Triggered by PostReceive job
-#
-module PushObserver
-  # This method will be called after each post receive and only if the provided
-  # user is present in GitLab.
-  #
-  # All callbacks for post receive should be placed here.
-  def trigger_post_receive(oldrev, newrev, ref, user)
-    data = post_receive_data(oldrev, newrev, ref, user)
-
-    # Create push event
-    self.observe_push(data)
-
-    if push_to_branch? ref, oldrev
-      # Close merged MR
-      self.update_merge_requests(oldrev, newrev, ref, user)
-
-      # Execute web hooks
-      self.execute_hooks(data.dup)
-
-      # Execute project services
-      self.execute_services(data.dup)
-    end
-
-    # Create satellite
-    self.satellite.create unless self.satellite.exists?
-
-    # Discover the default branch, but only if it hasn't already been set to
-    # something else
-    if default_branch.nil?
-      update_attributes(default_branch: discover_default_branch)
-    end
-  end
-
-  def push_to_branch? ref, oldrev
-    ref_parts = ref.split('/')
-
-    # Return if this is not a push to a branch (e.g. new commits)
-    !(ref_parts[1] !~ /heads/ || oldrev == "00000000000000000000000000000000")
-  end
-
-  def observe_push(data)
-    Event.create(
-      project: self,
-      action: Event::Pushed,
-      data: data,
-      author_id: data[:user_id]
-    )
-  end
-
-  def execute_hooks(data)
-    hooks.each { |hook| hook.execute(data) }
-  end
-
-  def execute_services(data)
-    services.each do |service|
-
-      # Call service hook only if it is active
-      service.execute(data) if service.active
-    end
-  end
-
-  # Produce a hash of post-receive data
-  #
-  # data = {
-  #   before: String,
-  #   after: String,
-  #   ref: String,
-  #   user_id: String,
-  #   user_name: String,
-  #   repository: {
-  #     name: String,
-  #     url: String,
-  #     description: String,
-  #     homepage: String,
-  #   },
-  #   commits: Array,
-  #   total_commits_count: Fixnum
-  # }
-  #
-  def post_receive_data(oldrev, newrev, ref, user)
-
-    push_commits = commits_between(oldrev, newrev)
-
-    # Total commits count
-    push_commits_count = push_commits.size
-
-    # Get latest 20 commits ASC
-    push_commits_limited = push_commits.last(20)
-
-    # Hash to be passed as post_receive_data
-    data = {
-      before: oldrev,
-      after: newrev,
-      ref: ref,
-      user_id: user.id,
-      user_name: user.name,
-      repository: {
-        name: name,
-        url: url_to_repo,
-        description: description,
-        homepage: web_url,
-      },
-      commits: [],
-      total_commits_count: push_commits_count
-    }
-
-    # For perfomance purposes maximum 20 latest commits
-    # will be passed as post receive hook data.
-    #
-    push_commits_limited.each do |commit|
-      data[:commits] << {
-        id: commit.id,
-        message: commit.safe_message,
-        timestamp: commit.date.xmlschema,
-        url: "#{Gitlab.config.gitlab.url}/#{path_with_namespace}/commit/#{commit.id}",
-        author: {
-          name: commit.author_name,
-          email: commit.author_email
-        }
-      }
-    end
-
-    data
-  end
-
-  def update_merge_requests(oldrev, newrev, ref, user)
-    return true unless ref =~ /heads/
-    branch_name = ref.gsub("refs/heads/", "")
-    c_ids = self.commits_between(oldrev, newrev).map(&:id)
-
-    # Update code for merge requests
-    mrs = self.merge_requests.opened.find_all_by_branch(branch_name).all
-    mrs.each { |merge_request| merge_request.reload_code; merge_request.mark_as_unchecked }
-
-    # Close merge requests
-    mrs = self.merge_requests.opened.where(target_branch: branch_name).all
-    mrs = mrs.select(&:last_commit).select { |mr| c_ids.include?(mr.last_commit.id) }
-    mrs.each { |merge_request| merge_request.merge!(user.id) }
-
-    true
-  end
-end
@@ -1,216 +0,0 @@
-# == Repository role
-#
-# Provides access to git repository resources like commits, branches etc..
-# Allows you to manage repository via gitolite interface(git_host)
-#
-# Used by Project
-#
-module Repository
-  include GitHost
-
-  def valid_repo?
-    repo
-  rescue
-    errors.add(:path, "Invalid repository path")
-    false
-  end
-
-  def empty_repo?
-    !repo_exists? || !has_commits?
-  end
-
-  def commit(commit_id = nil)
-    Commit.find_or_first(repo, commit_id, root_ref)
-  end
-
-  def fresh_commits(n = 10)
-    Commit.fresh_commits(repo, n)
-  end
-
-  def commits_with_refs(n = 20)
-    Commit.commits_with_refs(repo, n)
-  end
-
-  def commits_since(date)
-    Commit.commits_since(repo, date)
-  end
-
-  def commits(ref, path = nil, limit = nil, offset = nil)
-    Commit.commits(repo, ref, path, limit, offset)
-  end
-
-  def last_commit_for(ref, path = nil)
-    commits(ref, path, 1).first
-  end
-
-  def commits_between(from, to)
-    Commit.commits_between(repo, from, to)
-  end
-
-  def satellite
-    @satellite ||= Gitlab::Satellite::Satellite.new(self)
-  end
-
-  def has_post_receive_file?
-    !!hook_file
-  end
-
-  def valid_post_receive_file?
-    valid_hook_file == hook_file
-  end
-
-  def valid_hook_file
-    @valid_hook_file ||= File.read(Rails.root.join('lib', 'hooks', 'post-receive'))
-  end
-
-  def hook_file
-    @hook_file ||= begin
-                     hook_path = File.join(path_to_repo, 'hooks', 'post-receive')
-                     File.read(hook_path) if File.exists?(hook_path)
-                   end
-  end
-
-  # Returns an Array of branch names
-  def branch_names
-    repo.branches.collect(&:name).sort
-  end
-
-  # Returns an Array of Branches
-  def branches
-    repo.branches.sort_by(&:name)
-  end
-
-  # Returns an Array of tag names
-  def tag_names
-    repo.tags.collect(&:name).sort.reverse
-  end
-
-  # Returns an Array of Tags
-  def tags
-    repo.tags.sort_by(&:name).reverse
-  end
-
-  # Returns an Array of branch and tag names
-  def ref_names
-    [branch_names + tag_names].flatten
-  end
-
-  def repo
-    @repo ||= Grit::Repo.new(path_to_repo)
-  end
-
-  def url_to_repo
-    git_host.url_to_repo(path_with_namespace)
-  end
-
-  def path_to_repo
-    File.join(Gitlab.config.gitolite.repos_path, "#{path_with_namespace}.git")
-  end
-
-  def namespace_dir
-    namespace.try(:path) || ''
-  end
-
-  def update_repository
-    git_host.update_repository(self)
-  end
-
-  def destroy_repository
-    git_host.remove_repository(self)
-  end
-
-  def repo_exists?
-    @repo_exists ||= (repo && !repo.branches.empty?)
-  rescue
-    @repo_exists = false
-  end
-
-  def heads
-    @heads ||= repo.heads
-  end
-
-  def tree(fcommit, path = nil)
-    fcommit = commit if fcommit == :head
-    tree = fcommit.tree
-    path ? (tree / path) : tree
-  end
-
-  def open_branches
-    if protected_branches.empty?
-      self.repo.heads
-    else
-      pnames = protected_branches.map(&:name)
-      self.repo.heads.reject { |h| pnames.include?(h.name) }
-    end.sort_by(&:name)
-  end
-
-  # Discovers the default branch based on the repository's available branches
-  #
-  # - If no branches are present, returns nil
-  # - If one branch is present, returns its name
-  # - If two or more branches are present, returns the one that has a name
-  #   matching root_ref (default_branch or 'master' if default_branch is nil)
-  def discover_default_branch
-    if branch_names.length == 0
-      nil
-    elsif branch_names.length == 1
-      branch_names.first
-    else
-      branch_names.select { |v| v == root_ref }.first
-    end
-  end
-
-  def has_commits?
-    !!commit
-  rescue Grit::NoSuchPathError
-    false
-  end
-
-  def root_ref
-    default_branch || "master"
-  end
-
-  def root_ref?(branch)
-    root_ref == branch
-  end
-
-  # Archive Project to .tar.gz
-  #
-  # Already packed repo archives stored at
-  # app_root/tmp/repositories/project_name/project_name-commit-id.tag.gz
-  #
-  def archive_repo(ref)
-    ref = ref || self.root_ref
-    commit = self.commit(ref)
-    return nil unless commit
-
-    # Build file path
-    file_name = self.path + "-" + commit.id.to_s + ".tar.gz"
-    storage_path = Rails.root.join("tmp", "repositories", self.path_with_namespace)
-    file_path = File.join(storage_path, file_name)
-
-    # Put files into a directory before archiving
-    prefix = self.path + "/"
-
-    # Create file if not exists
-    unless File.exists?(file_path)
-      FileUtils.mkdir_p storage_path
-      file = self.repo.archive_to_file(ref, prefix,  file_path)
-    end
-
-    file_path
-  end
-
-  def ssh_url_to_repo
-    url_to_repo
-  end
-
-  def http_url_to_repo
-    http_url = [Gitlab.config.gitlab.url, "/", path_with_namespace, ".git"].join('')
-  end
-
-  # Check if current branch name is marked as protected in the system
-  def protected_branch? branch_name
-    protected_branches.map(&:name).include?(branch_name)
-  end
-end
@@ -1,47 +0,0 @@
-# Provides an ActiveRecord-like interface to a model whose data is not persisted to a database.
-module StaticModel
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    # Used by ActiveRecord's polymorphic association to set object_id
-    def primary_key
-      'id'
-    end
-
-    # Used by ActiveRecord's polymorphic association to set object_type
-    def base_class
-      self
-    end
-  end
-
-  # Used by AR for fetching attributes
-  #
-  # Pass it along if we respond to it.
-  def [](key)
-    send(key) if respond_to?(key)
-  end
-
-  def to_param
-    id
-  end
-
-  def new_record?
-    false
-  end
-
-  def persisted?
-    false
-  end
-
-  def destroyed?
-    false
-  end
-
-  def ==(other)
-    if other.is_a? StaticModel
-      id == other.id
-    else
-      super
-    end
-  end
-end
@@ -1,63 +0,0 @@
-# == Team role
-#
-# Provides functionality to manage project team
-#  - add user/users to project
-#  - update existing membership
-#  - remove users from project team
-#
-# Used by Project
-#
-module Team
-  def team_member_by_name_or_email(name = nil, email = nil)
-    user = users.where("name like ? or email like ?", name, email).first
-    users_projects.where(user: user) if user
-  end
-
-  # Get Team Member record by user id
-  def team_member_by_id(user_id)
-    users_projects.find_by_user_id(user_id)
-  end
-
-  # Add user to project
-  # with passed access role
-  def add_user_to_team(user, access_role)
-    add_user_id_to_team(user.id, access_role)
-  end
-
-  # Add multiple users to project
-  # with same access role
-  def add_users_to_team(users, access_role)
-    add_users_ids_to_team(users.map(&:id), access_role)
-  end
-
-  # Add user to project
-  # with passed access role by user id
-  def add_user_id_to_team(user_id, access_role)
-    users_projects.create(
-      user_id: user_id,
-      project_access: access_role
-    )
-  end
-
-  # Add multiple users to project
-  # with same access role by user ids
-  def add_users_ids_to_team(users_ids, access_role)
-    UsersProject.bulk_import(self, users_ids, access_role)
-  end
-
-  # Update multiple project users
-  # to same access role by user ids
-  def update_users_ids_to_role(users_ids, access_role)
-    UsersProject.bulk_update(self, users_ids, access_role)
-  end
-
-  # Delete multiple users from project by user ids
-  def delete_users_ids_from_team(users_ids)
-    UsersProject.bulk_delete(self, users_ids)
-  end
-
-  # Remove all users from project team
-  def truncate_team
-    UsersProject.truncate_team(self)
-  end
-end
@@ -1,39 +0,0 @@
-# == Votes role
-#
-# Provides functionality to upvote/downvote entity
-# based on +1 and -1 notes
-#
-# Used for Issue and Merge Request
-#
-module Votes
-  # Return the number of +1 comments (upvotes)
-  def upvotes
-    notes.select(&:upvote?).size
-  end
-
-  def upvotes_in_percent
-    if votes_count.zero?
-      0
-    else
-      100.0 / votes_count * upvotes
-    end
-  end
-
-  # Return the number of -1 comments (downvotes)
-  def downvotes
-    notes.select(&:downvote?).size
-  end
-
-  def downvotes_in_percent
-    if votes_count.zero?
-      0
-    else
-      100.0 - upvotes_in_percent
-    end
-  end
-
-  # Return the total number of votes
-  def votes_count
-    upvotes + downvotes
-  end
-end
@@ -0,0 +1,11 @@
+# == Gitolited mixin
+#
+# Provide a shortcut to Gitlab::Gitolite instance by gitolite
+#
+# Used by Project, UsersProject, etc
+#
+module Gitolited
+  def gitolite
+    Gitlab::Gitolite.new
+  end
+end
@@ -0,0 +1,47 @@
+# Provides an ActiveRecord-like interface to a model whose data is not persisted to a database.
+module StaticModel
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    # Used by ActiveRecord's polymorphic association to set object_id
+    def primary_key
+      'id'
+    end
+
+    # Used by ActiveRecord's polymorphic association to set object_type
+    def base_class
+      self
+    end
+  end
+
+  # Used by AR for fetching attributes
+  #
+  # Pass it along if we respond to it.
+  def [](key)
+    send(key) if respond_to?(key)
+  end
+
+  def to_param
+    id
+  end
+
+  def new_record?
+    false
+  end
+
+  def persisted?
+    false
+  end
+
+  def destroyed?
+    false
+  end
+
+  def ==(other)
+    if other.is_a? StaticModel
+      id == other.id
+    else
+      super
+    end
+  end
+end
@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Issue, "IssueCommonality" do
+  let(:issue) { create(:issue) }
+
+  describe "Associations" do
+    it { should belong_to(:project) }
+    it { should belong_to(:author) }
+    it { should belong_to(:assignee) }
+    it { should have_many(:notes).dependent(:destroy) }
+  end
+
+  describe "Validation" do
+    it { should validate_presence_of(:project) }
+    it { should validate_presence_of(:author) }
+    it { should validate_presence_of(:title) }
+    it { should ensure_length_of(:title).is_at_least(0).is_at_most(255) }
+    it { should ensure_inclusion_of(:closed).in_array([true, false]) }
+  end
+
+  describe "Scope" do
+    it { described_class.should respond_to(:opened) }
+    it { described_class.should respond_to(:closed) }
+    it { described_class.should respond_to(:assigned) }
+  end
+
+  it "has an :author_id_of_changes accessor" do
+    issue.should respond_to(:author_id_of_changes)
+    issue.should respond_to(:author_id_of_changes=)
+  end
+
+  describe ".search" do
+    let!(:searchable_issue) { create(:issue, title: "Searchable issue") }
+
+    it "matches by title" do
+      described_class.search('able').all.should == [searchable_issue]
+    end
+  end
+
+  describe "#today?" do
+    it "returns true when created today" do
+      # Avoid timezone differences and just return exactly what we want
+      Date.stub(:today).and_return(issue.created_at.to_date)
+      issue.today?.should be_true
+    end
+
+    it "returns false when not created today" do
+      Date.stub(:today).and_return(Date.yesterday)
+      issue.today?.should be_false
+    end
+  end
+
+  describe "#new?" do
+    it "returns true when created today and record hasn't been updated" do
+      issue.stub(:today?).and_return(true)
+      issue.new?.should be_true
+    end
+
+    it "returns false when not created today" do
+      issue.stub(:today?).and_return(false)
+      issue.new?.should be_false
+    end
+
+    it "returns false when record has been updated" do
+      issue.stub(:today?).and_return(true)
+      issue.touch
+      issue.new?.should be_false
+    end
+  end
+end
@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Issue do
+  let(:issue) { create(:issue) }
+
+  describe "#upvotes" do
+    it "with no notes has a 0/0 score" do
+      issue.upvotes.should == 0
+    end
+
+    it "should recognize non-+1 notes" do
+      issue.notes << create(:note, note: "No +1 here")
+      issue.should have(1).note
+      issue.notes.first.upvote?.should be_false
+      issue.upvotes.should == 0
+    end
+
+    it "should recognize a single +1 note" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.upvotes.should == 1
+    end
+
+    it "should recognize multiple +1 notes" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.notes << create(:note, note: "+1 I want this")
+      issue.upvotes.should == 2
+    end
+  end
+
+  describe "#downvotes" do
+    it "with no notes has a 0/0 score" do
+      issue.downvotes.should == 0
+    end
+
+    it "should recognize non--1 notes" do
+      issue.notes << create(:note, note: "Almost got a -1")
+      issue.should have(1).note
+      issue.notes.first.downvote?.should be_false
+      issue.downvotes.should == 0
+    end
+
+    it "should recognize a single -1 note" do
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.downvotes.should == 1
+    end
+
+    it "should recognize multiple -1 notes" do
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.notes << create(:note, note: "-1 Away with this")
+      issue.downvotes.should == 2
+    end
+  end
+
+  describe "#votes_count" do
+    it "with no notes has a 0/0 score" do
+      issue.votes_count.should == 0
+    end
+
+    it "should recognize non notes" do
+      issue.notes << create(:note, note: "No +1 here")
+      issue.should have(1).note
+      issue.votes_count.should == 0
+    end
+
+    it "should recognize a single +1 note" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.votes_count.should == 1
+    end
+
+    it "should recognize a single -1 note" do
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.votes_count.should == 1
+    end
+
+    it "should recognize multiple notes" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.notes << create(:note, note: "+1 I want this")
+      issue.votes_count.should == 3
+    end
+  end
+
+  describe "#upvotes_in_percent" do
+    it "with no notes has a 0% score" do
+      issue.upvotes_in_percent.should == 0
+    end
+
+    it "should count a single 1 note as 100%" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.upvotes_in_percent.should == 100
+    end
+
+    it "should count multiple +1 notes as 100%" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.notes << create(:note, note: "+1 I want this")
+      issue.upvotes_in_percent.should == 100
+    end
+
+    it "should count fractions for multiple +1 and -1 notes correctly" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.notes << create(:note, note: "+1 I want this")
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.notes << create(:note, note: "+1 me too")
+      issue.upvotes_in_percent.should == 75
+    end
+  end
+
+  describe "#downvotes_in_percent" do
+    it "with no notes has a 0% score" do
+      issue.downvotes_in_percent.should == 0
+    end
+
+    it "should count a single -1 note as 100%" do
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.downvotes_in_percent.should == 100
+    end
+
+    it "should count multiple -1 notes as 100%" do
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.notes << create(:note, note: "-1 Away with this")
+      issue.downvotes_in_percent.should == 100
+    end
+
+    it "should count fractions for multiple +1 and -1 notes correctly" do
+      issue.notes << create(:note, note: "+1 This is awesome")
+      issue.notes << create(:note, note: "+1 I want this")
+      issue.notes << create(:note, note: "-1 This is bad")
+      issue.notes << create(:note, note: "+1 me too")
+      issue.downvotes_in_percent.should == 25
+    end
+  end
+end
@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe Project, "Repository" do
+  let(:project) { create(:project) }
+
+  describe "#empty_repo?" do
+    it "should return true if the repo doesn't exist" do
+      project.stub(repo_exists?: false, has_commits?: true)
+      project.should be_empty_repo
+    end
+
+    it "should return true if the repo has commits" do
+      project.stub(repo_exists?: true, has_commits?: false)
+      project.should be_empty_repo
+    end
+
+    it "should return false if the repo exists and has commits" do
+      project.stub(repo_exists?: true, has_commits?: true)
+      project.should_not be_empty_repo
+    end
+  end
+
+  describe "#discover_default_branch" do
+    let(:master) { 'master' }
+    let(:stable) { 'stable' }
+
+    it "returns 'master' when master exists" do
+      project.should_receive(:branch_names).at_least(:once).and_return([stable, master])
+      project.discover_default_branch.should == 'master'
+    end
+
+    it "returns non-master when master exists but default branch is set to something else" do
+      project.default_branch = 'stable'
+      project.should_receive(:branch_names).at_least(:once).and_return([stable, master])
+      project.discover_default_branch.should == 'stable'
+    end
+
+    it "returns a non-master branch when only one exists" do
+      project.should_receive(:branch_names).at_least(:once).and_return([stable])
+      project.discover_default_branch.should == 'stable'
+    end
+
+    it "returns nil when no branch exists" do
+      project.should_receive(:branch_names).at_least(:once).and_return([])
+      project.discover_default_branch.should be_nil
+    end
+  end
+
+  describe "#root_ref" do
+    it "returns default_branch when set" do
+      project.default_branch = 'stable'
+      project.root_ref.should == 'stable'
+    end
+
+    it "returns 'master' when default_branch is nil" do
+      project.default_branch = nil
+      project.root_ref.should == 'master'
+    end
+  end
+
+  describe "#root_ref?" do
+    it "returns true when branch is root_ref" do
+      project.default_branch = 'stable'
+      project.root_ref?('stable').should be_true
+    end
+
+    it "returns false when branch is not root_ref" do
+      project.default_branch = nil
+      project.root_ref?('stable').should be_false
+    end
+  end
+
+  describe :repo do
+    it "should return valid repo" do
+      project.repo.should be_kind_of(Grit::Repo)
+    end
+
+    it "should return nil" do
+      lambda { Project.new(path: "invalid").repo }.should raise_error(Grit::NoSuchPathError)
+    end
+
+    it "should return nil" do
+      lambda { Project.new.repo }.should raise_error(TypeError)
+    end
+  end
+
+  describe :commit do
+    it "should return first head commit if without params" do
+      project.commit.id.should == project.repo.commits.first.id
+    end
+
+    it "should return valid commit" do
+      project.commit(ValidCommit::ID).should be_valid_commit
+    end
+
+    it "should return nil" do
+      project.commit("+123_4532530XYZ").should be_nil
+    end
+  end
+
+  describe :tree do
+    before do
+      @commit = project.commit(ValidCommit::ID)
+    end
+
+    it "should raise error w/o arguments" do
+      lambda { project.tree }.should raise_error
+    end
+
+    it "should return root tree for commit" do
+      tree = project.tree(@commit)
+      tree.contents.size.should == ValidCommit::FILES_COUNT
+      tree.contents.map(&:name).should == ValidCommit::FILES
+    end
+
+    it "should return root tree for commit with correct path" do
+      tree = project.tree(@commit, ValidCommit::C_FILE_PATH)
+      tree.contents.map(&:name).should == ValidCommit::C_FILES
+    end
+
+    it "should return root tree for commit with incorrect path" do
+      project.tree(@commit, "invalid_path").should be_nil
+    end
+  end
+
+  describe "fresh commits" do
+    let(:project) { create(:project) }
+
+    it { project.fresh_commits(3).count.should == 3 }
+    it { project.fresh_commits.first.id.should == "bcf03b5de6c33f3869ef70d68cf06e679d1d7f9a" }
+    it { project.fresh_commits.last.id.should == "f403da73f5e62794a0447aca879360494b08f678" }
+  end
+
+  describe "commits_between" do
+    let(:project) { create(:project) }
+
+    subject do
+      commits = project.commits_between("3a4b4fb4cde7809f033822a171b9feae19d41fff",
+                                        "8470d70da67355c9c009e4401746b1d5410af2e3")
+      commits.map { |c| c.id }
+    end
+
+    it { should have(3).elements }
+    it { should include("f0f14c8eaba69ebddd766498a9d0b0e79becd633") }
+    it { should_not include("bcf03b5de6c33f3869ef70d68cf06e679d1d7f9a") }
+  end
+
+  describe :valid_repo? do
+    it "should be valid repo" do
+      project = create(:project)
+      project.valid_repo?.should be_true
+    end
+
+    it "should be invalid repo" do
+      project = Project.new(name: "ok_name", path: "/INVALID_PATH/", path: "NEOK")
+      project.valid_repo?.should be_false
+    end
+  end
+end
@@ -133,14 +133,6 @@ describe Project do
     it { should respond_to(:path_with_namespace) }
   end
-  describe 'modules' do
-    it { should include_module(Repository) }
-    it { should include_module(PushObserver) }
-    it { should include_module(Authority) }
-    it { should include_module(Team) }
-    it { should include_module(NamespacedProject) }
-  end
-
   it "should return valid url to repo" do
     project = Project.new(path: "somewhere")
     project.url_to_repo.should == Gitlab.config.gitolite.ssh_path_prefix + "somewhere.git"
@@ -65,10 +65,6 @@ describe User do
     it { should ensure_length_of(:bio).is_within(0..255) }
   end
-  describe 'modules' do
-    it { should include_module(Account) }
-  end
-
   describe "Respond to" do
     it { should respond_to(:is_admin?) }
     it { should respond_to(:identifier) }
@@ -185,4 +181,14 @@ describe User do
     it { User.not_in_project(@project).should == [@user, @project.owner] }
   end
+
+  describe 'normal user' do
+    let(:user) { create(:user, name: 'John Smith') }
+
+    it { user.is_admin?.should be_false }
+    it { user.require_ssh_key?.should be_true }
+    it { user.can_create_group?.should be_false }
+    it { user.can_create_project?.should be_true }
+    it { user.first_name.should == 'John' }
+  end
 end
@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe User, "Account" do
-  describe 'normal user' do
-    let(:user) { create(:user, name: 'John Smith') }
-
-    it { user.is_admin?.should be_false }
-    it { user.require_ssh_key?.should be_true }
-    it { user.can_create_group?.should be_false }
-    it { user.can_create_project?.should be_true }
-    it { user.first_name.should == 'John' }
-  end
-end
@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe Issue, "IssueCommonality" do
-  let(:issue) { create(:issue) }
-
-  describe "Associations" do
-    it { should belong_to(:project) }
-    it { should belong_to(:author) }
-    it { should belong_to(:assignee) }
-    it { should have_many(:notes).dependent(:destroy) }
-  end
-
-  describe "Validation" do
-    it { should validate_presence_of(:project) }
-    it { should validate_presence_of(:author) }
-    it { should validate_presence_of(:title) }
-    it { should ensure_length_of(:title).is_at_least(0).is_at_most(255) }
-    it { should ensure_inclusion_of(:closed).in_array([true, false]) }
-  end
-
-  describe "Scope" do
-    it { described_class.should respond_to(:opened) }
-    it { described_class.should respond_to(:closed) }
-    it { described_class.should respond_to(:assigned) }
-  end
-
-  it "has an :author_id_of_changes accessor" do
-    issue.should respond_to(:author_id_of_changes)
-    issue.should respond_to(:author_id_of_changes=)
-  end
-
-  describe ".search" do
-    let!(:searchable_issue) { create(:issue, title: "Searchable issue") }
-
-    it "matches by title" do
-      described_class.search('able').all.should == [searchable_issue]
-    end
-  end
-
-  describe "#today?" do
-    it "returns true when created today" do
-      # Avoid timezone differences and just return exactly what we want
-      Date.stub(:today).and_return(issue.created_at.to_date)
-      issue.today?.should be_true
-    end
-
-    it "returns false when not created today" do
-      Date.stub(:today).and_return(Date.yesterday)
-      issue.today?.should be_false
-    end
-  end
-
-  describe "#new?" do
-    it "returns true when created today and record hasn't been updated" do
-      issue.stub(:today?).and_return(true)
-      issue.new?.should be_true
-    end
-
-    it "returns false when not created today" do
-      issue.stub(:today?).and_return(false)
-      issue.new?.should be_false
-    end
-
-    it "returns false when record has been updated" do
-      issue.stub(:today?).and_return(true)
-      issue.touch
-      issue.new?.should be_false
-    end
-  end
-end
@@ -1,159 +0,0 @@
-require 'spec_helper'
-
-describe Project, "Repository" do
-  let(:project) { create(:project) }
-
-  describe "#empty_repo?" do
-    it "should return true if the repo doesn't exist" do
-      project.stub(repo_exists?: false, has_commits?: true)
-      project.should be_empty_repo
-    end
-
-    it "should return true if the repo has commits" do
-      project.stub(repo_exists?: true, has_commits?: false)
-      project.should be_empty_repo
-    end
-
-    it "should return false if the repo exists and has commits" do
-      project.stub(repo_exists?: true, has_commits?: true)
-      project.should_not be_empty_repo
-    end
-  end
-
-  describe "#discover_default_branch" do
-    let(:master) { 'master' }
-    let(:stable) { 'stable' }
-
-    it "returns 'master' when master exists" do
-      project.should_receive(:branch_names).at_least(:once).and_return([stable, master])
-      project.discover_default_branch.should == 'master'
-    end
-
-    it "returns non-master when master exists but default branch is set to something else" do
-      project.default_branch = 'stable'
-      project.should_receive(:branch_names).at_least(:once).and_return([stable, master])
-      project.discover_default_branch.should == 'stable'
-    end
-
-    it "returns a non-master branch when only one exists" do
-      project.should_receive(:branch_names).at_least(:once).and_return([stable])
-      project.discover_default_branch.should == 'stable'
-    end
-
-    it "returns nil when no branch exists" do
-      project.should_receive(:branch_names).at_least(:once).and_return([])
-      project.discover_default_branch.should be_nil
-    end
-  end
-
-  describe "#root_ref" do
-    it "returns default_branch when set" do
-      project.default_branch = 'stable'
-      project.root_ref.should == 'stable'
-    end
-
-    it "returns 'master' when default_branch is nil" do
-      project.default_branch = nil
-      project.root_ref.should == 'master'
-    end
-  end
-
-  describe "#root_ref?" do
-    it "returns true when branch is root_ref" do
-      project.default_branch = 'stable'
-      project.root_ref?('stable').should be_true
-    end
-
-    it "returns false when branch is not root_ref" do
-      project.default_branch = nil
-      project.root_ref?('stable').should be_false
-    end
-  end
-
-  describe :repo do
-    it "should return valid repo" do
-      project.repo.should be_kind_of(Grit::Repo)
-    end
-
-    it "should return nil" do
-      lambda { Project.new(path: "invalid").repo }.should raise_error(Grit::NoSuchPathError)
-    end
-
-    it "should return nil" do
-      lambda { Project.new.repo }.should raise_error(TypeError)
-    end
-  end
-
-  describe :commit do
-    it "should return first head commit if without params" do
-      project.commit.id.should == project.repo.commits.first.id
-    end
-
-    it "should return valid commit" do
-      project.commit(ValidCommit::ID).should be_valid_commit
-    end
-
-    it "should return nil" do
-      project.commit("+123_4532530XYZ").should be_nil
-    end
-  end
-
-  describe :tree do
-    before do
-      @commit = project.commit(ValidCommit::ID)
-    end
-
-    it "should raise error w/o arguments" do
-      lambda { project.tree }.should raise_error
-    end
-
-    it "should return root tree for commit" do
-      tree = project.tree(@commit)
-      tree.contents.size.should == ValidCommit::FILES_COUNT
-      tree.contents.map(&:name).should == ValidCommit::FILES
-    end
-
-    it "should return root tree for commit with correct path" do
-      tree = project.tree(@commit, ValidCommit::C_FILE_PATH)
-      tree.contents.map(&:name).should == ValidCommit::C_FILES
-    end
-
-    it "should return root tree for commit with incorrect path" do
-      project.tree(@commit, "invalid_path").should be_nil
-    end
-  end
-
-  describe "fresh commits" do
-    let(:project) { create(:project) }
-
-    it { project.fresh_commits(3).count.should == 3 }
-    it { project.fresh_commits.first.id.should == "bcf03b5de6c33f3869ef70d68cf06e679d1d7f9a" }
-    it { project.fresh_commits.last.id.should == "f403da73f5e62794a0447aca879360494b08f678" }
-  end
-
-  describe "commits_between" do
-    let(:project) { create(:project) }
-
-    subject do
-      commits = project.commits_between("3a4b4fb4cde7809f033822a171b9feae19d41fff",
-                                        "8470d70da67355c9c009e4401746b1d5410af2e3")
-      commits.map { |c| c.id }
-    end
-
-    it { should have(3).elements }
-    it { should include("f0f14c8eaba69ebddd766498a9d0b0e79becd633") }
-    it { should_not include("bcf03b5de6c33f3869ef70d68cf06e679d1d7f9a") }
-  end
-
-  describe :valid_repo? do
-    it "should be valid repo" do
-      project = create(:project)
-      project.valid_repo?.should be_true
-    end
-
-    it "should be invalid repo" do
-      project = Project.new(name: "ok_name", path: "/INVALID_PATH/", path: "NEOK")
-      project.valid_repo?.should be_false
-    end
-  end
-end
@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-describe Issue do
-  let(:issue) { create(:issue) }
-
-  describe "#upvotes" do
-    it "with no notes has a 0/0 score" do
-      issue.upvotes.should == 0
-    end
-
-    it "should recognize non-+1 notes" do
-      issue.notes << create(:note, note: "No +1 here")
-      issue.should have(1).note
-      issue.notes.first.upvote?.should be_false
-      issue.upvotes.should == 0
-    end
-
-    it "should recognize a single +1 note" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.upvotes.should == 1
-    end
-
-    it "should recognize multiple +1 notes" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.notes << create(:note, note: "+1 I want this")
-      issue.upvotes.should == 2
-    end
-  end
-
-  describe "#downvotes" do
-    it "with no notes has a 0/0 score" do
-      issue.downvotes.should == 0
-    end
-
-    it "should recognize non--1 notes" do
-      issue.notes << create(:note, note: "Almost got a -1")
-      issue.should have(1).note
-      issue.notes.first.downvote?.should be_false
-      issue.downvotes.should == 0
-    end
-
-    it "should recognize a single -1 note" do
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.downvotes.should == 1
-    end
-
-    it "should recognize multiple -1 notes" do
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.notes << create(:note, note: "-1 Away with this")
-      issue.downvotes.should == 2
-    end
-  end
-
-  describe "#votes_count" do
-    it "with no notes has a 0/0 score" do
-      issue.votes_count.should == 0
-    end
-
-    it "should recognize non notes" do
-      issue.notes << create(:note, note: "No +1 here")
-      issue.should have(1).note
-      issue.votes_count.should == 0
-    end
-
-    it "should recognize a single +1 note" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.votes_count.should == 1
-    end
-
-    it "should recognize a single -1 note" do
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.votes_count.should == 1
-    end
-
-    it "should recognize multiple notes" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.notes << create(:note, note: "+1 I want this")
-      issue.votes_count.should == 3
-    end
-  end
-
-  describe "#upvotes_in_percent" do
-    it "with no notes has a 0% score" do
-      issue.upvotes_in_percent.should == 0
-    end
-
-    it "should count a single 1 note as 100%" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.upvotes_in_percent.should == 100
-    end
-
-    it "should count multiple +1 notes as 100%" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.notes << create(:note, note: "+1 I want this")
-      issue.upvotes_in_percent.should == 100
-    end
-
-    it "should count fractions for multiple +1 and -1 notes correctly" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.notes << create(:note, note: "+1 I want this")
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.notes << create(:note, note: "+1 me too")
-      issue.upvotes_in_percent.should == 75
-    end
-  end
-
-  describe "#downvotes_in_percent" do
-    it "with no notes has a 0% score" do
-      issue.downvotes_in_percent.should == 0
-    end
-
-    it "should count a single -1 note as 100%" do
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.downvotes_in_percent.should == 100
-    end
-
-    it "should count multiple -1 notes as 100%" do
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.notes << create(:note, note: "-1 Away with this")
-      issue.downvotes_in_percent.should == 100
-    end
-
-    it "should count fractions for multiple +1 and -1 notes correctly" do
-      issue.notes << create(:note, note: "+1 This is awesome")
-      issue.notes << create(:note, note: "+1 I want this")
-      issue.notes << create(:note, note: "-1 This is bad")
-      issue.notes << create(:note, note: "+1 me too")
-      issue.downvotes_in_percent.should == 25
-    end
-  end
-end
 # Stubs out all Git repository access done by models so that specs can run
 # against fake repositories without Grit complaining that they don't exist.
-module StubbedRepository
+class Project
   def path_to_repo
     if new_record? || path == 'newproject'
       # There are a couple Project specs and features that expect the Project's
@@ -27,5 +27,3 @@ module StubbedRepository
     end
   end
 end
-
-Project.send(:include, StubbedRepository)
@@ -0,0 +1,102 @@		@@ -0,0 +1,102 @@
	1	+# == Issuable concern
	2	+#
	3	+# Contains common functionality shared between Issues and MergeRequests
	4	+#
	5	+# Used by Issue, MergeRequest
	6	+#
	7	+module Issuable
	8	+ extend ActiveSupport::Concern
	9	+
	10	+ included do
	11	+ belongs_to :project
	12	+ belongs_to :author, class_name: "User"
	13	+ belongs_to :assignee, class_name: "User"
	14	+ belongs_to :milestone
	15	+ has_many :notes, as: :noteable, dependent: :destroy
	16	+
	17	+ validates :project, presence: true
	18	+ validates :author, presence: true
	19	+ validates :title, presence: true, length: { within: 0..255 }
	20	+ validates :closed, inclusion: { in: [true, false] }
	21	+
	22	+ scope :opened, where(closed: false)
	23	+ scope :closed, where(closed: true)
	24	+ scope :of_group, ->(group) { where(project_id: group.project_ids) }
	25	+ scope :assigned, ->(u) { where(assignee_id: u.id)}
	26	+ scope :recent, order("created_at DESC")
	27	+
	28	+ delegate :name,
	29	+ :email,
	30	+ to: :author,
	31	+ prefix: true
	32	+
	33	+ delegate :name,
	34	+ :email,
	35	+ to: :assignee,
	36	+ allow_nil: true,
	37	+ prefix: true
	38	+
	39	+ attr_accessor :author_id_of_changes
	40	+ end
	41	+
	42	+ module ClassMethods
	43	+ def search(query)
	44	+ where("title like :query", query: "%#{query}%")
	45	+ end
	46	+ end
	47	+
	48	+ def today?
	49	+ Date.today == created_at.to_date
	50	+ end
	51	+
	52	+ def new?
	53	+ today? && created_at == updated_at
	54	+ end
	55	+
	56	+ def is_assigned?
	57	+ !!assignee_id
	58	+ end
	59	+
	60	+ def is_being_reassigned?
	61	+ assignee_id_changed?
	62	+ end
	63	+
	64	+ def is_being_closed?
	65	+ closed_changed? && closed
	66	+ end
	67	+
	68	+ def is_being_reopened?
	69	+ closed_changed? && !closed
	70	+ end
	71	+
	72	+ # Return the number of +1 comments (upvotes)
	73	+ def upvotes
	74	+ notes.select(&:upvote?).size
	75	+ end
	76	+
	77	+ def upvotes_in_percent
	78	+ if votes_count.zero?
	79	+ 0
	80	+ else
	81	+ 100.0 / votes_count * upvotes
	82	+ end
	83	+ end
	84	+
	85	+ # Return the number of -1 comments (downvotes)
	86	+ def downvotes
	87	+ notes.select(&:downvote?).size
	88	+ end
	89	+
	90	+ def downvotes_in_percent
	91	+ if votes_count.zero?
	92	+ 0
	93	+ else
	94	+ 100.0 - upvotes_in_percent
	95	+ end
	96	+ end
	97	+
	98	+ # Return the total number of votes
	99	+ def votes_count
	100	+ upvotes + downvotes
	101	+ end
	102	+end
	@@ -15,9 +15,6 @@		@@ -15,9 +15,6 @@
15	#	15	#
16		16
17	class Event < ActiveRecord::Base	17	class Event < ActiveRecord::Base
18	- include NoteEvent
19	- include PushEvent
20	-
21	attr_accessible :project, :action, :data, :author_id, :project_id,	18	attr_accessible :project, :action, :data, :author_id, :project_id,
22	:target_id, :target_type	19	:target_id, :target_type
23		20
	@@ -170,4 +167,139 @@ class Event < ActiveRecord::Base		@@ -170,4 +167,139 @@ class Event < ActiveRecord::Base
170	"opened"	167	"opened"
171	end	168	end
172	end	169	end
		170	+
		171	+ def valid_push?
		172	+ data[:ref]
		173	+ rescue => ex
		174	+ false
		175	+ end
		176	+
		177	+ def tag?
		178	+ data[:ref]["refs/tags"]
		179	+ end
		180	+
		181	+ def branch?
		182	+ data[:ref]["refs/heads"]
		183	+ end
		184	+
		185	+ def new_branch?
		186	+ commit_from =~ /^00000/
		187	+ end
		188	+
		189	+ def new_ref?
		190	+ commit_from =~ /^00000/
		191	+ end
		192	+
		193	+ def rm_ref?
		194	+ commit_to =~ /^00000/
		195	+ end
		196	+
		197	+ def md_ref?
		198	+ !(rm_ref? \|\| new_ref?)
		199	+ end
		200	+
		201	+ def commit_from
		202	+ data[:before]
		203	+ end
		204	+
		205	+ def commit_to
		206	+ data[:after]
		207	+ end
		208	+
		209	+ def ref_name
		210	+ if tag?
		211	+ tag_name
		212	+ else
		213	+ branch_name
		214	+ end
		215	+ end
		216	+
		217	+ def branch_name
		218	+ @branch_name \|\|= data[:ref].gsub("refs/heads/", "")
		219	+ end
		220	+
		221	+ def tag_name
		222	+ @tag_name \|\|= data[:ref].gsub("refs/tags/", "")
		223	+ end
		224	+
		225	+ # Max 20 commits from push DESC
		226	+ def commits
		227	+ @commits \|\|= data[:commits].map { \|commit\| project.commit(commit[:id]) }.reverse
		228	+ end
		229	+
		230	+ def commits_count
		231	+ data[:total_commits_count] \|\| commits.count \|\| 0
		232	+ end
		233	+
		234	+ def ref_type
		235	+ tag? ? "tag" : "branch"
		236	+ end
		237	+
		238	+ def push_action_name
		239	+ if new_ref?
		240	+ "pushed new"
		241	+ elsif rm_ref?
		242	+ "deleted"
		243	+ else
		244	+ "pushed to"
		245	+ end
		246	+ end
		247	+
		248	+ def parent_commit
		249	+ project.commit(commit_from)
		250	+ rescue => ex
		251	+ nil
		252	+ end
		253	+
		254	+ def last_commit
		255	+ project.commit(commit_to)
		256	+ rescue => ex
		257	+ nil
		258	+ end
		259	+
		260	+ def push_with_commits?
		261	+ md_ref? && commits.any? && parent_commit && last_commit
		262	+ rescue Grit::NoSuchPathError
		263	+ false
		264	+ end
		265	+
		266	+ def last_push_to_non_root?
		267	+ branch? && project.default_branch != branch_name
		268	+ end
		269	+
		270	+ def note_commit_id
		271	+ target.commit_id
		272	+ end
		273	+
		274	+ def note_short_commit_id
		275	+ note_commit_id[0..8]
		276	+ end
		277	+
		278	+ def note_commit?
		279	+ target.noteable_type == "Commit"
		280	+ end
		281	+
		282	+ def note_target
		283	+ target.noteable
		284	+ end
		285	+
		286	+ def note_target_id
		287	+ if note_commit?
		288	+ target.commit_id
		289	+ else
		290	+ target.noteable_id.to_s
		291	+ end
		292	+ end
		293	+
		294	+ def wall_note?
		295	+ target.noteable_type.blank?
		296	+ end
		297	+
		298	+ def note_target_type
		299	+ if target.noteable_type.present?
		300	+ target.noteable_type.titleize
		301	+ else
		302	+ "Wall"
		303	+ end.downcase
		304	+ end
173	end	305	end
	@@ -17,8 +17,7 @@		@@ -17,8 +17,7 @@
17	#	17	#
18		18
19	class Issue < ActiveRecord::Base	19	class Issue < ActiveRecord::Base
20	- include IssueCommonality
21	- include Votes	20	+ include Issuable
22		21
23	attr_accessible :title, :assignee_id, :closed, :position, :description,	22	attr_accessible :title, :assignee_id, :closed, :position, :description,
24	:milestone_id, :label_list, :author_id_of_changes	23	:milestone_id, :label_list, :author_id_of_changes
	@@ -21,11 +21,7 @@		@@ -21,11 +21,7 @@
21	require "grit"	21	require "grit"
22		22
23	class Project < ActiveRecord::Base	23	class Project < ActiveRecord::Base
24	- include Repository
25	- include PushObserver
26	- include Authority
27	- include Team
28	- include NamespacedProject	24	+ include Gitolited
29		25
30	class TransferError < StandardError; end	26	class TransferError < StandardError; end
31		27
	@@ -277,4 +273,514 @@ class Project < ActiveRecord::Base		@@ -277,4 +273,514 @@ class Project < ActiveRecord::Base
277	creator	273	creator
278	end	274	end
279	end	275	end
		276	+
		277	+ def team_member_by_name_or_email(name = nil, email = nil)
		278	+ user = users.where("name like ? or email like ?", name, email).first
		279	+ users_projects.where(user: user) if user
		280	+ end
		281	+
		282	+ # Get Team Member record by user id
		283	+ def team_member_by_id(user_id)
		284	+ users_projects.find_by_user_id(user_id)
		285	+ end
		286	+
		287	+ # Add user to project
		288	+ # with passed access role
		289	+ def add_user_to_team(user, access_role)
		290	+ add_user_id_to_team(user.id, access_role)
		291	+ end
		292	+
		293	+ # Add multiple users to project
		294	+ # with same access role
		295	+ def add_users_to_team(users, access_role)
		296	+ add_users_ids_to_team(users.map(&:id), access_role)
		297	+ end
		298	+
		299	+ # Add user to project
		300	+ # with passed access role by user id
		301	+ def add_user_id_to_team(user_id, access_role)
		302	+ users_projects.create(
		303	+ user_id: user_id,
		304	+ project_access: access_role
		305	+ )
		306	+ end
		307	+
		308	+ # Add multiple users to project
		309	+ # with same access role by user ids
		310	+ def add_users_ids_to_team(users_ids, access_role)
		311	+ UsersProject.bulk_import(self, users_ids, access_role)
		312	+ end
		313	+
		314	+ # Update multiple project users
		315	+ # to same access role by user ids
		316	+ def update_users_ids_to_role(users_ids, access_role)
		317	+ UsersProject.bulk_update(self, users_ids, access_role)
		318	+ end
		319	+
		320	+ # Delete multiple users from project by user ids
		321	+ def delete_users_ids_from_team(users_ids)
		322	+ UsersProject.bulk_delete(self, users_ids)
		323	+ end
		324	+
		325	+ # Remove all users from project team
		326	+ def truncate_team
		327	+ UsersProject.truncate_team(self)
		328	+ end
		329	+
		330	+ # Compatible with all access rights
		331	+ # Should be rewrited for new access rights
		332	+ def add_access(user, *access)
		333	+ access = if access.include?(:admin)
		334	+ { project_access: UsersProject::MASTER }
		335	+ elsif access.include?(:write)
		336	+ { project_access: UsersProject::DEVELOPER }
		337	+ else
		338	+ { project_access: UsersProject::REPORTER }
		339	+ end
		340	+ opts = { user: user }
		341	+ opts.merge!(access)
		342	+ users_projects.create(opts)
		343	+ end
		344	+
		345	+ def reset_access(user)
		346	+ users_projects.where(project_id: self.id, user_id: user.id).destroy if self.id
		347	+ end
		348	+
		349	+ def repository_readers
		350	+ repository_members[UsersProject::REPORTER]
		351	+ end
		352	+
		353	+ def repository_writers
		354	+ repository_members[UsersProject::DEVELOPER]
		355	+ end
		356	+
		357	+ def repository_masters
		358	+ repository_members[UsersProject::MASTER]
		359	+ end
		360	+
		361	+ def repository_members
		362	+ keys = Hash.new {\|h,k\| h[k] = [] }
		363	+ UsersProject.select("keys.identifier, project_access").
		364	+ joins(user: :keys).where(project_id: id).
		365	+ each {\|row\| keys[row.project_access] << [row.identifier] }
		366	+
		367	+ keys[UsersProject::REPORTER] += deploy_keys.pluck(:identifier)
		368	+ keys
		369	+ end
		370	+
		371	+ def allow_read_for?(user)
		372	+ !users_projects.where(user_id: user.id).empty?
		373	+ end
		374	+
		375	+ def guest_access_for?(user)
		376	+ !users_projects.where(user_id: user.id).empty?
		377	+ end
		378	+
		379	+ def report_access_for?(user)
		380	+ !users_projects.where(user_id: user.id, project_access: [UsersProject::REPORTER, UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
		381	+ end
		382	+
		383	+ def dev_access_for?(user)
		384	+ !users_projects.where(user_id: user.id, project_access: [UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
		385	+ end
		386	+
		387	+ def master_access_for?(user)
		388	+ !users_projects.where(user_id: user.id, project_access: [UsersProject::MASTER]).empty?
		389	+ end
		390	+
		391	+ def transfer(new_namespace)
		392	+ Project.transaction do
		393	+ old_namespace = namespace
		394	+ self.namespace = new_namespace
		395	+
		396	+ old_dir = old_namespace.try(:path) \|\| ''
		397	+ new_dir = new_namespace.try(:path) \|\| ''
		398	+
		399	+ old_repo = if old_dir.present?
		400	+ File.join(old_dir, self.path)
		401	+ else
		402	+ self.path
		403	+ end
		404	+
		405	+ if Project.where(path: self.path, namespace_id: new_namespace.try(:id)).present?
		406	+ raise TransferError.new("Project with same path in target namespace already exists")
		407	+ end
		408	+
		409	+ Gitlab::ProjectMover.new(self, old_dir, new_dir).execute
		410	+
		411	+ gitolite.move_repository(old_repo, self)
		412	+
		413	+ save!
		414	+ end
		415	+ rescue Gitlab::ProjectMover::ProjectMoveError => ex
		416	+ raise Project::TransferError.new(ex.message)
		417	+ end
		418	+
		419	+ def name_with_namespace
		420	+ @name_with_namespace \|\|= begin
		421	+ if namespace
		422	+ namespace.human_name + " / " + name
		423	+ else
		424	+ name
		425	+ end
		426	+ end
		427	+ end
		428	+
		429	+ def namespace_owner
		430	+ namespace.try(:owner)
		431	+ end
		432	+
		433	+ def path_with_namespace
		434	+ if namespace
		435	+ namespace.path + '/' + path
		436	+ else
		437	+ path
		438	+ end
		439	+ end
		440	+
		441	+ # This method will be called after each post receive and only if the provided
		442	+ # user is present in GitLab.
		443	+ #
		444	+ # All callbacks for post receive should be placed here.
		445	+ def trigger_post_receive(oldrev, newrev, ref, user)
		446	+ data = post_receive_data(oldrev, newrev, ref, user)
		447	+
		448	+ # Create push event
		449	+ self.observe_push(data)
		450	+
		451	+ if push_to_branch? ref, oldrev
		452	+ # Close merged MR
		453	+ self.update_merge_requests(oldrev, newrev, ref, user)
		454	+
		455	+ # Execute web hooks
		456	+ self.execute_hooks(data.dup)
		457	+
		458	+ # Execute project services
		459	+ self.execute_services(data.dup)
		460	+ end
		461	+
		462	+ # Create satellite
		463	+ self.satellite.create unless self.satellite.exists?
		464	+
		465	+ # Discover the default branch, but only if it hasn't already been set to
		466	+ # something else
		467	+ if default_branch.nil?
		468	+ update_attributes(default_branch: discover_default_branch)
		469	+ end
		470	+ end
		471	+
		472	+ def push_to_branch? ref, oldrev
		473	+ ref_parts = ref.split('/')
		474	+
		475	+ # Return if this is not a push to a branch (e.g. new commits)
		476	+ !(ref_parts[1] !~ /heads/ \|\| oldrev == "00000000000000000000000000000000")
		477	+ end
		478	+
		479	+ def observe_push(data)
		480	+ Event.create(
		481	+ project: self,
		482	+ action: Event::Pushed,
		483	+ data: data,
		484	+ author_id: data[:user_id]
		485	+ )
		486	+ end
		487	+
		488	+ def execute_hooks(data)
		489	+ hooks.each { \|hook\| hook.execute(data) }
		490	+ end
		491	+
		492	+ def execute_services(data)
		493	+ services.each do \|service\|
		494	+
		495	+ # Call service hook only if it is active
		496	+ service.execute(data) if service.active
		497	+ end
		498	+ end
		499	+
		500	+ # Produce a hash of post-receive data
		501	+ #
		502	+ # data = {
		503	+ # before: String,
		504	+ # after: String,
		505	+ # ref: String,
		506	+ # user_id: String,
		507	+ # user_name: String,
		508	+ # repository: {
		509	+ # name: String,
		510	+ # url: String,
		511	+ # description: String,
		512	+ # homepage: String,
		513	+ # },
		514	+ # commits: Array,
		515	+ # total_commits_count: Fixnum
		516	+ # }
		517	+ #
		518	+ def post_receive_data(oldrev, newrev, ref, user)
		519	+
		520	+ push_commits = commits_between(oldrev, newrev)
		521	+
		522	+ # Total commits count
		523	+ push_commits_count = push_commits.size
		524	+
		525	+ # Get latest 20 commits ASC
		526	+ push_commits_limited = push_commits.last(20)
		527	+
		528	+ # Hash to be passed as post_receive_data
		529	+ data = {
		530	+ before: oldrev,
		531	+ after: newrev,
		532	+ ref: ref,
		533	+ user_id: user.id,
		534	+ user_name: user.name,
		535	+ repository: {
		536	+ name: name,
		537	+ url: url_to_repo,
		538	+ description: description,
		539	+ homepage: web_url,
		540	+ },
		541	+ commits: [],
		542	+ total_commits_count: push_commits_count
		543	+ }
		544	+
		545	+ # For perfomance purposes maximum 20 latest commits
		546	+ # will be passed as post receive hook data.
		547	+ #
		548	+ push_commits_limited.each do \|commit\|
		549	+ data[:commits] << {
		550	+ id: commit.id,
		551	+ message: commit.safe_message,
		552	+ timestamp: commit.date.xmlschema,
		553	+ url: "#{Gitlab.config.gitlab.url}/#{path_with_namespace}/commit/#{commit.id}",
		554	+ author: {
		555	+ name: commit.author_name,
		556	+ email: commit.author_email
		557	+ }
		558	+ }
		559	+ end
		560	+
		561	+ data
		562	+ end
		563	+
		564	+ def update_merge_requests(oldrev, newrev, ref, user)
		565	+ return true unless ref =~ /heads/
		566	+ branch_name = ref.gsub("refs/heads/", "")
		567	+ c_ids = self.commits_between(oldrev, newrev).map(&:id)
		568	+
		569	+ # Update code for merge requests
		570	+ mrs = self.merge_requests.opened.find_all_by_branch(branch_name).all
		571	+ mrs.each { \|merge_request\| merge_request.reload_code; merge_request.mark_as_unchecked }
		572	+
		573	+ # Close merge requests
		574	+ mrs = self.merge_requests.opened.where(target_branch: branch_name).all
		575	+ mrs = mrs.select(&:last_commit).select { \|mr\| c_ids.include?(mr.last_commit.id) }
		576	+ mrs.each { \|merge_request\| merge_request.merge!(user.id) }
		577	+
		578	+ true
		579	+ end
		580	+
		581	+ def valid_repo?
		582	+ repo
		583	+ rescue
		584	+ errors.add(:path, "Invalid repository path")
		585	+ false
		586	+ end
		587	+
		588	+ def empty_repo?
		589	+ !repo_exists? \|\| !has_commits?
		590	+ end
		591	+
		592	+ def commit(commit_id = nil)
		593	+ Commit.find_or_first(repo, commit_id, root_ref)
		594	+ end
		595	+
		596	+ def fresh_commits(n = 10)
		597	+ Commit.fresh_commits(repo, n)
		598	+ end
		599	+
		600	+ def commits_with_refs(n = 20)
		601	+ Commit.commits_with_refs(repo, n)
		602	+ end
		603	+
		604	+ def commits_since(date)
		605	+ Commit.commits_since(repo, date)
		606	+ end
		607	+
		608	+ def commits(ref, path = nil, limit = nil, offset = nil)
		609	+ Commit.commits(repo, ref, path, limit, offset)
		610	+ end
		611	+
		612	+ def last_commit_for(ref, path = nil)
		613	+ commits(ref, path, 1).first
		614	+ end
		615	+
		616	+ def commits_between(from, to)
		617	+ Commit.commits_between(repo, from, to)
		618	+ end
		619	+
		620	+ def satellite
		621	+ @satellite \|\|= Gitlab::Satellite::Satellite.new(self)
		622	+ end
		623	+
		624	+ def has_post_receive_file?
		625	+ !!hook_file
		626	+ end
		627	+
		628	+ def valid_post_receive_file?
		629	+ valid_hook_file == hook_file
		630	+ end
		631	+
		632	+ def valid_hook_file
		633	+ @valid_hook_file \|\|= File.read(Rails.root.join('lib', 'hooks', 'post-receive'))
		634	+ end
		635	+
		636	+ def hook_file
		637	+ @hook_file \|\|= begin
		638	+ hook_path = File.join(path_to_repo, 'hooks', 'post-receive')
		639	+ File.read(hook_path) if File.exists?(hook_path)
		640	+ end
		641	+ end
		642	+
		643	+ # Returns an Array of branch names
		644	+ def branch_names
		645	+ repo.branches.collect(&:name).sort
		646	+ end
		647	+
		648	+ # Returns an Array of Branches
		649	+ def branches
		650	+ repo.branches.sort_by(&:name)
		651	+ end
		652	+
		653	+ # Returns an Array of tag names
		654	+ def tag_names
		655	+ repo.tags.collect(&:name).sort.reverse
		656	+ end
		657	+
		658	+ # Returns an Array of Tags
		659	+ def tags
		660	+ repo.tags.sort_by(&:name).reverse
		661	+ end
		662	+
		663	+ # Returns an Array of branch and tag names
		664	+ def ref_names
		665	+ [branch_names + tag_names].flatten
		666	+ end
		667	+
		668	+ def repo
		669	+ @repo \|\|= Grit::Repo.new(path_to_repo)
		670	+ end
		671	+
		672	+ def url_to_repo
		673	+ gitolite.url_to_repo(path_with_namespace)
		674	+ end
		675	+
		676	+ def path_to_repo
		677	+ File.join(Gitlab.config.gitolite.repos_path, "#{path_with_namespace}.git")
		678	+ end
		679	+
		680	+ def namespace_dir
		681	+ namespace.try(:path) \|\| ''
		682	+ end
		683	+
		684	+ def update_repository
		685	+ gitolite.update_repository(self)
		686	+ end
		687	+
		688	+ def destroy_repository
		689	+ gitolite.remove_repository(self)
		690	+ end
		691	+
		692	+ def repo_exists?
		693	+ @repo_exists \|\|= (repo && !repo.branches.empty?)
		694	+ rescue
		695	+ @repo_exists = false
		696	+ end
		697	+
		698	+ def heads
		699	+ @heads \|\|= repo.heads
		700	+ end
		701	+
		702	+ def tree(fcommit, path = nil)
		703	+ fcommit = commit if fcommit == :head
		704	+ tree = fcommit.tree
		705	+ path ? (tree / path) : tree
		706	+ end
		707	+
		708	+ def open_branches
		709	+ if protected_branches.empty?
		710	+ self.repo.heads
		711	+ else
		712	+ pnames = protected_branches.map(&:name)
		713	+ self.repo.heads.reject { \|h\| pnames.include?(h.name) }
		714	+ end.sort_by(&:name)
		715	+ end
		716	+
		717	+ # Discovers the default branch based on the repository's available branches
		718	+ #
		719	+ # - If no branches are present, returns nil
		720	+ # - If one branch is present, returns its name
		721	+ # - If two or more branches are present, returns the one that has a name
		722	+ # matching root_ref (default_branch or 'master' if default_branch is nil)
		723	+ def discover_default_branch
		724	+ if branch_names.length == 0
		725	+ nil
		726	+ elsif branch_names.length == 1
		727	+ branch_names.first
		728	+ else
		729	+ branch_names.select { \|v\| v == root_ref }.first
		730	+ end
		731	+ end
		732	+
		733	+ def has_commits?
		734	+ !!commit
		735	+ rescue Grit::NoSuchPathError
		736	+ false
		737	+ end
		738	+
		739	+ def root_ref
		740	+ default_branch \|\| "master"
		741	+ end
		742	+
		743	+ def root_ref?(branch)
		744	+ root_ref == branch
		745	+ end
		746	+
		747	+ # Archive Project to .tar.gz
		748	+ #
		749	+ # Already packed repo archives stored at
		750	+ # app_root/tmp/repositories/project_name/project_name-commit-id.tag.gz
		751	+ #
		752	+ def archive_repo(ref)
		753	+ ref = ref \|\| self.root_ref
		754	+ commit = self.commit(ref)
		755	+ return nil unless commit
		756	+
		757	+ # Build file path
		758	+ file_name = self.path + "-" + commit.id.to_s + ".tar.gz"
		759	+ storage_path = Rails.root.join("tmp", "repositories", self.path_with_namespace)
		760	+ file_path = File.join(storage_path, file_name)
		761	+
		762	+ # Put files into a directory before archiving
		763	+ prefix = self.path + "/"
		764	+
		765	+ # Create file if not exists
		766	+ unless File.exists?(file_path)
		767	+ FileUtils.mkdir_p storage_path
		768	+ file = self.repo.archive_to_file(ref, prefix, file_path)
		769	+ end
		770	+
		771	+ file_path
		772	+ end
		773	+
		774	+ def ssh_url_to_repo
		775	+ url_to_repo
		776	+ end
		777	+
		778	+ def http_url_to_repo
		779	+ http_url = [Gitlab.config.gitlab.url, "/", path_with_namespace, ".git"].join('')
		780	+ end
		781	+
		782	+ # Check if current branch name is marked as protected in the system
		783	+ def protected_branch? branch_name
		784	+ protected_branches.map(&:name).include?(branch_name)
		785	+ end
280	end	786	end
	@@ -10,7 +10,7 @@		@@ -10,7 +10,7 @@
10	#	10	#
11		11
12	class ProtectedBranch < ActiveRecord::Base	12	class ProtectedBranch < ActiveRecord::Base
13	- include GitHost	13	+ include Gitolited
14		14
15	attr_accessible :name	15	attr_accessible :name
16		16
	@@ -22,7 +22,7 @@ class ProtectedBranch < ActiveRecord::Base		@@ -22,7 +22,7 @@ class ProtectedBranch < ActiveRecord::Base
22	after_destroy :update_repository	22	after_destroy :update_repository
23		23
24	def update_repository	24	def update_repository
25	- git_host.update_repository(project)	25	+ gitolite.update_repository(project)
26	end	26	end
27		27
28	def commit	28	def commit
	@@ -34,8 +34,6 @@		@@ -34,8 +34,6 @@
34	#	34	#
35		35
36	class User < ActiveRecord::Base	36	class User < ActiveRecord::Base
37	- include Account
38	-
39	devise :database_authenticatable, :token_authenticatable, :lockable,	37	devise :database_authenticatable, :token_authenticatable, :lockable,
40	:recoverable, :rememberable, :trackable, :validatable, :omniauthable	38	:recoverable, :rememberable, :trackable, :validatable, :omniauthable
41		39
	@@ -192,4 +190,92 @@ class User < ActiveRecord::Base		@@ -192,4 +190,92 @@ class User < ActiveRecord::Base
192	def tm_in_personal_projects	190	def tm_in_personal_projects
193	personal_projects.users_projects.where(user_id: self.id)	191	personal_projects.users_projects.where(user_id: self.id)
194	end	192	end
		193	+
		194	+ # Returns a string for use as a Gitolite user identifier
		195	+ #
		196	+ # Note that Gitolite 2.x requires the following pattern for users:
		197	+ #
		198	+ # ^@?[0-9a-zA-Z][0-9a-zA-Z._\@+-]*$
		199	+ def identifier
		200	+ # Replace non-word chars with underscores, then make sure it starts with
		201	+ # valid chars
		202	+ email.gsub(/\W/, '_').gsub(/\A([\W\_])+/, '')
		203	+ end
		204	+
		205	+ def is_admin?
		206	+ admin
		207	+ end
		208	+
		209	+ def require_ssh_key?
		210	+ keys.count == 0
		211	+ end
		212	+
		213	+ def can_create_project?
		214	+ projects_limit > personal_projects.count
		215	+ end
		216	+
		217	+ def can_create_group?
		218	+ is_admin?
		219	+ end
		220	+
		221	+ def abilities
		222	+ @abilities \|\|= begin
		223	+ abilities = Six.new
		224	+ abilities << Ability
		225	+ abilities
		226	+ end
		227	+ end
		228	+
		229	+ def can? action, subject
		230	+ abilities.allowed?(self, action, subject)
		231	+ end
		232	+
		233	+ def last_activity_project
		234	+ projects.first
		235	+ end
		236	+
		237	+ def first_name
		238	+ name.split.first unless name.blank?
		239	+ end
		240	+
		241	+ def cared_merge_requests
		242	+ MergeRequest.where("author_id = :id or assignee_id = :id", id: self.id)
		243	+ end
		244	+
		245	+ # Remove user from all projects and
		246	+ # set blocked attribute to true
		247	+ def block
		248	+ users_projects.find_each do \|membership\|
		249	+ return false unless membership.destroy
		250	+ end
		251	+
		252	+ self.blocked = true
		253	+ save
		254	+ end
		255	+
		256	+ def projects_limit_percent
		257	+ return 100 if projects_limit.zero?
		258	+ (personal_projects.count.to_f / projects_limit) * 100
		259	+ end
		260	+
		261	+ def recent_push project_id = nil
		262	+ # Get push events not earlier than 2 hours ago
		263	+ events = recent_events.code_push.where("created_at > ?", Time.now - 2.hours)
		264	+ events = events.where(project_id: project_id) if project_id
		265	+
		266	+ # Take only latest one
		267	+ events = events.recent.limit(1).first
		268	+ end
		269	+
		270	+ def projects_sorted_by_activity
		271	+ authorized_projects.sorted_by_activity
		272	+ end
		273	+
		274	+ def several_namespaces?
		275	+ namespaces.size > 1
		276	+ end
		277	+
		278	+ def namespace_id
		279	+ namespace.try :id
		280	+ end
195	end	281	end
	@@ -11,7 +11,7 @@		@@ -11,7 +11,7 @@
11	#	11	#
12		12
13	class UsersProject < ActiveRecord::Base	13	class UsersProject < ActiveRecord::Base
14	- include GitHost	14	+ include Gitolited
15		15
16	GUEST = 10	16	GUEST = 10
17	REPORTER = 20	17	REPORTER = 20
	@@ -152,7 +152,7 @@ class UsersProject < ActiveRecord::Base		@@ -152,7 +152,7 @@ class UsersProject < ActiveRecord::Base
152	end	152	end
153		153
154	def update_repository	154	def update_repository
155	- git_host.update_repository(project)	155	+ gitolite.update_repository(project)
156	end	156	end
157		157
158	def project_access_human	158	def project_access_human
1	class KeyObserver < ActiveRecord::Observer	1	class KeyObserver < ActiveRecord::Observer
2	- include GitHost	2	+ include Gitolited
3		3
4	def after_save(key)	4	def after_save(key)
5	- git_host.set_key(key.identifier, key.key, key.projects)	5	+ gitolite.set_key(key.identifier, key.key, key.projects)
6	end	6	end
7		7
8	def after_destroy(key)	8	def after_destroy(key)
9	return if key.is_deploy_key && !key.last_deploy?	9	return if key.is_deploy_key && !key.last_deploy?
10	- git_host.remove_key(key.identifier, key.projects)	10	+ gitolite.remove_key(key.identifier, key.projects)
11	end	11	end
12	end	12	end
	@@ -1,95 +0,0 @@	@@ -1,95 +0,0 @@
1	-# == Account role
2	-#
3	-# Describe behaviour of User in application
4	-#
5	-# Used by User
6	-#
7	-module Account
8	- # Returns a string for use as a Gitolite user identifier
9	- #
10	- # Note that Gitolite 2.x requires the following pattern for users:
11	- #
12	- # ^@?[0-9a-zA-Z][0-9a-zA-Z._\@+-]*$
13	- def identifier
14	- # Replace non-word chars with underscores, then make sure it starts with
15	- # valid chars
16	- email.gsub(/\W/, '_').gsub(/\A([\W\_])+/, '')
17	- end
18	-
19	- def is_admin?
20	- admin
21	- end
22	-
23	- def require_ssh_key?
24	- keys.count == 0
25	- end
26	-
27	- def can_create_project?
28	- projects_limit > personal_projects.count
29	- end
30	-
31	- def can_create_group?
32	- is_admin?
33	- end
34	-
35	- def abilities
36	- @abilities \|\|= begin
37	- abilities = Six.new
38	- abilities << Ability
39	- abilities
40	- end
41	- end
42	-
43	- def can? action, subject
44	- abilities.allowed?(self, action, subject)
45	- end
46	-
47	- def last_activity_project
48	- projects.first
49	- end
50	-
51	- def first_name
52	- name.split.first unless name.blank?
53	- end
54	-
55	- def cared_merge_requests
56	- MergeRequest.where("author_id = :id or assignee_id = :id", id: self.id)
57	- end
58	-
59	- # Remove user from all projects and
60	- # set blocked attribute to true
61	- def block
62	- users_projects.find_each do \|membership\|
63	- return false unless membership.destroy
64	- end
65	-
66	- self.blocked = true
67	- save
68	- end
69	-
70	- def projects_limit_percent
71	- return 100 if projects_limit.zero?
72	- (personal_projects.count.to_f / projects_limit) * 100
73	- end
74	-
75	- def recent_push project_id = nil
76	- # Get push events not earlier than 2 hours ago
77	- events = recent_events.code_push.where("created_at > ?", Time.now - 2.hours)
78	- events = events.where(project_id: project_id) if project_id
79	-
80	- # Take only latest one
81	- events = events.recent.limit(1).first
82	- end
83	-
84	- def projects_sorted_by_activity
85	- authorized_projects.sorted_by_activity
86	- end
87	-
88	- def several_namespaces?
89	- namespaces.size > 1
90	- end
91	-
92	- def namespace_id
93	- namespace.try :id
94	- end
95	-end
	@@ -1,68 +0,0 @@	@@ -1,68 +0,0 @@
1	-# == Authority role
2	-#
3	-# Control access to project repository based on users role in team
4	-#
5	-# Used by Project
6	-#
7	-module Authority
8	- # Compatible with all access rights
9	- # Should be rewrited for new access rights
10	- def add_access(user, *access)
11	- access = if access.include?(:admin)
12	- { project_access: UsersProject::MASTER }
13	- elsif access.include?(:write)
14	- { project_access: UsersProject::DEVELOPER }
15	- else
16	- { project_access: UsersProject::REPORTER }
17	- end
18	- opts = { user: user }
19	- opts.merge!(access)
20	- users_projects.create(opts)
21	- end
22	-
23	- def reset_access(user)
24	- users_projects.where(project_id: self.id, user_id: user.id).destroy if self.id
25	- end
26	-
27	- def repository_readers
28	- repository_members[UsersProject::REPORTER]
29	- end
30	-
31	- def repository_writers
32	- repository_members[UsersProject::DEVELOPER]
33	- end
34	-
35	- def repository_masters
36	- repository_members[UsersProject::MASTER]
37	- end
38	-
39	- def repository_members
40	- keys = Hash.new {\|h,k\| h[k] = [] }
41	- UsersProject.select("keys.identifier, project_access").
42	- joins(user: :keys).where(project_id: id).
43	- each {\|row\| keys[row.project_access] << [row.identifier] }
44	-
45	- keys[UsersProject::REPORTER] += deploy_keys.pluck(:identifier)
46	- keys
47	- end
48	-
49	- def allow_read_for?(user)
50	- !users_projects.where(user_id: user.id).empty?
51	- end
52	-
53	- def guest_access_for?(user)
54	- !users_projects.where(user_id: user.id).empty?
55	- end
56	-
57	- def report_access_for?(user)
58	- !users_projects.where(user_id: user.id, project_access: [UsersProject::REPORTER, UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
59	- end
60	-
61	- def dev_access_for?(user)
62	- !users_projects.where(user_id: user.id, project_access: [UsersProject::DEVELOPER, UsersProject::MASTER]).empty?
63	- end
64	-
65	- def master_access_for?(user)
66	- !users_projects.where(user_id: user.id, project_access: [UsersProject::MASTER]).empty?
67	- end
68	-end