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 @@
	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	15	#
16	16
17	17	class Event < ActiveRecord::Base
18		- include NoteEvent
19		- include PushEvent
20		-
21	18	attr_accessible :project, :action, :data, :author_id, :project_id,
22	19	:target_id, :target_type
23	20
...	...	@@ -170,4 +167,139 @@ class Event < ActiveRecord::Base
170	167	"opened"
171	168	end
172	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	305	end
...	...
...	...	@@ -17,8 +17,7 @@
17	17	#
18	18
19	19	class Issue < ActiveRecord::Base
20		- include IssueCommonality
21		- include Votes
	20	+ include Issuable
22	21
23	22	attr_accessible :title, :assignee_id, :closed, :position, :description,
24	23	:milestone_id, :label_list, :author_id_of_changes
...	...
...	...	@@ -20,11 +20,10 @@
20	20	#
21	21
22	22	require Rails.root.join("app/models/commit")
23		-require Rails.root.join("app/roles/static_model")
	23	+require Rails.root.join("lib/static_model")
24	24
25	25	class MergeRequest < ActiveRecord::Base
26		- include IssueCommonality
27		- include Votes
	26	+ include Issuable
28	27
29	28	attr_accessible :title, :assignee_id, :closed, :target_branch, :source_branch, :milestone_id,
30	29	:author_id_of_changes
...	...
...	...	@@ -21,11 +21,7 @@
21	21	require "grit"
22	22
23	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	26	class TransferError < StandardError; end
31	27
...	...	@@ -277,4 +273,514 @@ class Project < ActiveRecord::Base
277	273	creator
278	274	end
279	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	786	end
...	...
...	...	@@ -10,7 +10,7 @@
10	10	#
11	11
12	12	class ProtectedBranch < ActiveRecord::Base
13		- include GitHost
	13	+ include Gitolited
14	14
15	15	attr_accessible :name
16	16
...	...	@@ -22,7 +22,7 @@ class ProtectedBranch < ActiveRecord::Base
22	22	after_destroy :update_repository
23	23
24	24	def update_repository
25		- git_host.update_repository(project)
	25	+ gitolite.update_repository(project)
26	26	end
27	27
28	28	def commit
...	...
...	...	@@ -34,8 +34,6 @@
34	34	#
35	35
36	36	class User < ActiveRecord::Base
37		- include Account
38		-
39	37	devise :database_authenticatable, :token_authenticatable, :lockable,
40	38	:recoverable, :rememberable, :trackable, :validatable, :omniauthable
41	39
...	...	@@ -192,4 +190,92 @@ class User < ActiveRecord::Base
192	190	def tm_in_personal_projects
193	191	personal_projects.users_projects.where(user_id: self.id)
194	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	281	end
...	...
...	...	@@ -11,7 +11,7 @@
11	11	#
12	12
13	13	class UsersProject < ActiveRecord::Base
14		- include GitHost
	14	+ include Gitolited
15	15
16	16	GUEST = 10
17	17	REPORTER = 20
...	...	@@ -152,7 +152,7 @@ class UsersProject < ActiveRecord::Base
152	152	end
153	153
154	154	def update_repository
155		- git_host.update_repository(project)
	155	+ gitolite.update_repository(project)
156	156	end
157	157
158	158	def project_access_human
...	...
1	1	class KeyObserver < ActiveRecord::Observer
2		- include GitHost
	2	+ include Gitolited
3	3
4	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	6	end
7	7
8	8	def after_destroy(key)
9	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	11	end
12	12	end
...	...
...	...	@@ -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