merge_request.rb 24.5 KB
Newer Older
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1
class MergeRequest < ActiveRecord::Base
2
  include InternalId
3
  include Issuable
4
  include Noteable
5
  include Referable
6
  include Sortable
7 8 9
  include IgnorableColumn

  ignore_column :position
10

11 12
  belongs_to :target_project, class_name: "Project"
  belongs_to :source_project, class_name: "Project"
13
  belongs_to :merge_user, class_name: "User"
14

15
  has_many :merge_request_diffs
16 17 18
  has_one :merge_request_diff,
    -> { order('merge_request_diffs.id DESC') }

19 20
  belongs_to :head_pipeline, foreign_key: "head_pipeline_id", class_name: "Ci::Pipeline"

21
  has_many :events, as: :target, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
22

23 24 25
  has_many :merge_requests_closing_issues,
    class_name: 'MergeRequestsClosingIssues',
    dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
26

27 28
  belongs_to :assignee, class_name: "User"

29
  serialize :merge_params, Hash # rubocop:disable Cop/ActiveRecordSerialize
30

31 32
  after_create :ensure_merge_request_diff, unless: :importing?
  after_update :reload_diff_if_branch_changed
33

34
  delegate :commits, :real_size, :commit_shas, :commits_count,
35
    to: :merge_request_diff, prefix: nil
36

37 38 39 40
  # When this attribute is true some MR validation is ignored
  # It allows us to close or modify broken merge requests
  attr_accessor :allow_broken

41 42
  # Temporary fields to store compare vars
  # when creating new merge request
43
  attr_accessor :can_be_created, :compare_commits, :diff_options, :compare
44

Andrew8xx8's avatar
Andrew8xx8 committed
45
  state_machine :state, initial: :opened do
46 47 48 49
    event :close do
      transition [:reopened, :opened] => :closed
    end

50
    event :mark_as_merged do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
51
      transition [:reopened, :opened, :locked] => :merged
52 53 54
    end

    event :reopen do
Andrew8xx8's avatar
Andrew8xx8 committed
55
      transition closed: :reopened
56 57
    end

58
    event :lock_mr do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
59 60 61
      transition [:reopened, :opened] => :locked
    end

62
    event :unlock_mr do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
63 64 65
      transition locked: :reopened
    end

66 67 68 69 70
    after_transition any => :locked do |merge_request, transition|
      merge_request.locked_at = Time.now
      merge_request.save
    end

71
    after_transition locked: (any - :locked) do |merge_request, transition|
72 73 74 75
      merge_request.locked_at = nil
      merge_request.save
    end

76 77 78 79
    state :opened
    state :reopened
    state :closed
    state :merged
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
80
    state :locked
81 82
  end

83 84 85 86 87 88
  state_machine :merge_status, initial: :unchecked do
    event :mark_as_unchecked do
      transition [:can_be_merged, :cannot_be_merged] => :unchecked
    end

    event :mark_as_mergeable do
89
      transition [:unchecked, :cannot_be_merged] => :can_be_merged
90 91 92
    end

    event :mark_as_unmergeable do
93
      transition [:unchecked, :can_be_merged] => :cannot_be_merged
94 95
    end

96
    state :unchecked
97 98
    state :can_be_merged
    state :cannot_be_merged
99 100

    around_transition do |merge_request, transition, block|
101
      Gitlab::Timeless.timeless(merge_request, &block)
102
    end
103
  end
104

105
  validates :source_project, presence: true, unless: [:allow_broken, :importing?, :closed_without_fork?]
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
106
  validates :source_branch, presence: true
107
  validates :target_project, presence: true
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
108
  validates :target_branch, presence: true
109
  validates :merge_user, presence: true, if: :merge_when_pipeline_succeeds?, unless: :importing?
110 111
  validate :validate_branches, unless: [:allow_broken, :importing?, :closed_without_fork?]
  validate :validate_fork, unless: :closed_without_fork?
112
  validate :validate_target_project, on: :create
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
113

114 115 116
  scope :by_source_or_target_branch, ->(branch_name) do
    where("source_branch = :branch OR target_branch = :branch", branch: branch_name)
  end
117
  scope :by_milestone, ->(milestone) { where(milestone_id: milestone) }
118
  scope :of_projects, ->(ids) { where(target_project_id: ids) }
119
  scope :from_project, ->(project) { where(source_project_id: project.id) }
120 121
  scope :merged, -> { with_state(:merged) }
  scope :closed_and_merged, -> { with_states(:closed, :merged) }
122
  scope :from_source_branches, ->(branches) { where(source_branch: branches) }
123

124 125
  scope :join_project, -> { joins(:target_project) }
  scope :references_project, -> { references(:target_project) }
126 127 128 129 130
  scope :assigned, -> { where("assignee_id IS NOT NULL") }
  scope :unassigned, -> { where("assignee_id IS NULL") }
  scope :assigned_to, ->(u) { where(assignee_id: u.id)}

  participant :assignee
131

132 133
  after_save :keep_around_commit

134 135 136 137
  def self.reference_prefix
    '!'
  end

138 139 140 141
  # Pattern used to extract `!123` merge request references from text
  #
  # This pattern supports cross-project references.
  def self.reference_pattern
142
    @reference_pattern ||= %r{
143
      (#{Project.reference_pattern})?
144 145 146 147
      #{Regexp.escape(reference_prefix)}(?<merge_request>\d+)
    }x
  end

148
  def self.link_reference_pattern
149
    @link_reference_pattern ||= super("merge_requests", /(?<merge_request>\d+)/)
150 151
  end

152 153 154 155
  def self.reference_valid?(reference)
    reference.to_i > 0 && reference.to_i <= Gitlab::Database::MAX_INT_VALUE
  end

156 157 158 159
  def self.project_foreign_key
    'target_project_id'
  end

160 161 162 163 164 165 166 167 168 169 170
  # Returns all the merge requests from an ActiveRecord:Relation.
  #
  # This method uses a UNION as it usually operates on the result of
  # ProjectsFinder#execute. PostgreSQL in particular doesn't always like queries
  # using multiple sub-queries especially when combined with an OR statement.
  # UNIONs on the other hand perform much better in these cases.
  #
  # relation - An ActiveRecord::Relation that returns a list of Projects.
  #
  # Returns an ActiveRecord::Relation.
  def self.in_projects(relation)
171 172 173 174
    # unscoping unnecessary conditions that'll be applied
    # when executing `where("merge_requests.id IN (#{union.to_sql})")`
    source = unscoped.where(source_project_id: relation).select(:id)
    target = unscoped.where(target_project_id: relation).select(:id)
175 176 177 178 179
    union  = Gitlab::SQL::Union.new([source, target])

    where("merge_requests.id IN (#{union.to_sql})")
  end

180 181 182 183 184 185 186 187 188 189 190 191 192 193
  WIP_REGEX = /\A\s*(\[WIP\]\s*|WIP:\s*|WIP\s+)+\s*/i.freeze

  def self.work_in_progress?(title)
    !!(title =~ WIP_REGEX)
  end

  def self.wipless_title(title)
    title.sub(WIP_REGEX, "")
  end

  def self.wip_title(title)
    work_in_progress?(title) ? title : "WIP: #{title}"
  end

194 195 196 197 198 199 200 201
  # Returns a Hash of attributes to be used for Twitter card metadata
  def card_attributes
    {
      'Author'   => author.try(:name),
      'Assignee' => assignee.try(:name)
    }
  end

202
  # These method are needed for compatibility with issues to not mess view and other code
203 204 205 206
  def assignees
    Array(assignee)
  end

207 208 209 210 211 212 213 214
  def assignee_ids
    Array(assignee_id)
  end

  def assignee_ids=(ids)
    write_attribute(:assignee_id, ids.last)
  end

215 216 217 218
  def assignee_or_author?(user)
    author_id == user.id || assignee_id == user.id
  end

219
  # `from` argument can be a Namespace or Project.
220
  def to_reference(from = nil, full: false)
221 222
    reference = "#{self.class.reference_prefix}#{iid}"

223
    "#{project.to_reference(from, full: full)}#{reference}"
224 225
  end

226 227
  def first_commit
    merge_request_diff ? merge_request_diff.first_commit : compare_commits.first
228
  end
229

230
  def raw_diffs(*args)
231
    merge_request_diff ? merge_request_diff.raw_diffs(*args) : compare.raw_diffs(*args)
232 233
  end

234
  def diffs(diff_options = {})
235
    if compare
236
      # When saving MR diffs, `expanded` is implicitly added (because we need
237 238
      # to save the entire contents to the DB), so add that here for
      # consistency.
239
      compare.diffs(diff_options.merge(expanded: true))
240
    else
241
      merge_request_diff.diffs(diff_options)
242
    end
243 244
  end

245
  def diff_size
246 247 248
    # Calling `merge_request_diff.diffs.real_size` will also perform
    # highlighting, which we don't need here.
    return real_size if merge_request_diff
249

250
    diffs.real_size
251 252
  end

253
  def diff_base_commit
254
    if persisted?
255
      merge_request_diff.base_commit
256 257
    else
      branch_merge_base_commit
258 259 260 261 262 263 264 265
    end
  end

  def diff_start_commit
    if persisted?
      merge_request_diff.start_commit
    else
      target_branch_head
266 267 268
    end
  end

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
  def diff_head_commit
    if persisted?
      merge_request_diff.head_commit
    else
      source_branch_head
    end
  end

  def diff_start_sha
    diff_start_commit.try(:sha)
  end

  def diff_base_sha
    diff_base_commit.try(:sha)
  end

  def diff_head_sha
    diff_head_commit.try(:sha)
  end

  # When importing a pull request from GitHub, the old and new branches may no
  # longer actually exist by those names, but we need to recreate the merge
  # request diff with the right source and target shas.
  # We use these attributes to force these to the intended values.
  attr_writer :target_branch_sha, :source_branch_sha

  def source_branch_head
296 297
    return unless source_project

298
    source_branch_ref = @source_branch_sha || source_branch
299
    source_project.repository.commit(source_branch_ref) if source_branch_ref
300 301 302 303
  end

  def target_branch_head
    target_branch_ref = @target_branch_sha || target_branch
304
    target_project.repository.commit(target_branch_ref) if target_branch_ref
305 306
  end

307 308 309 310 311 312 313 314 315
  def branch_merge_base_commit
    start_sha = target_branch_sha
    head_sha  = source_branch_sha

    if start_sha && head_sha
      target_project.merge_base_commit(start_sha, head_sha)
    end
  end

316
  def target_branch_sha
317
    @target_branch_sha || target_branch_head.try(:sha)
318 319 320
  end

  def source_branch_sha
321
    @source_branch_sha || source_branch_head.try(:sha)
322 323
  end

324
  def diff_refs
325
    if persisted?
326
      merge_request_diff.diff_refs
327
    else
328 329 330 331 332
      Gitlab::Diff::DiffRefs.new(
        base_sha:  diff_base_sha,
        start_sha: diff_start_sha,
        head_sha:  diff_head_sha
      )
333
    end
334 335
  end

336 337 338 339
  def branch_merge_base_sha
    branch_merge_base_commit.try(:sha)
  end

340
  def validate_branches
341
    if target_project == source_project && target_branch == source_branch
342
      errors.add :branch_conflict, "You can not use same project/branch for source and target"
343
    end
344

345
    if opened? || reopened?
346
      similar_mrs = self.target_project.merge_requests.where(source_branch: source_branch, target_branch: target_branch, source_project_id: source_project.try(:id)).opened
347 348
      similar_mrs = similar_mrs.where('id not in (?)', self.id) if self.id
      if similar_mrs.any?
349
        errors.add :validate_branches,
Gabriel Mazetto's avatar
Gabriel Mazetto committed
350
                   "Cannot Create: This merge request already exists: #{similar_mrs.pluck(:title)}"
351
      end
352
    end
353 354
  end

355 356 357 358 359 360
  def validate_target_project
    return true if target_project.merge_requests_enabled?

    errors.add :base, 'Target project has disabled merge requests'
  end

361
  def validate_fork
362
    return true unless target_project && source_project
363
    return true if target_project == source_project
364
    return true unless source_project_missing?
365

366
    errors.add :validate_fork,
367
               'Source project is not a fork of the target project'
368 369 370
  end

  def closed_without_fork?
371
    closed? && source_project_missing?
372 373
  end

374
  def source_project_missing?
375 376 377 378
    return false unless for_fork?
    return true unless source_project

    !source_project.forked_from?(target_project)
379 380
  end

381
  def reopenable?
382
    closed? && !source_project_missing? && source_branch_exists?
Katarzyna Kobierska's avatar
Katarzyna Kobierska committed
383 384
  end

385 386
  def ensure_merge_request_diff
    merge_request_diff || create_merge_request_diff
387 388
  end

389 390 391 392 393 394 395 396 397
  def create_merge_request_diff
    merge_request_diffs.create
    reload_merge_request_diff
  end

  def reload_merge_request_diff
    merge_request_diff(true)
  end

398 399 400 401 402 403 404 405 406
  def merge_request_diff_for(diff_refs_or_sha)
    @merge_request_diffs_by_diff_refs_or_sha ||= Hash.new do |h, diff_refs_or_sha|
      diffs = merge_request_diffs.viewable.select_without_diff
      h[diff_refs_or_sha] =
        if diff_refs_or_sha.is_a?(Gitlab::Diff::DiffRefs)
          diffs.find_by_diff_refs(diff_refs_or_sha)
        else
          diffs.find_by(head_commit_sha: diff_refs_or_sha)
        end
Douwe Maan's avatar
Douwe Maan committed
407 408
    end

409
    @merge_request_diffs_by_diff_refs_or_sha[diff_refs_or_sha]
410 411
  end

412 413 414 415 416 417 418 419 420 421 422
  def version_params_for(diff_refs)
    if diff = merge_request_diff_for(diff_refs)
      { diff_id: diff.id }
    elsif diff = merge_request_diff_for(diff_refs.head_sha)
      {
        diff_id: diff.id,
        start_sha: diff_refs.start_sha
      }
    end
  end

423
  def reload_diff_if_branch_changed
424
    if source_branch_changed? || target_branch_changed?
425
      reload_diff
426 427 428
    end
  end

429
  def reload_diff(current_user = nil)
430 431
    return unless open?

432
    old_diff_refs = self.diff_refs
433
    create_merge_request_diff
434
    MergeRequests::MergeRequestDiffCacheService.new.execute(self)
435 436
    new_diff_refs = self.diff_refs

437
    update_diff_discussion_positions(
438
      old_diff_refs: old_diff_refs,
439 440
      new_diff_refs: new_diff_refs,
      current_user: current_user
441
    )
442 443
  end

444
  def check_if_can_be_merged
445 446
    return unless unchecked?

447
    can_be_merged =
448
      !broken? && project.repository.can_be_merged?(diff_head_sha, target_branch)
449 450

    if can_be_merged
451 452 453 454
      mark_as_mergeable
    else
      mark_as_unmergeable
    end
455 456
  end

457
  def merge_event
458
    @merge_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::MERGED).last
459 460
  end

461
  def closed_event
462
    @closed_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::CLOSED).last
463 464
  end

465
  def work_in_progress?
466
    self.class.work_in_progress?(title)
467 468 469
  end

  def wipless_title
470 471 472 473 474
    self.class.wipless_title(self.title)
  end

  def wip_title
    self.class.wip_title(self.title)
475 476
  end

477 478
  def mergeable?(skip_ci_check: false)
    return false unless mergeable_state?(skip_ci_check: skip_ci_check)
479 480 481 482

    check_if_can_be_merged

    can_be_merged?
483 484
  end

485
  def mergeable_state?(skip_ci_check: false)
486 487 488
    return false unless open?
    return false if work_in_progress?
    return false if broken?
489
    return false unless skip_ci_check || mergeable_ci_state?
490
    return false unless mergeable_discussions_state?
491 492

    true
493 494
  end

495
  def can_cancel_merge_when_pipeline_succeeds?(current_user)
496
    can_be_merged_by?(current_user) || self.author == current_user
497 498
  end

499
  def can_remove_source_branch?(current_user)
500
    !ProtectedBranch.protected?(source_project, source_branch) &&
501
      !source_project.root_ref?(source_branch) &&
502
      Ability.allowed?(current_user, :push_code, source_project) &&
503
      diff_head_commit == source_branch_head
504 505
  end

506
  def should_remove_source_branch?
507
    Gitlab::Utils.to_boolean(merge_params['should_remove_source_branch'])
508 509 510
  end

  def force_remove_source_branch?
511
    Gitlab::Utils.to_boolean(merge_params['force_remove_source_branch'])
512 513 514 515 516 517
  end

  def remove_source_branch?
    should_remove_source_branch? || force_remove_source_branch?
  end

518
  def related_notes
519 520
    # Fetch comments only from last 100 commits
    commits_for_notes_limit = 100
521
    commit_ids = commit_shas.take(commits_for_notes_limit)
522

523 524
    Note.where(
      "(project_id = :target_project_id AND noteable_type = 'MergeRequest' AND noteable_id = :mr_id) OR" +
525
      "((project_id = :source_project_id OR project_id = :target_project_id) AND noteable_type = 'Commit' AND commit_id IN (:commit_ids))",
526
      mr_id: id,
527 528 529
      commit_ids: commit_ids,
      target_project_id: target_project_id,
      source_project_id: source_project_id
530
    )
531
  end
532

533
  alias_method :discussion_notes, :related_notes
534

535 536 537
  def mergeable_discussions_state?
    return true unless project.only_allow_merge_if_all_discussions_are_resolved?

538
    !discussions_to_be_resolved?
539 540
  end

Kirill Zaitsev's avatar
Kirill Zaitsev committed
541 542
  def hook_attrs
    attrs = {
543
      source: source_project.try(:hook_attrs),
Kirill Zaitsev's avatar
Kirill Zaitsev committed
544
      target: target_project.hook_attrs,
545
      last_commit: nil,
546 547 548 549
      work_in_progress: work_in_progress?,
      total_time_spent: total_time_spent,
      human_total_time_spent: human_total_time_spent,
      human_time_estimate: human_time_estimate
Kirill Zaitsev's avatar
Kirill Zaitsev committed
550 551
    }

552
    if diff_head_commit
553
      attrs[:last_commit] = diff_head_commit.hook_attrs
Kirill Zaitsev's avatar
Kirill Zaitsev committed
554 555 556 557 558
    end

    attributes.merge!(attrs)
  end

559 560 561 562
  def for_fork?
    target_project != source_project
  end

563 564 565 566
  def project
    target_project
  end

567 568 569 570
  # If the merge request closes any issues, save this information in the
  # `MergeRequestsClosingIssues` model. This is a performance optimization.
  # Calculating this information for a number of merge requests requires
  # running `ReferenceExtractor` on each of them separately.
571
  # This optimization does not apply to issues from external sources.
572
  def cache_merge_request_closes_issues!(current_user)
573 574
    return if project.has_external_issue_tracker?

575
    transaction do
576
      self.merge_requests_closing_issues.delete_all
577

578
      closes_issues(current_user).each do |issue|
579
        self.merge_requests_closing_issues.create!(issue: issue)
580 581 582 583
      end
    end
  end

584
  # Return the set of issues that will be closed if this merge request is accepted.
585
  def closes_issues(current_user = self.author)
586
    if target_branch == project.default_branch
587
      messages = [title, description]
588
      messages.concat(commits.map(&:safe_message)) if merge_request_diff
589

590 591
      Gitlab::ClosingIssueExtractor.new(project, current_user)
        .closed_by_message(messages.join("\n"))
592 593 594 595 596
    else
      []
    end
  end

597
  def issues_mentioned_but_not_closing(current_user)
598
    return [] unless target_branch == project.default_branch
599

600
    ext = Gitlab::ReferenceExtractor.new(project, current_user)
601
    ext.analyze("#{title}\n#{description}")
602

603
    ext.issues - closes_issues(current_user)
604 605
  end

606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
  def target_project_path
    if target_project
      target_project.path_with_namespace
    else
      "(removed)"
    end
  end

  def source_project_path
    if source_project
      source_project.path_with_namespace
    else
      "(removed)"
    end
  end

622 623
  def source_project_namespace
    if source_project && source_project.namespace
624
      source_project.namespace.full_path
625 626 627 628 629
    else
      "(removed)"
    end
  end

630 631
  def target_project_namespace
    if target_project && target_project.namespace
632
      target_project.namespace.full_path
633 634 635 636 637
    else
      "(removed)"
    end
  end

638 639 640 641 642 643 644 645 646 647 648 649
  def source_branch_exists?
    return false unless self.source_project

    self.source_project.repository.branch_names.include?(self.source_branch)
  end

  def target_branch_exists?
    return false unless self.target_project

    self.target_project.repository.branch_names.include?(self.target_branch)
  end

650
  def merge_commit_message(include_description: false)
651 652 653 654
    closes_issues_references = closes_issues.map do |issue|
      issue.to_reference(target_project)
    end

655 656 657 658
    message = [
      "Merge branch '#{source_branch}' into '#{target_branch}'",
      title
    ]
659

660
    if !include_description && closes_issues_references.present?
661
      message << "Closes #{closes_issues_references.to_sentence}"
662 663
    end

664
    message << "#{description}" if include_description && description.present?
665 666
    message << "See merge request #{to_reference}"

667
    message.join("\n\n")
668
  end
669

670 671
  def reset_merge_when_pipeline_succeeds
    return unless merge_when_pipeline_succeeds?
672

673
    self.merge_when_pipeline_succeeds = false
674
    self.merge_user = nil
675 676 677 678
    if merge_params
      merge_params.delete('should_remove_source_branch')
      merge_params.delete('commit_message')
    end
679 680 681 682

    self.save
  end

683
  # Return array of possible target branches
Steven Burgart's avatar
Steven Burgart committed
684
  # depends on target project of MR
685 686 687 688 689 690 691 692 693
  def target_branches
    if target_project.nil?
      []
    else
      target_project.repository.branch_names
    end
  end

  # Return array of possible source branches
Steven Burgart's avatar
Steven Burgart committed
694
  # depends on source project of MR
695 696 697 698 699 700 701
  def source_branches
    if source_project.nil?
      []
    else
      source_project.repository.branch_names
    end
  end
702 703

  def locked_long_ago?
Ben Bodenmiller's avatar
Ben Bodenmiller committed
704 705 706
    return false unless locked?

    locked_at.nil? || locked_at < (Time.now - 1.day)
707
  end
708 709

  def has_ci?
710 711 712 713
    has_ci_integration = source_project.try(:ci_service)
    uses_gitlab_ci = all_pipelines.any?

    (has_ci_integration || uses_gitlab_ci) && commits.any?
714 715 716 717 718
  end

  def branch_missing?
    !source_branch_exists? || !target_branch_exists?
  end
719

720
  def broken?
721
    has_no_commits? || branch_missing? || cannot_be_merged?
722 723
  end

724
  def can_be_merged_by?(user)
725 726 727 728 729 730 731
    access = ::Gitlab::UserAccess.new(user, project: project)
    access.can_push_to_branch?(target_branch) || access.can_merge_to_branch?(target_branch)
  end

  def can_be_merged_via_command_line_by?(user)
    access = ::Gitlab::UserAccess.new(user, project: project)
    access.can_push_to_branch?(target_branch)
732 733
  end

734
  def mergeable_ci_state?
735
    return true unless project.only_allow_merge_if_pipeline_succeeds?
736

737
    !head_pipeline || head_pipeline.success? || head_pipeline.skipped?
738 739
  end

Douwe Maan's avatar
Douwe Maan committed
740
  def environments_for(current_user)
741
    return [] unless diff_head_commit
742

Douwe Maan's avatar
Douwe Maan committed
743 744 745
    @environments ||= Hash.new do |h, current_user|
      envs = EnvironmentsFinder.new(target_project, current_user,
        ref: target_branch, commit: diff_head_commit, with_tags: true).execute
746

Douwe Maan's avatar
Douwe Maan committed
747 748 749 750
      if source_project
        envs.concat EnvironmentsFinder.new(source_project, current_user,
          ref: source_branch, commit: diff_head_commit).execute
      end
751

Douwe Maan's avatar
Douwe Maan committed
752
      h[current_user] = envs.uniq
753
    end
Douwe Maan's avatar
Douwe Maan committed
754 755

    @environments[current_user]
756 757
  end

758 759 760 761 762 763 764 765 766
  def state_human_name
    if merged?
      "Merged"
    elsif closed?
      "Closed"
    else
      "Open"
    end
  end
767

768 769 770 771 772 773 774 775 776 777
  def state_icon_name
    if merged?
      "check"
    elsif closed?
      "times"
    else
      "circle-o"
    end
  end

778 779 780 781
  def fetch_ref
    target_project.repository.fetch_ref(
      source_project.repository.path_to_repo,
      "refs/heads/#{source_branch}",
782
      ref_path
783
    )
784
    update_column(:ref_fetched, true)
785 786
  end

787 788 789 790
  def ref_path
    "refs/merge-requests/#{iid}/head"
  end

791
  def ref_fetched?
792 793 794 795 796 797 798
    super ||
      begin
        computed_value = project.repository.ref_exists?(ref_path)
        update_column(:ref_fetched, true) if computed_value

        computed_value
      end
799 800 801
  end

  def ensure_ref_fetched
802
    fetch_ref unless ref_fetched?
803 804
  end

805 806 807 808 809 810 811 812
  def in_locked_state
    begin
      lock_mr
      yield
    ensure
      unlock_mr if locked?
    end
  end
813

814 815 816
  def diverged_commits_count
    cache = Rails.cache.read(:"merge_request_#{id}_diverged_commits")

817
    if cache.blank? || cache[:source_sha] != source_branch_sha || cache[:target_sha] != target_branch_sha
818
      cache = {
819 820
        source_sha: source_branch_sha,
        target_sha: target_branch_sha,
821 822 823 824 825 826 827 828 829
        diverged_commits_count: compute_diverged_commits_count
      }
      Rails.cache.write(:"merge_request_#{id}_diverged_commits", cache)
    end

    cache[:diverged_commits_count]
  end

  def compute_diverged_commits_count
830
    return 0 unless source_branch_sha && target_branch_sha
831

832
    Gitlab::Git::Commit.between(target_project.repository.raw_repository, source_branch_sha, target_branch_sha).size
833
  end
834
  private :compute_diverged_commits_count
835 836 837 838 839

  def diverged_from_target_branch?
    diverged_commits_count > 0
  end

840
  def all_pipelines
841
    return Ci::Pipeline.none unless source_project
842

843
    @all_pipelines ||= source_project.pipelines
844
      .where(sha: all_commit_shas, ref: source_branch)
845
      .order(id: :desc)
846
  end
847

848
  # Note that this could also return SHA from now dangling commits
849
  #
850
  def all_commit_shas
851
    if persisted?
852 853 854 855
      column_shas = MergeRequestDiffCommit.where(merge_request_diff: merge_request_diffs).pluck('DISTINCT(sha)')
      serialised_shas = merge_request_diffs.where.not(st_commits: nil).flat_map(&:commit_shas)

      (column_shas + serialised_shas).uniq
856 857
    elsif compare_commits
      compare_commits.to_a.reverse.map(&:id)
858
    else
859
      [diff_head_sha]
860
    end
861 862
  end

863 864 865 866
  def merge_commit
    @merge_commit ||= project.commit(merge_commit_sha) if merge_commit_sha
  end

867
  def can_be_reverted?(current_user)
868
    merge_commit && !merge_commit.has_been_reverted?(current_user, self)
869
  end
870 871

  def can_be_cherry_picked?
Fatih Acet's avatar
Fatih Acet committed
872
    merge_commit.present?
873
  end
874

875
  def has_complete_diff_refs?
876
    diff_refs && diff_refs.complete?
877 878
  end

879
  def update_diff_discussion_positions(old_diff_refs:, new_diff_refs:, current_user: nil)
880
    return unless has_complete_diff_refs?
881 882
    return if new_diff_refs == old_diff_refs

883 884
    active_diff_discussions = self.notes.new_diff_notes.discussions.select do |discussion|
      discussion.active?(old_diff_refs)
885
    end
886
    return if active_diff_discussions.empty?
887

888
    paths = active_diff_discussions.flat_map { |n| n.diff_file.paths }.uniq
889

890
    service = Discussions::UpdateDiffPositionService.new(
891
      self.project,
892
      current_user,
893 894 895 896 897
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs,
      paths: paths
    )

898 899
    active_diff_discussions.each do |discussion|
      service.execute(discussion)
900 901 902
    end
  end

903 904 905
  def keep_around_commit
    project.repository.keep_around(self.merge_commit_sha)
  end
906

907
  def has_commits?
908
    merge_request_diff && commits_count > 0
909 910 911 912 913
  end

  def has_no_commits?
    !has_commits?
  end
914

915
  def mergeable_with_quick_action?(current_user, autocomplete_precheck: false, last_diff_sha: nil)
916 917 918 919 920 921 922 923 924 925
    return false unless can_be_merged_by?(current_user)

    return true if autocomplete_precheck

    return false unless mergeable?(skip_ci_check: true)
    return false if head_pipeline && !(head_pipeline.success? || head_pipeline.active?)
    return false if last_diff_sha != diff_head_sha

    true
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
926
end