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/)
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
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 []
+ 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
- end
- def self.project_abilities(user, project)
- rules = []
+ 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 << [
+ :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 << [
+ :download_code,
+ :write_merge_request,
+ :write_snippet
+ ] if project.report_access_for?(user)
- rules << [
- :write_wiki
- ] if project.dev_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 << [
+ :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
+ rules.flatten
+ end
- class << self
[:issue, :note, :snippet, :merge_request].each do |name|
define_method "#{name}_abilities" do |user, subject|
if subject.author == user
:"modify_#{name}",
]
else
- subject.respond_to?(:project) ?
- project_abilities(user, subject.project) : []
+ subject.respond_to?(:project) ? project_abilities(user, subject.project) : []
end
end
end
# 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
-# == 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
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
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
+#
attr_accessible :key, :title
+ before_validation :strip_white_space
+ before_save :set_identifier
+
validates :title, presence: true, length: { within: 0..255 }
- validates :key, presence: true,
- length: { within: 0..5000 },
- format: { :with => /ssh-.{3} / }
+ validates :key, presence: true, length: { within: 0..5000 }, format: { :with => /ssh-.{3} / }
+ validate :unique_key, :fingerprintable_key
- before_save :set_identifier
- before_validation :strip_white_space
delegate :name, :email, to: :user, prefix: true
- validate :unique_key, :fingerprintable_key
def strip_white_space
self.key = self.key.strip unless self.key.blank?
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
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)
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)
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"
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)
delegate :name, to: :owner, allow_nil: true, prefix: true
+ # Validations
+ validates :owner, presence: true
+ validates :description, length: { within: 0..2000 }
+ validates :name, uniqueness: true, presence: true, length: { within: 0..255 }
+ validates :path, uniqueness: true, presence: true, length: { within: 0..255 },
+ format: { with: /\A[a-zA-Z][a-zA-Z0-9_\-\.]*\z/,
+ message: "only letters, digits & '_' '-' '.' allowed. Letter should be first" }
+ validates :code, presence: true, uniqueness: true, length: { within: 1..255 },
+ format: { with: /\A[a-zA-Z][a-zA-Z0-9_\-\.]*\z/,
+ message: "only letters, digits & '_' '-' '.' allowed. Letter should be first" }
+ validates :issues_enabled, :wall_enabled, :merge_requests_enabled,
+ :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 ) }
- 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!
+ class << self
+ def active
+ joins(:issues, :notes, :merge_requests).order("issues.created_at, notes.created_at, merge_requests.created_at DESC")
+ end
- # Add user as project master
- project.users_projects.create!(project_access: UsersProject::MASTER, user: user)
+ def search query
+ where("name LIKE :query OR code LIKE :query OR path LIKE :query", query: "%#{query}%")
+ end
- # when project saved no team member exist so
- # project repository should be updated after first user add
- project.update_repository
+ 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
- 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
+ def access_options
+ UsersProject.access_roles
+ end
end
def git_error?
id && valid?
end
- # Validations
- validates :owner, presence: true
- validates :description, length: { within: 0..2000 }
- validates :name, uniqueness: true, presence: true, length: { within: 0..255 }
- validates :path, uniqueness: true, presence: true, length: { within: 0..255 },
- format: { with: /\A[a-zA-Z][a-zA-Z0-9_\-\.]*\z/,
- message: "only letters, digits & '_' '-' '.' allowed. Letter should be first" }
- validates :code, presence: true, uniqueness: true, length: { within: 1..255 },
- format: { with: /\A[a-zA-Z][a-zA-Z0-9_\-\.]*\z/,
- message: "only letters, digits & '_' '-' '.' allowed. Letter should be first" }
- validates :issues_enabled, :wall_enabled, :merge_requests_enabled,
- :wiki_enabled, inclusion: { in: [true, false] }
- validate :check_limit, :repo_name
-
def check_limit
unless owner.can_create_project?
errors[:base] << ("Your own projects limit is #{owner.projects_limit}! Please contact administrator to increase it")
end
end
- def self.access_options
- UsersProject.access_roles
- end
-
def to_param
code
end
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
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])
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
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) ) }
- 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
- def generate_password
- if self.force_random_password
- self.password = self.password_confirmation = Devise.friendly_token.first(8)
+ # 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)
+
+ 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
- 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
+ def without_projects
+ where('id NOT IN (SELECT DISTINCT(user_id) FROM users_projects)')
end
- end
- def self.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 self.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 self.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 self.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 self.gitlab_auth
- Gitlab::Auth.new
+ def search query
+ where("name LIKE :query or email LIKE :query", query: "%#{query}%")
+ end
end
- def self.search query
- where("name LIKE :query OR email LIKE :query", query: "%#{query}%")
+ def generate_password
+ if self.force_random_password
+ self.password = self.password_confirmation = Devise.friendly_token.first(8)
+ end
end
end
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
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)
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
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
# 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
# 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)
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)
false
end
- def tag?
+ def tag?
data[:ref]["refs/tags"]
end
- def branch?
+ def branch?
data[:ref]["refs/heads"]
end
commit_to =~ /^00000/
end
- def md_ref?
+ def md_ref?
!(rm_ref? || new_ref?)
end
data[:after]
end
- def ref_name
+ def ref_name
if tag?
tag_name
else
OSDN Git Service
