BigW Consortium Gitlab

merge_request.rb 23.9 KB
Newer Older
1
class MergeRequest < ActiveRecord::Base
2
  include InternalId
3
  include Issuable
4
  include Noteable
5
  include Referable
6
  include Sortable
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
  belongs_to :head_pipeline, foreign_key: "head_pipeline_id", class_name: "Ci::Pipeline"

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

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

22 23
  belongs_to :assignee, class_name: "User"

24
  serialize :merge_params, Hash # rubocop:disable Cop/ActiverecordSerialize
25

26 27
  after_create :ensure_merge_request_diff, unless: :importing?
  after_update :reload_diff_if_branch_changed
28

29 30
  delegate :commits, :real_size, :commits_sha, :commits_count,
    to: :merge_request_diff, prefix: nil
31

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

36 37
  # Temporary fields to store compare vars
  # when creating new merge request
38
  attr_accessor :can_be_created, :compare_commits, :diff_options, :compare
39

Andrew8xx8 committed
40
  state_machine :state, initial: :opened do
41 42 43 44
    event :close do
      transition [:reopened, :opened] => :closed
    end

45
    event :mark_as_merged do
46
      transition [:reopened, :opened, :locked] => :merged
47 48 49
    end

    event :reopen do
Andrew8xx8 committed
50
      transition closed: :reopened
51 52
    end

53
    event :lock_mr do
54 55 56
      transition [:reopened, :opened] => :locked
    end

57
    event :unlock_mr do
58 59 60
      transition locked: :reopened
    end

61 62 63 64 65
    after_transition any => :locked do |merge_request, transition|
      merge_request.locked_at = Time.now
      merge_request.save
    end

66
    after_transition locked: (any - :locked) do |merge_request, transition|
67 68 69 70
      merge_request.locked_at = nil
      merge_request.save
    end

71 72 73 74
    state :opened
    state :reopened
    state :closed
    state :merged
75
    state :locked
76 77
  end

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

    event :mark_as_unmergeable do
88
      transition [:unchecked, :can_be_merged] => :cannot_be_merged
89 90
    end

91
    state :unchecked
92 93
    state :can_be_merged
    state :cannot_be_merged
94 95

    around_transition do |merge_request, transition, block|
96
      Gitlab::Timeless.timeless(merge_request, &block)
97
    end
98
  end
99

100
  validates :source_project, presence: true, unless: [:allow_broken, :importing?, :closed_without_fork?]
Andrey Kumanyaev committed
101
  validates :source_branch, presence: true
102
  validates :target_project, presence: true
Andrey Kumanyaev committed
103
  validates :target_branch, presence: true
104
  validates :merge_user, presence: true, if: :merge_when_pipeline_succeeds?, unless: :importing?
105 106
  validate :validate_branches, unless: [:allow_broken, :importing?, :closed_without_fork?]
  validate :validate_fork, unless: :closed_without_fork?
107
  validate :validate_target_project, on: :create
108

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

119 120
  scope :join_project, -> { joins(:target_project) }
  scope :references_project, -> { references(:target_project) }
121 122 123 124 125
  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
126

127 128
  after_save :keep_around_commit

129 130 131 132
  def self.reference_prefix
    '!'
  end

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

143
  def self.link_reference_pattern
144
    @link_reference_pattern ||= super("merge_requests", /(?<merge_request>\d+)/)
145 146
  end

147 148 149 150
  def self.reference_valid?(reference)
    reference.to_i > 0 && reference.to_i <= Gitlab::Database::MAX_INT_VALUE
  end

151 152 153 154
  def self.project_foreign_key
    'target_project_id'
  end

155 156 157 158 159 160 161 162 163 164 165
  # 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)
166 167 168 169
    # 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)
170 171 172 173 174
    union  = Gitlab::SQL::Union.new([source, target])

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

175 176 177 178 179 180 181 182 183 184 185 186 187 188
  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

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

  # This method is needed for compatibility with issues to not mess view and other code
  def assignees
    Array(assignee)
  end

  def assignee_or_author?(user)
    author_id == user.id || assignee_id == user.id
  end

206
  # `from` argument can be a Namespace or Project.
207
  def to_reference(from = nil, full: false)
208 209
    reference = "#{self.class.reference_prefix}#{iid}"

210
    "#{project.to_reference(from, full: full)}#{reference}"
211 212
  end

213 214
  def first_commit
    merge_request_diff ? merge_request_diff.first_commit : compare_commits.first
215
  end
216

217
  def raw_diffs(*args)
218
    merge_request_diff ? merge_request_diff.raw_diffs(*args) : compare.raw_diffs(*args)
219 220
  end

221
  def diffs(diff_options = {})
222
    if compare
223
      # When saving MR diffs, `expanded` is implicitly added (because we need
224 225
      # to save the entire contents to the DB), so add that here for
      # consistency.
226
      compare.diffs(diff_options.merge(expanded: true))
227
    else
228
      merge_request_diff.diffs(diff_options)
229
    end
230 231
  end

232
  def diff_size
233 234 235
    # Calling `merge_request_diff.diffs.real_size` will also perform
    # highlighting, which we don't need here.
    return real_size if merge_request_diff
236

237
    diffs.real_size
238 239
  end

240
  def diff_base_commit
241
    if persisted?
242
      merge_request_diff.base_commit
243 244
    else
      branch_merge_base_commit
245 246 247 248 249 250 251 252
    end
  end

  def diff_start_commit
    if persisted?
      merge_request_diff.start_commit
    else
      target_branch_head
253 254 255
    end
  end

256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
  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
283 284
    return unless source_project

285
    source_branch_ref = @source_branch_sha || source_branch
286
    source_project.repository.commit(source_branch_ref) if source_branch_ref
287 288 289 290
  end

  def target_branch_head
    target_branch_ref = @target_branch_sha || target_branch
291
    target_project.repository.commit(target_branch_ref) if target_branch_ref
292 293
  end

294 295 296 297 298 299 300 301 302
  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

303
  def target_branch_sha
304
    @target_branch_sha || target_branch_head.try(:sha)
305 306 307
  end

  def source_branch_sha
308
    @source_branch_sha || source_branch_head.try(:sha)
309 310
  end

311
  def diff_refs
312
    if persisted?
313
      merge_request_diff.diff_refs
314
    else
315 316 317 318 319
      Gitlab::Diff::DiffRefs.new(
        base_sha:  diff_base_sha,
        start_sha: diff_start_sha,
        head_sha:  diff_head_sha
      )
320
    end
321 322
  end

323 324 325 326
  def branch_merge_base_sha
    branch_merge_base_commit.try(:sha)
  end

327
  def validate_branches
328
    if target_project == source_project && target_branch == source_branch
329
      errors.add :branch_conflict, "You can not use same project/branch for source and target"
330
    end
331

332
    if opened? || reopened?
333
      similar_mrs = self.target_project.merge_requests.where(source_branch: source_branch, target_branch: target_branch, source_project_id: source_project.try(:id)).opened
334 335
      similar_mrs = similar_mrs.where('id not in (?)', self.id) if self.id
      if similar_mrs.any?
336
        errors.add :validate_branches,
337
                   "Cannot Create: This merge request already exists: #{similar_mrs.pluck(:title)}"
338
      end
339
    end
340 341
  end

342 343 344 345 346 347
  def validate_target_project
    return true if target_project.merge_requests_enabled?

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

348
  def validate_fork
349
    return true unless target_project && source_project
350
    return true if target_project == source_project
351
    return true unless source_project_missing?
352

353
    errors.add :validate_fork,
354
               'Source project is not a fork of the target project'
355 356 357
  end

  def closed_without_fork?
358
    closed? && source_project_missing?
359 360
  end

361
  def source_project_missing?
362 363 364 365
    return false unless for_fork?
    return true unless source_project

    !source_project.forked_from?(target_project)
366 367
  end

368
  def reopenable?
369
    closed? && !source_project_missing? && source_branch_exists?
Katarzyna Kobierska committed
370 371
  end

372 373
  def ensure_merge_request_diff
    merge_request_diff || create_merge_request_diff
374 375
  end

376 377 378 379 380 381 382 383 384
  def create_merge_request_diff
    merge_request_diffs.create
    reload_merge_request_diff
  end

  def reload_merge_request_diff
    merge_request_diff(true)
  end

385 386 387 388 389 390 391 392 393
  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
394 395
    end

396
    @merge_request_diffs_by_diff_refs_or_sha[diff_refs_or_sha]
397 398
  end

399 400 401 402 403 404 405 406 407 408 409
  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

410
  def reload_diff_if_branch_changed
411
    if source_branch_changed? || target_branch_changed?
412
      reload_diff
413 414 415
    end
  end

416
  def reload_diff(current_user = nil)
417 418
    return unless open?

419
    old_diff_refs = self.diff_refs
420
    create_merge_request_diff
421
    MergeRequests::MergeRequestDiffCacheService.new.execute(self)
422 423
    new_diff_refs = self.diff_refs

424
    update_diff_discussion_positions(
425
      old_diff_refs: old_diff_refs,
426 427
      new_diff_refs: new_diff_refs,
      current_user: current_user
428
    )
429 430
  end

431
  def check_if_can_be_merged
432 433
    return unless unchecked?

434
    can_be_merged =
435
      !broken? && project.repository.can_be_merged?(diff_head_sha, target_branch)
436 437

    if can_be_merged
438 439 440 441
      mark_as_mergeable
    else
      mark_as_unmergeable
    end
442 443
  end

444
  def merge_event
445
    @merge_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::MERGED).last
446 447
  end

448
  def closed_event
449
    @closed_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::CLOSED).last
450 451
  end

452
  def work_in_progress?
453
    self.class.work_in_progress?(title)
454 455 456
  end

  def wipless_title
457 458 459 460 461
    self.class.wipless_title(self.title)
  end

  def wip_title
    self.class.wip_title(self.title)
462 463
  end

464 465
  def mergeable?(skip_ci_check: false)
    return false unless mergeable_state?(skip_ci_check: skip_ci_check)
466 467 468 469

    check_if_can_be_merged

    can_be_merged?
470 471
  end

472
  def mergeable_state?(skip_ci_check: false)
473 474 475
    return false unless open?
    return false if work_in_progress?
    return false if broken?
476
    return false unless skip_ci_check || mergeable_ci_state?
477
    return false unless mergeable_discussions_state?
478 479

    true
480 481
  end

482
  def can_cancel_merge_when_pipeline_succeeds?(current_user)
483
    can_be_merged_by?(current_user) || self.author == current_user
484 485
  end

486
  def can_remove_source_branch?(current_user)
487
    !ProtectedBranch.protected?(source_project, source_branch) &&
488
      !source_project.root_ref?(source_branch) &&
489
      Ability.allowed?(current_user, :push_code, source_project) &&
490
      diff_head_commit == source_branch_head
491 492
  end

493
  def should_remove_source_branch?
494
    Gitlab::Utils.to_boolean(merge_params['should_remove_source_branch'])
495 496 497
  end

  def force_remove_source_branch?
498
    Gitlab::Utils.to_boolean(merge_params['force_remove_source_branch'])
499 500 501 502 503 504
  end

  def remove_source_branch?
    should_remove_source_branch? || force_remove_source_branch?
  end

505
  def related_notes
506 507 508 509
    # Fetch comments only from last 100 commits
    commits_for_notes_limit = 100
    commit_ids = commits.last(commits_for_notes_limit).map(&:id)

510 511
    Note.where(
      "(project_id = :target_project_id AND noteable_type = 'MergeRequest' AND noteable_id = :mr_id) OR" +
512
      "((project_id = :source_project_id OR project_id = :target_project_id) AND noteable_type = 'Commit' AND commit_id IN (:commit_ids))",
513
      mr_id: id,
514 515 516
      commit_ids: commit_ids,
      target_project_id: target_project_id,
      source_project_id: source_project_id
517
    )
518
  end
519

520
  alias_method :discussion_notes, :related_notes
521

522 523 524
  def mergeable_discussions_state?
    return true unless project.only_allow_merge_if_all_discussions_are_resolved?

525
    !discussions_to_be_resolved?
526 527
  end

Kirill Zaitsev committed
528 529
  def hook_attrs
    attrs = {
530
      source: source_project.try(:hook_attrs),
Kirill Zaitsev committed
531
      target: target_project.hook_attrs,
532
      last_commit: nil,
533 534 535 536
      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
537 538
    }

539
    if diff_head_commit
540
      attrs[:last_commit] = diff_head_commit.hook_attrs
Kirill Zaitsev committed
541 542 543 544 545
    end

    attributes.merge!(attrs)
  end

546 547 548 549
  def for_fork?
    target_project != source_project
  end

550 551 552 553
  def project
    target_project
  end

554 555 556 557
  # 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.
558
  # This optimization does not apply to issues from external sources.
559
  def cache_merge_request_closes_issues!(current_user)
560 561
    return if project.has_external_issue_tracker?

562
    transaction do
563
      self.merge_requests_closing_issues.delete_all
564

565
      closes_issues(current_user).each do |issue|
566
        self.merge_requests_closing_issues.create!(issue: issue)
567 568 569 570
      end
    end
  end

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

      Gitlab::ClosingIssueExtractor.new(project, current_user).
        closed_by_message(messages.join("\n"))
579 580 581 582 583
    else
      []
    end
  end

584
  def issues_mentioned_but_not_closing(current_user)
585
    return [] unless target_branch == project.default_branch
586

587
    ext = Gitlab::ReferenceExtractor.new(project, current_user)
588
    ext.analyze("#{title}\n#{description}")
589

590
    ext.issues - closes_issues(current_user)
591 592
  end

593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
  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

609 610
  def source_project_namespace
    if source_project && source_project.namespace
611
      source_project.namespace.full_path
612 613 614 615 616
    else
      "(removed)"
    end
  end

617 618
  def target_project_namespace
    if target_project && target_project.namespace
619
      target_project.namespace.full_path
620 621 622 623 624
    else
      "(removed)"
    end
  end

625 626 627 628 629 630 631 632 633 634 635 636
  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

637
  def merge_commit_message(include_description: false)
638 639 640 641
    closes_issues_references = closes_issues.map do |issue|
      issue.to_reference(target_project)
    end

642 643 644 645
    message = [
      "Merge branch '#{source_branch}' into '#{target_branch}'",
      title
    ]
646

647
    if !include_description && closes_issues_references.present?
648
      message << "Closes #{closes_issues_references.to_sentence}"
649 650
    end

651
    message << "#{description}" if include_description && description.present?
652 653
    message << "See merge request #{to_reference}"

654
    message.join("\n\n")
655
  end
656

657 658
  def reset_merge_when_pipeline_succeeds
    return unless merge_when_pipeline_succeeds?
659

660
    self.merge_when_pipeline_succeeds = false
661
    self.merge_user = nil
662 663 664 665
    if merge_params
      merge_params.delete('should_remove_source_branch')
      merge_params.delete('commit_message')
    end
666 667 668 669

    self.save
  end

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

  # Return array of possible source branches
Steven Burgart committed
681
  # depends on source project of MR
682 683 684 685 686 687 688
  def source_branches
    if source_project.nil?
      []
    else
      source_project.repository.branch_names
    end
  end
689 690

  def locked_long_ago?
Ben Bodenmiller committed
691 692 693
    return false unless locked?

    locked_at.nil? || locked_at < (Time.now - 1.day)
694
  end
695 696

  def has_ci?
697 698 699 700
    has_ci_integration = source_project.try(:ci_service)
    uses_gitlab_ci = all_pipelines.any?

    (has_ci_integration || uses_gitlab_ci) && commits.any?
701 702 703 704 705
  end

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

707
  def broken?
708
    has_no_commits? || branch_missing? || cannot_be_merged?
709 710
  end

711
  def can_be_merged_by?(user)
712 713 714 715 716 717 718
    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)
719 720
  end

721
  def mergeable_ci_state?
722
    return true unless project.only_allow_merge_if_pipeline_succeeds?
723

724
    !head_pipeline || head_pipeline.success? || head_pipeline.skipped?
725 726
  end

Douwe Maan committed
727
  def environments_for(current_user)
728
    return [] unless diff_head_commit
729

Douwe Maan committed
730 731 732
    @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
733

Douwe Maan committed
734 735 736 737
      if source_project
        envs.concat EnvironmentsFinder.new(source_project, current_user,
          ref: source_branch, commit: diff_head_commit).execute
      end
738

Douwe Maan committed
739
      h[current_user] = envs.uniq
740
    end
Douwe Maan committed
741 742

    @environments[current_user]
743 744
  end

745 746 747 748 749 750 751 752 753
  def state_human_name
    if merged?
      "Merged"
    elsif closed?
      "Closed"
    else
      "Open"
    end
  end
754

755 756 757 758 759 760 761 762 763 764
  def state_icon_name
    if merged?
      "check"
    elsif closed?
      "times"
    else
      "circle-o"
    end
  end

765 766 767 768
  def fetch_ref
    target_project.repository.fetch_ref(
      source_project.repository.path_to_repo,
      "refs/heads/#{source_branch}",
769
      ref_path
770 771 772
    )
  end

773 774 775 776
  def ref_path
    "refs/merge-requests/#{iid}/head"
  end

777 778
  def ref_fetched?
    project.repository.ref_exists?(ref_path)
779 780 781
  end

  def ensure_ref_fetched
782
    fetch_ref unless ref_fetched?
783 784
  end

785 786 787 788 789 790 791 792
  def in_locked_state
    begin
      lock_mr
      yield
    ensure
      unlock_mr if locked?
    end
  end
793

794 795 796
  def diverged_commits_count
    cache = Rails.cache.read(:"merge_request_#{id}_diverged_commits")

797
    if cache.blank? || cache[:source_sha] != source_branch_sha || cache[:target_sha] != target_branch_sha
798
      cache = {
799 800
        source_sha: source_branch_sha,
        target_sha: target_branch_sha,
801 802 803 804 805 806 807 808 809
        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
810
    return 0 unless source_branch_sha && target_branch_sha
811

812
    Gitlab::Git::Commit.between(target_project.repository.raw_repository, source_branch_sha, target_branch_sha).size
813
  end
814
  private :compute_diverged_commits_count
815 816 817 818 819

  def diverged_from_target_branch?
    diverged_commits_count > 0
  end

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

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

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

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

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

  def can_be_cherry_picked?
849
    merge_commit.present?
850
  end
851

852
  def has_complete_diff_refs?
853
    diff_refs && diff_refs.complete?
854 855
  end

856
  def update_diff_discussion_positions(old_diff_refs:, new_diff_refs:, current_user: nil)
857
    return unless has_complete_diff_refs?
858 859
    return if new_diff_refs == old_diff_refs

860 861
    active_diff_discussions = self.notes.new_diff_notes.discussions.select do |discussion|
      discussion.active?(old_diff_refs)
862
    end
863
    return if active_diff_discussions.empty?
864

865
    paths = active_diff_discussions.flat_map { |n| n.diff_file.paths }.uniq
866

867
    service = Discussions::UpdateDiffPositionService.new(
868
      self.project,
869
      current_user,
870 871 872 873 874
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs,
      paths: paths
    )

875 876
    active_diff_discussions.each do |discussion|
      service.execute(discussion)
877 878 879
    end
  end

880 881 882
  def keep_around_commit
    project.repository.keep_around(self.merge_commit_sha)
  end
883

884
  def has_commits?
885
    merge_request_diff && commits_count > 0
886 887 888 889 890
  end

  def has_no_commits?
    !has_commits?
  end
891 892 893 894 895 896 897 898 899 900 901 902

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