BigW Consortium Gitlab

merge_request.rb 25 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 :merge_user, class_name: "User"
11

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

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

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

20 21
  serialize :merge_params, Hash

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

118 119
  after_save :keep_around_commit

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

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

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

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

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

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

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

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

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

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

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

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

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

203
  def diff_size
204 205 206 207 208
    # 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 || {})
209 210

    raw_diffs(opts).size
211 212
  end

213
  def diff_base_commit
214
    if persisted?
215
      merge_request_diff.base_commit
216 217
    else
      branch_merge_base_commit
218 219 220 221 222 223 224 225 226
    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.
227 228 229
  # 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.
230
  def likely_diff_base_commit
231
    first_commit.try(:parent) || first_commit
232 233 234 235 236 237 238
  end

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

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 269
  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
270
    source_project.repository.commit(source_branch_ref) if source_branch_ref
271 272 273 274
  end

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

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

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

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

295 296 297 298 299 300 301 302
  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
    )
303 304
  end

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

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

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

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

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

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

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

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

    !source_project.forked_from?(target_project)
351 352
  end

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

357 358
  def ensure_merge_request_diff
    merge_request_diff || create_merge_request_diff
359 360
  end

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

  def reload_merge_request_diff
    merge_request_diff(true)
  end

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

376
  def reload_diff
377 378
    return unless open?

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

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

390
  def check_if_can_be_merged
391 392
    return unless unchecked?

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

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

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

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

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

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

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

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

    check_if_can_be_merged

    can_be_merged?
429 430
  end

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

    true
439 440
  end

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

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

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

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

  def remove_source_branch?
    should_remove_source_branch? || force_remove_source_branch?
  end

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

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

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

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

490 491 492 493 494 495 496 497
  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

498 499 500 501 502
  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)
503 504
  end

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

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

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

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

520
    !discussions_to_be_resolved?
521 522
  end

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

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

    attributes.merge!(attrs)
  end

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

545 546 547 548
  def project
    target_project
  end

549 550 551 552
  # 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.
553
  # This optimization does not apply to issues from external sources.
554
  def cache_merge_request_closes_issues!(current_user)
555 556
    return if project.has_external_issue_tracker?

557
    transaction do
558
      self.merge_requests_closing_issues.delete_all
559

560
      closes_issues(current_user).each do |issue|
561
        self.merge_requests_closing_issues.create!(issue: issue)
562 563 564 565
      end
    end
  end

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

      Gitlab::ClosingIssueExtractor.new(project, current_user).
        closed_by_message(messages.join("\n"))
574 575 576 577 578
    else
      []
    end
  end

579
  def issues_mentioned_but_not_closing(current_user)
580
    return [] unless target_branch == project.default_branch
581

582
    ext = Gitlab::ReferenceExtractor.new(project, current_user)
583
    ext.analyze("#{title}\n#{description}")
584

585
    ext.issues - closes_issues(current_user)
586 587
  end

588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
  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

604 605
  def source_project_namespace
    if source_project && source_project.namespace
606
      source_project.namespace.full_path
607 608 609 610 611
    else
      "(removed)"
    end
  end

612 613
  def target_project_namespace
    if target_project && target_project.namespace
614
      target_project.namespace.full_path
615 616 617 618 619
    else
      "(removed)"
    end
  end

620 621 622 623 624 625 626 627 628 629 630 631
  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

632
  def merge_commit_message(include_description: false)
633 634 635 636
    closes_issues_references = closes_issues.map do |issue|
      issue.to_reference(target_project)
    end

637 638 639 640
    message = [
      "Merge branch '#{source_branch}' into '#{target_branch}'",
      title
    ]
641

642
    if !include_description && closes_issues_references.present?
643
      message << "Closes #{closes_issues_references.to_sentence}"
644 645
    end

646
    message << "#{description}" if include_description && description.present?
647 648
    message << "See merge request #{to_reference}"

649
    message.join("\n\n")
650
  end
651

652 653
  def reset_merge_when_pipeline_succeeds
    return unless merge_when_pipeline_succeeds?
654

655
    self.merge_when_pipeline_succeeds = false
656
    self.merge_user = nil
657 658 659 660
    if merge_params
      merge_params.delete('should_remove_source_branch')
      merge_params.delete('commit_message')
    end
661 662 663 664

    self.save
  end

665
  # Return array of possible target branches
Steven Burgart committed
666
  # depends on target project of MR
667 668 669 670 671 672 673 674 675
  def target_branches
    if target_project.nil?
      []
    else
      target_project.repository.branch_names
    end
  end

  # Return array of possible source branches
Steven Burgart committed
676
  # depends on source project of MR
677 678 679 680 681 682 683
  def source_branches
    if source_project.nil?
      []
    else
      source_project.repository.branch_names
    end
  end
684 685

  def locked_long_ago?
Ben Bodenmiller committed
686 687 688
    return false unless locked?

    locked_at.nil? || locked_at < (Time.now - 1.day)
689
  end
690 691

  def has_ci?
692 693 694 695
    has_ci_integration = source_project.try(:ci_service)
    uses_gitlab_ci = all_pipelines.any?

    (has_ci_integration || uses_gitlab_ci) && commits.any?
696 697 698 699 700
  end

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

702
  def broken?
703
    has_no_commits? || branch_missing? || cannot_be_merged?
704 705
  end

706
  def can_be_merged_by?(user)
707 708 709 710 711 712 713
    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)
714 715
  end

716
  def mergeable_ci_state?
717
    return true unless project.only_allow_merge_if_pipeline_succeeds?
718

719
    !head_pipeline || head_pipeline.success? || head_pipeline.skipped?
720 721
  end

Douwe Maan committed
722
  def environments_for(current_user)
723
    return [] unless diff_head_commit
724

Douwe Maan committed
725 726 727
    @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
728

Douwe Maan committed
729 730 731 732
      if source_project
        envs.concat EnvironmentsFinder.new(source_project, current_user,
          ref: source_branch, commit: diff_head_commit).execute
      end
733

Douwe Maan committed
734
      h[current_user] = envs.uniq
735
    end
Douwe Maan committed
736 737

    @environments[current_user]
738 739
  end

740 741 742 743 744 745 746 747 748
  def state_human_name
    if merged?
      "Merged"
    elsif closed?
      "Closed"
    else
      "Open"
    end
  end
749

750 751 752 753 754 755 756 757 758 759
  def state_icon_name
    if merged?
      "check"
    elsif closed?
      "times"
    else
      "circle-o"
    end
  end

760 761 762 763
  def fetch_ref
    target_project.repository.fetch_ref(
      source_project.repository.path_to_repo,
      "refs/heads/#{source_branch}",
764
      ref_path
765 766 767
    )
  end

768 769 770 771
  def ref_path
    "refs/merge-requests/#{iid}/head"
  end

772 773
  def ref_fetched?
    project.repository.ref_exists?(ref_path)
774 775 776
  end

  def ensure_ref_fetched
777
    fetch_ref unless ref_fetched?
778 779
  end

780 781 782 783 784 785 786 787
  def in_locked_state
    begin
      lock_mr
      yield
    ensure
      unlock_mr if locked?
    end
  end
788

789 790 791
  def diverged_commits_count
    cache = Rails.cache.read(:"merge_request_#{id}_diverged_commits")

792
    if cache.blank? || cache[:source_sha] != source_branch_sha || cache[:target_sha] != target_branch_sha
793
      cache = {
794 795
        source_sha: source_branch_sha,
        target_sha: target_branch_sha,
796 797 798 799 800 801 802 803 804
        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
805
    return 0 unless source_branch_sha && target_branch_sha
806

807
    Gitlab::Git::Commit.between(target_project.repository.raw_repository, source_branch_sha, target_branch_sha).size
808
  end
809
  private :compute_diverged_commits_count
810 811 812 813 814

  def diverged_from_target_branch?
    diverged_commits_count > 0
  end

815
  def head_pipeline
816
    return unless diff_head_sha && source_project
817

818
    @head_pipeline ||= source_project.pipeline_for(source_branch, diff_head_sha)
819
  end
820

821
  def all_pipelines
822
    return Ci::Pipeline.none unless source_project
823

824
    @all_pipelines ||= source_project.pipelines
825 826
      .where(sha: all_commits_sha, ref: source_branch)
      .order(id: :desc)
827
  end
828

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

841 842 843 844
  def merge_commit
    @merge_commit ||= project.commit(merge_commit_sha) if merge_commit_sha
  end

845
  def can_be_reverted?(current_user)
846
    merge_commit && !merge_commit.has_been_reverted?(current_user, self)
847
  end
848 849 850 851

  def can_be_cherry_picked?
    merge_commit
  end
852

853
  def has_complete_diff_refs?
854
    diff_sha_refs && diff_sha_refs.complete?
855 856
  end

857
  def update_diff_notes_positions(old_diff_refs:, new_diff_refs:)
858
    return unless has_complete_diff_refs?
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
    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
    )

877 878 879 880 881
    transaction do
      active_diff_notes.each do |note|
        service.execute(note)
        Gitlab::Timeless.timeless(note, &:save)
      end
882 883 884
    end
  end

885 886 887
  def keep_around_commit
    project.repository.keep_around(self.merge_commit_sha)
  end
888 889 890 891 892

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

893 894 895 896 897
  def conflicts_can_be_resolved_by?(user)
    access = ::Gitlab::UserAccess.new(user, project: source_project)
    access.can_push_to_branch?(source_branch)
  end

898 899 900 901 902
  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?
903 904

    begin
905 906 907 908 909
      # 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
910
    rescue Rugged::OdbError, Gitlab::Conflict::Parser::UnresolvableError, Gitlab::Conflict::FileCollection::ConflictSideMissing
911
      @conflicts_can_be_resolved_in_ui = false
912 913
    end
  end
914 915

  def has_commits?
916
    merge_request_diff && commits_count > 0
917 918 919 920 921
  end

  def has_no_commits?
    !has_commits?
  end
922 923 924 925 926 927 928 929 930 931 932 933

  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
934
end