BigW Consortium Gitlab

merge_request.rb 24.9 KB
Newer Older
1
class MergeRequest < ActiveRecord::Base
2
  include InternalId
3 4
  include Issuable
  include Referable
5
  include Sortable
6
  include Importable
7

8 9
  belongs_to :target_project, class_name: "Project"
  belongs_to :source_project, class_name: "Project"
10
  belongs_to :project, foreign_key: :target_project_id
11
  belongs_to :merge_user, class_name: "User"
12

13
  has_many :merge_request_diffs, dependent: :destroy
14 15 16
  has_one :merge_request_diff,
    -> { order('merge_request_diffs.id DESC') }

17 18
  has_many :events, as: :target, dependent: :destroy

19
  has_many :merge_requests_closing_issues, class_name: 'MergeRequestsClosingIssues', dependent: :delete_all
20

21 22
  serialize :merge_params, Hash

23 24
  after_create :ensure_merge_request_diff, unless: :importing?
  after_update :reload_diff_if_branch_changed
25

26 27
  delegate :commits, :real_size, :commits_sha, :commits_count,
    to: :merge_request_diff, prefix: nil
28

29 30 31 32
  # When this attribute is true some MR validation is ignored
  # It allows us to close or modify broken merge requests
  attr_accessor :allow_broken

33 34
  # Temporary fields to store compare vars
  # when creating new merge request
35
  attr_accessor :can_be_created, :compare_commits, :diff_options, :compare
36

Andrew8xx8 committed
37
  state_machine :state, initial: :opened do
38 39 40 41
    event :close do
      transition [:reopened, :opened] => :closed
    end

42
    event :mark_as_merged do
43
      transition [:reopened, :opened, :locked] => :merged
44 45 46
    end

    event :reopen do
Andrew8xx8 committed
47
      transition closed: :reopened
48 49
    end

50
    event :lock_mr do
51 52 53
      transition [:reopened, :opened] => :locked
    end

54
    event :unlock_mr do
55 56 57
      transition locked: :reopened
    end

58 59 60 61 62
    after_transition any => :locked do |merge_request, transition|
      merge_request.locked_at = Time.now
      merge_request.save
    end

63
    after_transition locked: (any - :locked) do |merge_request, transition|
64 65 66 67
      merge_request.locked_at = nil
      merge_request.save
    end

68 69 70 71
    state :opened
    state :reopened
    state :closed
    state :merged
72
    state :locked
73 74
  end

75 76 77 78 79 80
  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
81
      transition [:unchecked, :cannot_be_merged] => :can_be_merged
82 83 84
    end

    event :mark_as_unmergeable do
85
      transition [:unchecked, :can_be_merged] => :cannot_be_merged
86 87
    end

88
    state :unchecked
89 90
    state :can_be_merged
    state :cannot_be_merged
91 92

    around_transition do |merge_request, transition, block|
93
      Gitlab::Timeless.timeless(merge_request, &block)
94
    end
95
  end
96

97
  validates :source_project, presence: true, unless: [:allow_broken, :importing?, :closed_without_fork?]
Andrey Kumanyaev committed
98
  validates :source_branch, presence: true
99
  validates :target_project, presence: true
Andrey Kumanyaev committed
100
  validates :target_branch, presence: true
101
  validates :merge_user, presence: true, if: :merge_when_pipeline_succeeds?, unless: :importing?
102 103
  validate :validate_branches, unless: [:allow_broken, :importing?, :closed_without_fork?]
  validate :validate_fork, unless: :closed_without_fork?
104

105 106 107
  scope :by_source_or_target_branch, ->(branch_name) do
    where("source_branch = :branch OR target_branch = :branch", branch: branch_name)
  end
108
  scope :cared, ->(user) { where('assignee_id = :user OR author_id = :user', user: user.id) }
109
  scope :by_milestone, ->(milestone) { where(milestone_id: milestone) }
110
  scope :of_projects, ->(ids) { where(target_project_id: ids) }
111
  scope :from_project, ->(project) { where(source_project_id: project.id) }
112 113
  scope :merged, -> { with_state(:merged) }
  scope :closed_and_merged, -> { with_states(:closed, :merged) }
114
  scope :from_source_branches, ->(branches) { where(source_branch: branches) }
115

116 117 118
  scope :join_project, -> { joins(:target_project) }
  scope :references_project, -> { references(:target_project) }

119 120
  after_save :keep_around_commit

121 122 123 124
  def self.reference_prefix
    '!'
  end

125 126 127 128
  # Pattern used to extract `!123` merge request references from text
  #
  # This pattern supports cross-project references.
  def self.reference_pattern
129
    @reference_pattern ||= %r{
130
      (#{Project.reference_pattern})?
131 132 133 134
      #{Regexp.escape(reference_prefix)}(?<merge_request>\d+)
    }x
  end

135
  def self.link_reference_pattern
136
    @link_reference_pattern ||= super("merge_requests", /(?<merge_request>\d+)/)
137 138
  end

139 140 141 142
  def self.reference_valid?(reference)
    reference.to_i > 0 && reference.to_i <= Gitlab::Database::MAX_INT_VALUE
  end

143 144 145 146
  def self.project_foreign_key
    'target_project_id'
  end

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
  # 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)
    source = where(source_project_id: relation).select(:id)
    target = where(target_project_id: relation).select(:id)
    union  = Gitlab::SQL::Union.new([source, target])

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

165 166 167 168 169 170 171 172 173 174 175 176 177 178
  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

179
  # `from` argument can be a Namespace or Project.
180
  def to_reference(from = nil, full: false)
181 182
    reference = "#{self.class.reference_prefix}#{iid}"

183
    "#{project.to_reference(from, full: full)}#{reference}"
184 185
  end

186 187
  def first_commit
    merge_request_diff ? merge_request_diff.first_commit : compare_commits.first
188
  end
189

190
  def raw_diffs(*args)
191
    merge_request_diff ? merge_request_diff.raw_diffs(*args) : compare.raw_diffs(*args)
192 193
  end

194
  def diffs(diff_options = nil)
195 196
    if compare
      compare.diffs(diff_options)
197
    else
198
      merge_request_diff.diffs(diff_options)
199
    end
200 201
  end

202
  def diff_size
203 204 205 206 207
    # The `#diffs` method ends up at an instance of a class inheriting from
    # `Gitlab::Diff::FileCollection::Base`, so use those options as defaults
    # here too, to get the same diff size without performing highlighting.
    #
    opts = Gitlab::Diff::FileCollection::Base.default_options.merge(diff_options || {})
208 209

    raw_diffs(opts).size
210 211
  end

212
  def diff_base_commit
213
    if persisted?
214
      merge_request_diff.base_commit
215 216
    else
      branch_merge_base_commit
217 218 219 220 221 222 223 224 225
    end
  end

  # MRs created before 8.4 don't store a MergeRequestDiff#base_commit_sha,
  # but we need to get a commit for the "View file @ ..." link by deleted files,
  # so we find the likely one if we can't get the actual one.
  # This will not be the actual base commit if the target branch was merged into
  # the source branch after the merge request was created, but it is good enough
  # for the specific purpose of linking to a commit.
226 227 228
  # It is not good enough for use in `Gitlab::Git::DiffRefs`, which needs the
  # true base commit, so we can't simply have `#diff_base_commit` fall back on
  # this method.
229
  def likely_diff_base_commit
230
    first_commit.try(:parent) || first_commit
231 232 233 234 235 236 237
  end

  def diff_start_commit
    if persisted?
      merge_request_diff.start_commit
    else
      target_branch_head
238 239 240
    end
  end

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
  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
    source_branch_ref = @source_branch_sha || source_branch
269
    source_project.repository.commit(source_branch_ref) if source_branch_ref
270 271 272 273
  end

  def target_branch_head
    target_branch_ref = @target_branch_sha || target_branch
274
    target_project.repository.commit(target_branch_ref) if target_branch_ref
275 276
  end

277 278 279 280 281 282 283 284 285
  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

286
  def target_branch_sha
287
    @target_branch_sha || target_branch_head.try(:sha)
288 289 290
  end

  def source_branch_sha
291
    @source_branch_sha || source_branch_head.try(:sha)
292 293
  end

294 295 296 297 298 299 300 301
  def diff_refs
    return unless diff_start_commit || diff_base_commit

    Gitlab::Diff::DiffRefs.new(
      base_sha:  diff_base_sha,
      start_sha: diff_start_sha,
      head_sha:  diff_head_sha
    )
302 303
  end

304 305
  # Return diff_refs instance trying to not touch the git repository
  def diff_sha_refs
306
    if merge_request_diff && merge_request_diff.diff_refs_by_sha?
307
      merge_request_diff.diff_refs
308
    else
309
      diff_refs
310
    end
311 312
  end

313 314 315 316
  def branch_merge_base_sha
    branch_merge_base_commit.try(:sha)
  end

317
  def validate_branches
318
    if target_project == source_project && target_branch == source_branch
319
      errors.add :branch_conflict, "You can not use same project/branch for source and target"
320
    end
321

322
    if opened? || reopened?
323
      similar_mrs = self.target_project.merge_requests.where(source_branch: source_branch, target_branch: target_branch, source_project_id: source_project.try(:id)).opened
324 325
      similar_mrs = similar_mrs.where('id not in (?)', self.id) if self.id
      if similar_mrs.any?
326
        errors.add :validate_branches,
327
                   "Cannot Create: This merge request already exists: #{similar_mrs.pluck(:title)}"
328
      end
329
    end
330 331
  end

332
  def validate_fork
333
    return true unless target_project && source_project
334
    return true if target_project == source_project
335
    return true unless source_project_missing?
336

337
    errors.add :validate_fork,
338
               'Source project is not a fork of the target project'
339 340 341
  end

  def closed_without_fork?
342
    closed? && source_project_missing?
343 344
  end

345
  def source_project_missing?
346 347 348 349
    return false unless for_fork?
    return true unless source_project

    !source_project.forked_from?(target_project)
350 351
  end

352
  def reopenable?
353
    closed? && !source_project_missing? && source_branch_exists?
Katarzyna Kobierska committed
354 355
  end

356 357
  def ensure_merge_request_diff
    merge_request_diff || create_merge_request_diff
358 359
  end

360 361 362 363 364 365 366 367 368
  def create_merge_request_diff
    merge_request_diffs.create
    reload_merge_request_diff
  end

  def reload_merge_request_diff
    merge_request_diff(true)
  end

369
  def reload_diff_if_branch_changed
370
    if source_branch_changed? || target_branch_changed?
371
      reload_diff
372 373 374
    end
  end

375
  def reload_diff
376 377
    return unless open?

378
    old_diff_refs = self.diff_refs
379
    create_merge_request_diff
380
    MergeRequests::MergeRequestDiffCacheService.new.execute(self)
381 382 383 384 385 386
    new_diff_refs = self.diff_refs

    update_diff_notes_positions(
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs
    )
387 388
  end

389
  def check_if_can_be_merged
390 391
    return unless unchecked?

392
    can_be_merged =
393
      !broken? && project.repository.can_be_merged?(diff_head_sha, target_branch)
394 395

    if can_be_merged
396 397 398 399
      mark_as_mergeable
    else
      mark_as_unmergeable
    end
400 401
  end

402
  def merge_event
403
    @merge_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::MERGED).last
404 405
  end

406
  def closed_event
407
    @closed_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::CLOSED).last
408 409
  end

410
  def work_in_progress?
411
    self.class.work_in_progress?(title)
412 413 414
  end

  def wipless_title
415 416 417 418 419
    self.class.wipless_title(self.title)
  end

  def wip_title
    self.class.wip_title(self.title)
420 421
  end

422 423
  def mergeable?(skip_ci_check: false)
    return false unless mergeable_state?(skip_ci_check: skip_ci_check)
424 425 426 427

    check_if_can_be_merged

    can_be_merged?
428 429
  end

430
  def mergeable_state?(skip_ci_check: false)
431 432 433
    return false unless open?
    return false if work_in_progress?
    return false if broken?
434
    return false unless skip_ci_check || mergeable_ci_state?
435
    return false unless mergeable_discussions_state?
436 437

    true
438 439
  end

440
  def can_cancel_merge_when_pipeline_succeeds?(current_user)
441
    can_be_merged_by?(current_user) || self.author == current_user
442 443
  end

444
  def can_remove_source_branch?(current_user)
445
    !ProtectedBranch.protected?(source_project, source_branch) &&
446
      !source_project.root_ref?(source_branch) &&
447
      Ability.allowed?(current_user, :push_code, source_project) &&
448
      diff_head_commit == source_branch_head
449 450
  end

451
  def should_remove_source_branch?
452
    Gitlab::Utils.to_boolean(merge_params['should_remove_source_branch'])
453 454 455
  end

  def force_remove_source_branch?
456
    Gitlab::Utils.to_boolean(merge_params['force_remove_source_branch'])
457 458 459 460 461 462
  end

  def remove_source_branch?
    should_remove_source_branch? || force_remove_source_branch?
  end

463
  def related_notes
464 465 466 467
    # Fetch comments only from last 100 commits
    commits_for_notes_limit = 100
    commit_ids = commits.last(commits_for_notes_limit).map(&:id)

468 469
    Note.where(
      "(project_id = :target_project_id AND noteable_type = 'MergeRequest' AND noteable_id = :mr_id) OR" +
470
      "((project_id = :source_project_id OR project_id = :target_project_id) AND noteable_type = 'Commit' AND commit_id IN (:commit_ids))",
471
      mr_id: id,
472 473 474
      commit_ids: commit_ids,
      target_project_id: target_project_id,
      source_project_id: source_project_id
475
    )
476
  end
477

478
  def discussions
479
    @discussions ||= self.related_notes.
480
      inc_relations_for_view.
481 482 483 484
      fresh.
      discussions
  end

485 486 487 488
  def diff_discussions
    @diff_discussions ||= self.notes.diff_notes.discussions
  end

489 490 491 492 493 494 495 496
  def resolvable_discussions
    @resolvable_discussions ||= diff_discussions.select(&:to_be_resolved?)
  end

  def discussions_can_be_resolved_by?(user)
    resolvable_discussions.all? { |discussion| discussion.can_resolve?(user) }
  end

497 498 499 500 501
  def find_diff_discussion(discussion_id)
    notes = self.notes.diff_notes.where(discussion_id: discussion_id).fresh.to_a
    return if notes.empty?

    Discussion.new(notes)
502 503
  end

504
  def discussions_resolvable?
505
    diff_discussions.any?(&:resolvable?)
506 507
  end

508
  def discussions_resolved?
509
    discussions_resolvable? && diff_discussions.none?(&:to_be_resolved?)
510 511
  end

512 513 514 515
  def discussions_to_be_resolved?
    discussions_resolvable? && !discussions_resolved?
  end

516 517 518
  def mergeable_discussions_state?
    return true unless project.only_allow_merge_if_all_discussions_are_resolved?

519
    !discussions_to_be_resolved?
520 521
  end

Kirill Zaitsev committed
522 523
  def hook_attrs
    attrs = {
524
      source: source_project.try(:hook_attrs),
Kirill Zaitsev committed
525
      target: target_project.hook_attrs,
526
      last_commit: nil,
527 528 529 530
      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 committed
531 532
    }

533
    if diff_head_commit
534
      attrs[:last_commit] = diff_head_commit.hook_attrs
Kirill Zaitsev committed
535 536 537 538 539
    end

    attributes.merge!(attrs)
  end

540 541 542 543
  def for_fork?
    target_project != source_project
  end

544 545 546 547
  # 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.
548
  # This optimization does not apply to issues from external sources.
549
  def cache_merge_request_closes_issues!(current_user)
550 551
    return if project.has_external_issue_tracker?

552
    transaction do
553
      self.merge_requests_closing_issues.delete_all
554

555
      closes_issues(current_user).each do |issue|
556
        self.merge_requests_closing_issues.create!(issue: issue)
557 558 559 560
      end
    end
  end

561
  # Return the set of issues that will be closed if this merge request is accepted.
562
  def closes_issues(current_user = self.author)
563
    if target_branch == project.default_branch
564
      messages = [title, description]
565
      messages.concat(commits.map(&:safe_message)) if merge_request_diff
566 567 568

      Gitlab::ClosingIssueExtractor.new(project, current_user).
        closed_by_message(messages.join("\n"))
569 570 571 572 573
    else
      []
    end
  end

574
  def issues_mentioned_but_not_closing(current_user)
575
    return [] unless target_branch == project.default_branch
576

577
    ext = Gitlab::ReferenceExtractor.new(project, current_user)
578
    ext.analyze("#{title}\n#{description}")
579

580
    ext.issues - closes_issues(current_user)
581 582
  end

583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
  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

599 600
  def source_project_namespace
    if source_project && source_project.namespace
601
      source_project.namespace.full_path
602 603 604 605 606
    else
      "(removed)"
    end
  end

607 608
  def target_project_namespace
    if target_project && target_project.namespace
609
      target_project.namespace.full_path
610 611 612 613 614
    else
      "(removed)"
    end
  end

615 616 617 618 619 620 621 622 623 624 625 626
  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

627
  def merge_commit_message(include_description: false)
628 629 630 631
    closes_issues_references = closes_issues.map do |issue|
      issue.to_reference(target_project)
    end

632 633 634 635
    message = [
      "Merge branch '#{source_branch}' into '#{target_branch}'",
      title
    ]
636

637
    if !include_description && closes_issues_references.present?
638
      message << "Closes #{closes_issues_references.to_sentence}"
639 640
    end

641
    message << "#{description}" if include_description && description.present?
642 643
    message << "See merge request #{to_reference}"

644
    message.join("\n\n")
645
  end
646

647 648
  def reset_merge_when_pipeline_succeeds
    return unless merge_when_pipeline_succeeds?
649

650
    self.merge_when_pipeline_succeeds = false
651
    self.merge_user = nil
652 653 654 655
    if merge_params
      merge_params.delete('should_remove_source_branch')
      merge_params.delete('commit_message')
    end
656 657 658 659

    self.save
  end

660
  # Return array of possible target branches
Steven Burgart committed
661
  # depends on target project of MR
662 663 664 665 666 667 668 669 670
  def target_branches
    if target_project.nil?
      []
    else
      target_project.repository.branch_names
    end
  end

  # Return array of possible source branches
Steven Burgart committed
671
  # depends on source project of MR
672 673 674 675 676 677 678
  def source_branches
    if source_project.nil?
      []
    else
      source_project.repository.branch_names
    end
  end
679 680

  def locked_long_ago?
Ben Bodenmiller committed
681 682 683
    return false unless locked?

    locked_at.nil? || locked_at < (Time.now - 1.day)
684
  end
685 686

  def has_ci?
687 688 689 690
    has_ci_integration = source_project.try(:ci_service)
    uses_gitlab_ci = all_pipelines.any?

    (has_ci_integration || uses_gitlab_ci) && commits.any?
691 692 693 694 695
  end

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

697
  def broken?
698
    has_no_commits? || branch_missing? || cannot_be_merged?
699 700
  end

701
  def can_be_merged_by?(user)
702 703 704 705 706 707 708
    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)
709 710
  end

711
  def mergeable_ci_state?
712
    return true unless project.only_allow_merge_if_pipeline_succeeds?
713

714
    !head_pipeline || head_pipeline.success? || head_pipeline.skipped?
715 716
  end

Douwe Maan committed
717
  def environments_for(current_user)
718
    return [] unless diff_head_commit
719

Douwe Maan committed
720 721 722
    @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
723

Douwe Maan committed
724 725 726 727
      if source_project
        envs.concat EnvironmentsFinder.new(source_project, current_user,
          ref: source_branch, commit: diff_head_commit).execute
      end
728

Douwe Maan committed
729
      h[current_user] = envs.uniq
730
    end
Douwe Maan committed
731 732

    @environments[current_user]
733 734
  end

735 736 737 738 739 740 741 742 743
  def state_human_name
    if merged?
      "Merged"
    elsif closed?
      "Closed"
    else
      "Open"
    end
  end
744

745 746 747 748 749 750 751 752 753 754
  def state_icon_name
    if merged?
      "check"
    elsif closed?
      "times"
    else
      "circle-o"
    end
  end

755 756 757 758
  def fetch_ref
    target_project.repository.fetch_ref(
      source_project.repository.path_to_repo,
      "refs/heads/#{source_branch}",
759
      ref_path
760 761 762
    )
  end

763 764 765 766
  def ref_path
    "refs/merge-requests/#{iid}/head"
  end

767 768
  def ref_fetched?
    project.repository.ref_exists?(ref_path)
769 770 771
  end

  def ensure_ref_fetched
772
    fetch_ref unless ref_fetched?
773 774
  end

775 776 777 778 779 780 781 782
  def in_locked_state
    begin
      lock_mr
      yield
    ensure
      unlock_mr if locked?
    end
  end
783

784 785 786
  def diverged_commits_count
    cache = Rails.cache.read(:"merge_request_#{id}_diverged_commits")

787
    if cache.blank? || cache[:source_sha] != source_branch_sha || cache[:target_sha] != target_branch_sha
788
      cache = {
789 790
        source_sha: source_branch_sha,
        target_sha: target_branch_sha,
791 792 793 794 795 796 797 798 799
        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
800
    return 0 unless source_branch_sha && target_branch_sha
801

802
    Gitlab::Git::Commit.between(target_project.repository.raw_repository, source_branch_sha, target_branch_sha).size
803
  end
804
  private :compute_diverged_commits_count
805 806 807 808 809

  def diverged_from_target_branch?
    diverged_commits_count > 0
  end

810
  def head_pipeline
811
    return unless diff_head_sha && source_project
812

813
    @head_pipeline ||= source_project.pipeline_for(source_branch, diff_head_sha)
814
  end
815

816
  def all_pipelines
817
    return Ci::Pipeline.none unless source_project
818

819
    @all_pipelines ||= source_project.pipelines
820 821
      .where(sha: all_commits_sha, ref: source_branch)
      .order(id: :desc)
822
  end
823

824
  # Note that this could also return SHA from now dangling commits
825
  #
826
  def all_commits_sha
827 828
    if persisted?
      merge_request_diffs.flat_map(&:commits_sha).uniq
829 830
    elsif compare_commits
      compare_commits.to_a.reverse.map(&:id)
831
    else
832
      [diff_head_sha]
833
    end
834 835
  end

836 837 838 839
  def merge_commit
    @merge_commit ||= project.commit(merge_commit_sha) if merge_commit_sha
  end

840
  def can_be_reverted?(current_user)
841
    merge_commit && !merge_commit.has_been_reverted?(current_user, self)
842
  end
843 844 845 846

  def can_be_cherry_picked?
    merge_commit
  end
847

848
  def has_complete_diff_refs?
849
    diff_sha_refs && diff_sha_refs.complete?
850 851
  end

852
  def update_diff_notes_positions(old_diff_refs:, new_diff_refs:)
853
    return unless has_complete_diff_refs?
854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
    return if new_diff_refs == old_diff_refs

    active_diff_notes = self.notes.diff_notes.select do |note|
      note.new_diff_note? && note.active?(old_diff_refs)
    end

    return if active_diff_notes.empty?

    paths = active_diff_notes.flat_map { |n| n.diff_file.paths }.uniq

    service = Notes::DiffPositionUpdateService.new(
      self.project,
      nil,
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs,
      paths: paths
    )

872 873 874 875 876
    transaction do
      active_diff_notes.each do |note|
        service.execute(note)
        Gitlab::Timeless.timeless(note, &:save)
      end
877 878 879
    end
  end

880 881 882
  def keep_around_commit
    project.repository.keep_around(self.merge_commit_sha)
  end
883 884 885 886 887

  def conflicts
    @conflicts ||= Gitlab::Conflict::FileCollection.new(self)
  end

888 889 890 891 892
  def conflicts_can_be_resolved_by?(user)
    access = ::Gitlab::UserAccess.new(user, project: source_project)
    access.can_push_to_branch?(source_branch)
  end

893 894 895 896 897
  def conflicts_can_be_resolved_in_ui?
    return @conflicts_can_be_resolved_in_ui if defined?(@conflicts_can_be_resolved_in_ui)

    return @conflicts_can_be_resolved_in_ui = false unless cannot_be_merged?
    return @conflicts_can_be_resolved_in_ui = false unless has_complete_diff_refs?
898 899

    begin
900 901 902 903 904
      # Try to parse each conflict. If the MR's mergeable status hasn't been updated,
      # ensure that we don't say there are conflicts to resolve when there are no conflict
      # files.
      conflicts.files.each(&:lines)
      @conflicts_can_be_resolved_in_ui = conflicts.files.length > 0
905
    rescue Rugged::OdbError, Gitlab::Conflict::Parser::UnresolvableError, Gitlab::Conflict::FileCollection::ConflictSideMissing
906
      @conflicts_can_be_resolved_in_ui = false
907 908
    end
  end
909 910

  def has_commits?
911
    merge_request_diff && commits_count > 0
912 913 914 915 916
  end

  def has_no_commits?
    !has_commits?
  end
917 918 919 920 921 922 923 924 925 926 927 928

  def mergeable_with_slash_command?(current_user, autocomplete_precheck: false, last_diff_sha: nil)
    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
929
end