simple refactoring

app/helpers/commits_helper.rb

@@ -17,7 +17,7 @@ module CommitsHelper
     line_old = 1
     line_new = 1
     type = nil
-    
+
     lines_arr = ::Gitlab::InlineDiff.processing diff_arr
     lines_arr.each do |line|
       next if line.match(/^\-\-\- \/dev\/null/)

app/helpers/merge_requests_helper.rb

@@ -24,7 +24,7 @@ module MergeRequestsHelper
   def new_mr_path_from_push_event(event)
     new_project_merge_request_path(
       event.project,
-      merge_request: { 
+      merge_request: {
         source_branch: event.branch_name,
         target_branch: event.project.root_ref,
         title: event.branch_name.titleize

app/models/ability.rb

@@ -1,61 +1,61 @@
 class Ability
-  def self.allowed(object, subject)
-    case subject.class.name
-    when "Project" then project_abilities(object, subject)
-    when "Issue" then issue_abilities(object, subject)
-    when "Note" then note_abilities(object, subject)
-    when "Snippet" then snippet_abilities(object, subject)
-    when "MergeRequest" then merge_request_abilities(object, subject)
-    else []
-    end
-  end
-
-  def self.project_abilities(user, project)
-    rules = []
-
-    rules << [
-      :read_project,
-      :read_wiki,
-      :read_issue,
-      :read_milestone,
-      :read_snippet,
-      :read_team_member,
-      :read_merge_request,
-      :read_note,
-      :write_project,
-      :write_issue,
-      :write_note
-    ] if project.guest_access_for?(user)
-
-    rules << [
-      :download_code,
-      :write_merge_request,
-      :write_snippet
-    ] if project.report_access_for?(user)
-
-    rules << [
-      :write_wiki
-    ] if project.dev_access_for?(user)
-
-    rules << [
-      :modify_issue,
-      :modify_snippet,
-      :modify_merge_request,
-      :admin_project,
-      :admin_issue,
-      :admin_milestone,
-      :admin_snippet,
-      :admin_team_member,
-      :admin_merge_request,
-      :admin_note,
-      :accept_mr,
-      :admin_wiki
-    ] if project.master_access_for?(user) || project.owner == user
-
-    rules.flatten
-  end
-
   class << self
+    def allowed(object, subject)
+      case subject.class.name
+      when "Project" then project_abilities(object, subject)
+      when "Issue" then issue_abilities(object, subject)
+      when "Note" then note_abilities(object, subject)
+      when "Snippet" then snippet_abilities(object, subject)
+      when "MergeRequest" then merge_request_abilities(object, subject)
+      else []
+      end
+    end
+
+    def project_abilities(user, project)
+      rules = []
+
+      rules << [
+        :read_project,
+        :read_wiki,
+        :read_issue,
+        :read_milestone,
+        :read_snippet,
+        :read_team_member,
+        :read_merge_request,
+        :read_note,
+        :write_project,
+        :write_issue,
+        :write_note
+      ] if project.guest_access_for?(user)
+
+      rules << [
+        :download_code,
+        :write_merge_request,
+        :write_snippet
+      ] if project.report_access_for?(user)
+
+      rules << [
+        :write_wiki
+      ] if project.dev_access_for?(user)
+
+      rules << [
+        :modify_issue,
+        :modify_snippet,
+        :modify_merge_request,
+        :admin_project,
+        :admin_issue,
+        :admin_milestone,
+        :admin_snippet,
+        :admin_team_member,
+        :admin_merge_request,
+        :admin_note,
+        :accept_mr,
+        :admin_wiki
+      ] if project.master_access_for?(user) || project.owner == user
+
+      rules.flatten
+    end
+
     [:issue, :note, :snippet, :merge_request].each do |name|
       define_method "#{name}_abilities" do |user, subject|
         if subject.author == user
@@ -72,8 +72,7 @@ class Ability
             :"modify_#{name}",
           ]
         else
-          subject.respond_to?(:project) ?
-            project_abilities(user, subject.project) : []
+          subject.respond_to?(:project) ? project_abilities(user, subject.project) : []
         end
       end
     end

app/models/event.rb

@@ -27,19 +27,22 @@ class Event < ActiveRecord::Base
   # For Hash only
   serialize :data
 
+  # Scopes
   scope :recent, order("created_at DESC")
   scope :code_push, where(action: Pushed)
 
-  def self.determine_action(record)
-    if [Issue, MergeRequest].include? record.class
-      Event::Created
-    elsif record.kind_of? Note
-      Event::Commented
+  class << self
+    def determine_action(record)
+      if [Issue, MergeRequest].include? record.class
+        Event::Created
+      elsif record.kind_of? Note
+        Event::Commented
+      end
     end
-  end
 
-  def self.recent_for_user user
-    where(project_id: user.projects.map(&:id)).recent
+    def recent_for_user user
+      where(project_id: user.projects.map(&:id)).recent
+    end
   end
 
   # Next events currently enabled for system

app/models/group.rb

@@ -1,15 +1,3 @@
-# == Schema Information
-#
-# Table name: groups
-#
-#  id         :integer         not null, primary key
-#  name       :string(255)     not null
-#  code       :string(255)     not null
-#  owner_id   :integer         not null
-#  created_at :datetime        not null
-#  updated_at :datetime        not null
-#
-
 class Group < ActiveRecord::Base
   attr_accessible :code, :name, :owner_id
 
@@ -18,7 +6,7 @@ class Group < ActiveRecord::Base
 
   validates :name, presence: true, uniqueness: true
   validates :code, presence: true, uniqueness: true
-  validates :owner_id, presence: true
+  validates :owner, presence: true
 
   delegate :name, to: :owner, allow_nil: true, prefix: true
 
@@ -31,6 +19,18 @@ class Group < ActiveRecord::Base
   end
 
   def users
-    User.joins(:users_projects).where('users_projects.project_id' => project_ids).uniq
+    User.joins(:users_projects).where(users_projects: {project_id: project_ids}).uniq
   end
 end
+
+# == Schema Information
+#
+# Table name: groups
+#
+#  id         :integer         not null, primary key
+#  name       :string(255)     not null
+#  code       :string(255)     not null
+#  owner_id   :integer         not null
+#  created_at :datetime        not null
+#  updated_at :datetime        not null
+#

app/models/key.rb

@@ -6,16 +6,15 @@ class Key < ActiveRecord::Base
 
   attr_accessible :key, :title
 
-  validates :title, presence: true, length: { within: 0..255 }
-  validates :key, presence: true,
-            length: { within: 0..5000 },
-            format: { :with => /ssh-.{3} / }
-
-  before_save :set_identifier
   before_validation :strip_white_space
-  delegate :name, :email, to: :user, prefix: true
+  before_save :set_identifier
+
+  validates :title, presence: true, length: { within: 0..255 }
+  validates :key, presence: true, length: { within: 0..5000 }, format: { :with => /ssh-.{3} / }
   validate :unique_key, :fingerprintable_key
 
+  delegate :name, :email, to: :user, prefix: true
+
   def strip_white_space
     self.key = self.key.strip unless self.key.blank?
   end

app/models/merge_request.rb

@@ -7,6 +7,8 @@ class MergeRequest < ActiveRecord::Base
   attr_accessible :title, :assignee_id, :closed, :target_branch, :source_branch,
                   :author_id_of_changes
 
+  attr_accessor :should_remove_source_branch
+
   BROKEN_DIFF = "--broken-diff"
 
   UNCHECKED = 1
@@ -16,9 +18,8 @@ class MergeRequest < ActiveRecord::Base
   serialize :st_commits
   serialize :st_diffs
 
-  attr_accessor :should_remove_source_branch
-
-  validates_presence_of :source_branch, :target_branch
+  validates :source_branch, presence: true
+  validates :target_branch, presence: true
   validate :validate_branches
 
   def self.find_all_by_branch(branch_name)

app/models/milestone.rb

@@ -4,7 +4,8 @@ class Milestone < ActiveRecord::Base
   belongs_to :project
   has_many :issues
 
-  validates_presence_of :title, :project_id
+  validates :title, presence: true
+  validates :project, presence: true
 
   def self.active
     where("due_date > ? OR due_date IS NULL", Date.today)

app/models/note.rb

@@ -2,10 +2,13 @@ require 'carrierwave/orm/activerecord'
 require 'file_size_validator'
 
 class Note < ActiveRecord::Base
-  mount_uploader  :attachment, AttachmentUploader
+
   attr_accessible :note, :noteable, :noteable_id, :noteable_type, :project_id,
                   :attachment, :line_code
 
+  attr_accessor :notify
+  attr_accessor :notify_author
+
   belongs_to :project
   belongs_to :noteable, polymorphic: true
   belongs_to :author, class_name: "User"
@@ -13,18 +16,17 @@ class Note < ActiveRecord::Base
   delegate :name, to: :project, prefix: true
   delegate :name, :email, to: :author, prefix: true
 
-  attr_accessor :notify
-  attr_accessor :notify_author
-
-  validates_presence_of :project
-
+  validates :project, presence: true
   validates :note, presence: true, length: { within: 0..5000 }
   validates :attachment, file_size: { maximum: 10.megabytes.to_i }
 
+  mount_uploader  :attachment, AttachmentUploader
+
+  # Scopes
   scope :common, where(noteable_id: nil)
   scope :today, where("created_at >= :date", date: Date.today)
   scope :last_week, where("created_at  >= :date", date: (Date.today - 7.days))
-  scope :since, lambda { |day| where("created_at  >= :date", date: (day)) }
+  scope :since, ->(day) { where("created_at  >= :date", date: (day)) }
   scope :fresh, order("created_at ASC, id ASC")
   scope :inc_author_project, includes(:project, :author)
   scope :inc_author, includes(:author)

app/models/project.rb

@@ -28,52 +28,6 @@ class Project < ActiveRecord::Base
 
   delegate :name, to: :owner, allow_nil: true, prefix: true
 
-  # Scopes
-  scope :public_only, where(private_flag: false)
-  scope :without_user, ->(user)  { where("id NOT IN (:ids)", ids: user.projects.map(&:id) ) }
-  scope :not_in_group, ->(group) { where("id NOT IN (:ids)", ids: group.project_ids ) }
-
-  def self.active
-    joins(:issues, :notes, :merge_requests).order("issues.created_at, notes.created_at, merge_requests.created_at DESC")
-  end
-
-  def self.search query
-    where("name LIKE :query OR code LIKE :query OR path LIKE :query", query: "%#{query}%")
-  end
-
-  def self.create_by_user(params, user)
-    project = Project.new params
-
-    Project.transaction do
-      project.owner = user
-      project.save!
-
-      # Add user as project master
-      project.users_projects.create!(project_access: UsersProject::MASTER, user: user)
-
-      # when project saved no team member exist so
-      # project repository should be updated after first user add
-      project.update_repository
-    end
-
-    project
-  rescue Gitlab::Gitolite::AccessDenied => ex
-    project.error_code = :gitolite
-    project
-  rescue => ex
-    project.error_code = :db
-    project.errors.add(:base, "Can't save project. Please try again later")
-    project
-  end
-
-  def git_error?
-    error_code == :gitolite
-  end
-
-  def saved?
-    id && valid?
-  end
-
   # Validations
   validates :owner, presence: true
   validates :description, length: { within: 0..2000 }
@@ -88,6 +42,58 @@ class Project < ActiveRecord::Base
             :wiki_enabled, inclusion: { in: [true, false] }
   validate :check_limit, :repo_name
 
+  # Scopes
+  scope :public_only, where(private_flag: false)
+  scope :without_user, ->(user)  { where("id NOT IN (:ids)", ids: user.projects.map(&:id) ) }
+  scope :not_in_group, ->(group) { where("id NOT IN (:ids)", ids: group.project_ids ) }
+
+  class << self
+    def active
+      joins(:issues, :notes, :merge_requests).order("issues.created_at, notes.created_at, merge_requests.created_at DESC")
+    end
+
+    def search query
+      where("name LIKE :query OR code LIKE :query OR path LIKE :query", query: "%#{query}%")
+    end
+
+    def create_by_user(params, user)
+      project = Project.new params
+
+      Project.transaction do
+        project.owner = user
+        project.save!
+
+        # Add user as project master
+        project.users_projects.create!(project_access: UsersProject::MASTER, user: user)
+
+        # when project saved no team member exist so
+        # project repository should be updated after first user add
+        project.update_repository
+      end
+
+      project
+    rescue Gitlab::Gitolite::AccessDenied => ex
+      project.error_code = :gitolite
+      project
+    rescue => ex
+      project.error_code = :db
+      project.errors.add(:base, "Can't save project. Please try again later")
+      project
+    end
+
+    def access_options
+      UsersProject.access_roles
+    end
+  end
+
+  def git_error?
+    error_code == :gitolite
+  end
+
+  def saved?
+    id && valid?
+  end
+
   def check_limit
     unless owner.can_create_project?
       errors[:base] << ("Your own projects limit is #{owner.projects_limit}! Please contact administrator to increase it")
@@ -102,10 +108,6 @@ class Project < ActiveRecord::Base
     end
   end
 
-  def self.access_options
-    UsersProject.access_roles
-  end
-
   def to_param
     code
   end

app/models/protected_branch.rb

@@ -4,7 +4,8 @@ class ProtectedBranch < ActiveRecord::Base
   attr_accessible :name
 
   belongs_to :project
-  validates_presence_of :name, :project_id
+  validates :name, presence: true
+  validates :project, presence: true
 
   after_save :update_repository
   after_destroy :update_repository

app/models/snippet.rb

@@ -9,11 +9,13 @@ class Snippet < ActiveRecord::Base
 
   delegate :name, :email, to: :author, prefix: true
 
-  validates_presence_of :author_id, :project_id
+  validates :author, presence: true
+  validates :project, presence: true
   validates :title, presence: true, length: { within: 0..255 }
   validates :file_name, presence: true, length: { within: 0..255 }
   validates :content, presence: true, length: { within: 0..10000 }
 
+  # Scopes
   scope :fresh, order("created_at DESC")
   scope :non_expired, where(["expires_at IS NULL OR expires_at > ?", Time.current])
   scope :expired, where(["expires_at IS NOT NULL AND expires_at < ?", Time.current])

app/models/system_hook.rb

@@ -1,13 +1,13 @@
 class SystemHook < WebHook
-  def async_execute(data)
-    Resque.enqueue(SystemHookWorker, id, data)
-  end
-
   def self.all_hooks_fire(data)
     SystemHook.all.each do |sh|
       sh.async_execute data
     end
   end
+
+  def async_execute(data)
+    Resque.enqueue(SystemHookWorker, id, data)
+  end
 end
 
 # == Schema Information

app/models/user.rb

@@ -27,54 +27,57 @@ class User < ActiveRecord::Base
   validates :extern_uid, :allow_blank => true, :uniqueness => {:scope => :provider}
   validates :projects_limit, presence: true, numericality: {greater_than_or_equal_to: 0}
 
-  scope :not_in_project, lambda { |project|  where("id not in (:ids)", ids: project.users.map(&:id) ) }
+  before_validation :generate_password, on: :create
+  before_save :ensure_authentication_token
+  alias_attribute :private_token, :authentication_token
+
+  # Scopes
+  scope :not_in_project, ->(project) { where("id not in (:ids)", ids: project.users.map(&:id) ) }
   scope :admins, where(admin:  true)
   scope :blocked, where(blocked:  true)
   scope :active, where(blocked:  false)
 
-  before_validation :generate_password, on: :create
-  before_save :ensure_authentication_token
-  alias_attribute :private_token, :authentication_token
+  class << self
+    def filter filter_name
+      case filter_name
+      when "admins"; self.admins
+      when "blocked"; self.blocked
+      when "wop"; self.without_projects
+      else
+        self.active
+      end
+    end
+
+    def without_projects
+      where('id NOT IN (SELECT DISTINCT(user_id) FROM users_projects)')
+    end
+
+    def create_from_omniauth(auth, ldap = false)
+      gitlab_auth.create_from_omniauth(auth, ldap)
+    end
+
+    def find_or_new_for_omniauth(auth)
+      gitlab_auth.find_or_new_for_omniauth(auth)
+    end
+
+    def find_for_ldap_auth(auth, signed_in_resource = nil)
+      gitlab_auth.find_for_ldap_auth(auth, signed_in_resource)
+    end
+
+    def gitlab_auth
+      Gitlab::Auth.new
+    end
+
+    def search query
+      where("name LIKE :query or email LIKE :query", query: "%#{query}%")
+    end
+  end
 
   def generate_password
     if self.force_random_password
       self.password = self.password_confirmation = Devise.friendly_token.first(8)
     end
   end
-
-  def self.filter filter_name
-    case filter_name
-    when "admins"; self.admins
-    when "blocked"; self.blocked
-    when "wop"; self.without_projects
-    else
-      self.active
-    end
-  end
-
-  def self.without_projects
-    where('id NOT IN (SELECT DISTINCT(user_id) FROM users_projects)')
-  end
-
-  def self.create_from_omniauth(auth, ldap = false)
-    gitlab_auth.create_from_omniauth(auth, ldap)
-  end
-
-  def self.find_or_new_for_omniauth(auth)
-    gitlab_auth.find_or_new_for_omniauth(auth)
-  end
-
-  def self.find_for_ldap_auth(auth, signed_in_resource = nil)
-    gitlab_auth.find_for_ldap_auth(auth, signed_in_resource)
-  end
-
-  def self.gitlab_auth
-    Gitlab::Auth.new
-  end
-
-  def self.search query
-    where("name LIKE :query OR email LIKE :query", query: "%#{query}%")
-  end
 end
 
 # == Schema Information

app/models/users_project.rb

@@ -14,62 +14,64 @@ class UsersProject < ActiveRecord::Base
   after_save :update_repository
   after_destroy :update_repository
 
-  validates_uniqueness_of :user_id, scope: [:project_id], message: "already exists in project"
-  validates_presence_of :user_id
-  validates_presence_of :project_id
+  validates :user, presence: true
+  validates :user_id, uniqueness: { :scope => [:project_id], message: "already exists in project" }
+  validates :project, presence: true
 
   delegate :name, :email, to: :user, prefix: true
 
-  def self.bulk_delete(project, user_ids)
-    UsersProject.transaction do
-      UsersProject.where(:user_id => user_ids, :project_id => project.id).each do |users_project|
-        users_project.destroy
+  class << self
+    def bulk_delete(project, user_ids)
+      UsersProject.transaction do
+        UsersProject.where(:user_id => user_ids, :project_id => project.id).each do |users_project|
+          users_project.destroy
+        end
       end
     end
-  end
 
-  def self.bulk_update(project, user_ids, project_access)
-    UsersProject.transaction do
-      UsersProject.where(:user_id => user_ids, :project_id => project.id).each do |users_project|
-        users_project.project_access = project_access
-        users_project.save
+    def bulk_update(project, user_ids, project_access)
+      UsersProject.transaction do
+        UsersProject.where(:user_id => user_ids, :project_id => project.id).each do |users_project|
+          users_project.project_access = project_access
+          users_project.save
+        end
       end
     end
-  end
 
-  def self.bulk_import(project, user_ids, project_access)
-    UsersProject.transaction do
-      user_ids.each do |user_id|
-        users_project = UsersProject.new(
-          project_access: project_access,
-          user_id: user_id
-        )
-        users_project.project = project
-        users_project.save
+    def bulk_import(project, user_ids, project_access)
+      UsersProject.transaction do
+        user_ids.each do |user_id|
+          users_project = UsersProject.new(
+            project_access: project_access,
+            user_id: user_id
+          )
+          users_project.project = project
+          users_project.save
+        end
       end
     end
-  end
 
-  def self.user_bulk_import(user, project_ids, project_access)
-    UsersProject.transaction do
-      project_ids.each do |project_id|
-        users_project = UsersProject.new(
-          project_access: project_access,
-        )
-        users_project.project_id = project_id
-        users_project.user_id = user.id
-        users_project.save
+    def user_bulk_import(user, project_ids, project_access)
+      UsersProject.transaction do
+        project_ids.each do |project_id|
+          users_project = UsersProject.new(
+            project_access: project_access,
+          )
+          users_project.project_id = project_id
+          users_project.user_id = user.id
+          users_project.save
+        end
       end
     end
-  end
 
-  def self.access_roles
-    {
-      "Guest"     => GUEST,
-      "Reporter"  => REPORTER,
-      "Developer" => DEVELOPER,
-      "Master"    => MASTER
-    }
+    def access_roles
+      {
+        "Guest"     => GUEST,
+        "Reporter"  => REPORTER,
+        "Developer" => DEVELOPER,
+        "Master"    => MASTER
+      }
+    end
   end
 
   def role_access

app/models/web_hook.rb

@@ -7,7 +7,7 @@ class WebHook < ActiveRecord::Base
   default_timeout 10
 
   validates :url, presence: true,
-            format: { with: URI::regexp(%w(http https)), message: "should be a valid url" }
+                  format: { with: URI::regexp(%w(http https)), message: "should be a valid url" }
 
   def execute(data)
     parsed_url = URI.parse(url)

app/models/wiki.rb

@@ -5,8 +5,9 @@ class Wiki < ActiveRecord::Base
   belongs_to :user
   has_many :notes, as: :noteable, dependent: :destroy
 
-  validates :content, :title, :user_id, presence: true
-  validates :title, length: 1..250
+  validates :content, presence: true
+  validates :user, presence: true
+  validates :title, presence: true, length: 1..250
 
   before_update :set_slug
 
@@ -16,21 +17,20 @@ class Wiki < ActiveRecord::Base
 
   protected
 
+  def self.regenerate_from wiki
+    regenerated_field = [:slug, :content, :title]
+
+    new_wiki = Wiki.new
+    regenerated_field.each do |field|
+      new_wiki.send("#{field}=", wiki.send(field))
+    end
+    new_wiki
+  end
+
   def set_slug
     self.slug = self.title.parameterize
   end
 
-  class << self
-    def regenerate_from wiki
-      regenerated_field = [:slug, :content, :title]
-
-      new_wiki = Wiki.new
-      regenerated_field.each do |field|
-        new_wiki.send("#{field}=", wiki.send(field))
-      end
-      new_wiki
-    end
-  end
 end
 
 # == Schema Information

app/roles/account.rb

@@ -41,7 +41,7 @@ module Account
   # Remove user from all projects and
   # set blocked attribute to true
   def block
-    users_projects.all.each do |membership|
+    users_projects.find_each do |membership|
       return false unless membership.destroy
     end
 

app/roles/authority.rb

@@ -2,12 +2,12 @@ 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 } 
+    access = if access.include?(:admin)
+               { project_access: UsersProject::MASTER }
              elsif access.include?(:write)
-               { project_access: UsersProject::DEVELOPER } 
+               { project_access: UsersProject::DEVELOPER }
              else
-               { project_access: UsersProject::REPORTER } 
+               { project_access: UsersProject::REPORTER }
              end
     opts = { user: user }
     opts.merge!(access)

app/roles/issue_commonality.rb

@@ -8,12 +8,9 @@ module IssueCommonality
     belongs_to :assignee, class_name: "User"
     has_many :notes, as: :noteable, dependent: :destroy
 
-    validates_presence_of :project_id
-    validates_presence_of :author_id
-
-    validates :title,
-              presence: true,
-              length: { within: 0..255 }
+    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)

app/roles/push_event.rb

@@ -5,11 +5,11 @@ module PushEvent
     false
   end
 
-  def tag? 
+  def tag?
     data[:ref]["refs/tags"]
   end
 
-  def branch? 
+  def branch?
     data[:ref]["refs/heads"]
   end
 
@@ -25,7 +25,7 @@ module PushEvent
     commit_to =~ /^00000/
   end
 
-  def md_ref? 
+  def md_ref?
     !(rm_ref? || new_ref?)
   end
 
@@ -37,7 +37,7 @@ module PushEvent
     data[:after]
   end
 
-  def ref_name 
+  def ref_name
     if tag?
       tag_name
     else