BigW Consortium Gitlab

merge_request.rb 24.4 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 25
  serialize :merge_params, Hash

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 224 225 226
      # When saving MR diffs, `no_collapse` is implicitly added (because we need
      # to save the entire contents to the DB), so add that here for
      # consistency.
      compare.diffs(diff_options.merge(no_collapse: 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 253
    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.
254 255 256
  # 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.
257
  def likely_diff_base_commit
258
    first_commit.try(:parent) || first_commit
259 260 261 262 263 264 265
  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 325 326 327 328 329 330 331
  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
    )
332 333
  end

334 335
  # Return diff_refs instance trying to not touch the git repository
  def diff_sha_refs
336
    if merge_request_diff && merge_request_diff.diff_refs_by_sha?
337
      merge_request_diff.diff_refs
338
    else
339
      diff_refs
340
    end
341 342
  end

343 344 345 346
  def branch_merge_base_sha
    branch_merge_base_commit.try(:sha)
  end

347
  def validate_branches
348
    if target_project == source_project && target_branch == source_branch
349
      errors.add :branch_conflict, "You can not use same project/branch for source and target"
350
    end
351

352
    if opened? || reopened?
353
      similar_mrs = self.target_project.merge_requests.where(source_branch: source_branch, target_branch: target_branch, source_project_id: source_project.try(:id)).opened
354 355
      similar_mrs = similar_mrs.where('id not in (?)', self.id) if self.id
      if similar_mrs.any?
356
        errors.add :validate_branches,
357
                   "Cannot Create: This merge request already exists: #{similar_mrs.pluck(:title)}"
358
      end
359
    end
360 361
  end

362 363 364 365 366 367
  def validate_target_project
    return true if target_project.merge_requests_enabled?

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

368
  def validate_fork
369
    return true unless target_project && source_project
370
    return true if target_project == source_project
371
    return true unless source_project_missing?
372

373
    errors.add :validate_fork,
374
               'Source project is not a fork of the target project'
375 376 377
  end

  def closed_without_fork?
378
    closed? && source_project_missing?
379 380
  end

381
  def source_project_missing?
382 383 384 385
    return false unless for_fork?
    return true unless source_project

    !source_project.forked_from?(target_project)
386 387
  end

388
  def reopenable?
389
    closed? && !source_project_missing? && source_branch_exists?
Katarzyna Kobierska committed
390 391
  end

392 393
  def ensure_merge_request_diff
    merge_request_diff || create_merge_request_diff
394 395
  end

396 397 398 399 400 401 402 403 404
  def create_merge_request_diff
    merge_request_diffs.create
    reload_merge_request_diff
  end

  def reload_merge_request_diff
    merge_request_diff(true)
  end

405 406 407 408 409 410 411 412 413
  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
414 415
    end

416
    @merge_request_diffs_by_diff_refs_or_sha[diff_refs_or_sha]
417 418
  end

419
  def reload_diff_if_branch_changed
420
    if source_branch_changed? || target_branch_changed?
421
      reload_diff
422 423 424
    end
  end

425
  def reload_diff
426 427
    return unless open?

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

    update_diff_notes_positions(
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs
    )
437 438
  end

439
  def check_if_can_be_merged
440 441
    return unless unchecked?

442
    can_be_merged =
443
      !broken? && project.repository.can_be_merged?(diff_head_sha, target_branch)
444 445

    if can_be_merged
446 447 448 449
      mark_as_mergeable
    else
      mark_as_unmergeable
    end
450 451
  end

452
  def merge_event
453
    @merge_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: Event::MERGED).last
454 455
  end

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

460
  def work_in_progress?
461
    self.class.work_in_progress?(title)
462 463 464
  end

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

  def wip_title
    self.class.wip_title(self.title)
470 471
  end

472 473
  def mergeable?(skip_ci_check: false)
    return false unless mergeable_state?(skip_ci_check: skip_ci_check)
474 475 476 477

    check_if_can_be_merged

    can_be_merged?
478 479
  end

480
  def mergeable_state?(skip_ci_check: false)
481 482 483
    return false unless open?
    return false if work_in_progress?
    return false if broken?
484
    return false unless skip_ci_check || mergeable_ci_state?
485
    return false unless mergeable_discussions_state?
486 487

    true
488 489
  end

490
  def can_cancel_merge_when_pipeline_succeeds?(current_user)
491
    can_be_merged_by?(current_user) || self.author == current_user
492 493
  end

494
  def can_remove_source_branch?(current_user)
495
    !ProtectedBranch.protected?(source_project, source_branch) &&
496
      !source_project.root_ref?(source_branch) &&
497
      Ability.allowed?(current_user, :push_code, source_project) &&
498
      diff_head_commit == source_branch_head
499 500
  end

501
  def should_remove_source_branch?
502
    Gitlab::Utils.to_boolean(merge_params['should_remove_source_branch'])
503 504 505
  end

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

  def remove_source_branch?
    should_remove_source_branch? || force_remove_source_branch?
  end

513
  def related_notes
514 515 516 517
    # Fetch comments only from last 100 commits
    commits_for_notes_limit = 100
    commit_ids = commits.last(commits_for_notes_limit).map(&:id)

518 519
    Note.where(
      "(project_id = :target_project_id AND noteable_type = 'MergeRequest' AND noteable_id = :mr_id) OR" +
520
      "((project_id = :source_project_id OR project_id = :target_project_id) AND noteable_type = 'Commit' AND commit_id IN (:commit_ids))",
521
      mr_id: id,
522 523 524
      commit_ids: commit_ids,
      target_project_id: target_project_id,
      source_project_id: source_project_id
525
    )
526
  end
527

528
  alias_method :discussion_notes, :related_notes
529

530 531 532
  def mergeable_discussions_state?
    return true unless project.only_allow_merge_if_all_discussions_are_resolved?

533
    !discussions_to_be_resolved?
534 535
  end

Kirill Zaitsev committed
536 537
  def hook_attrs
    attrs = {
538
      source: source_project.try(:hook_attrs),
Kirill Zaitsev committed
539
      target: target_project.hook_attrs,
540
      last_commit: nil,
541 542 543 544
      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
545 546
    }

547
    if diff_head_commit
548
      attrs[:last_commit] = diff_head_commit.hook_attrs
Kirill Zaitsev committed
549 550 551 552 553
    end

    attributes.merge!(attrs)
  end

554 555 556 557
  def for_fork?
    target_project != source_project
  end

558 559 560 561
  def project
    target_project
  end

562 563 564 565
  # 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.
566
  # This optimization does not apply to issues from external sources.
567
  def cache_merge_request_closes_issues!(current_user)
568 569
    return if project.has_external_issue_tracker?

570
    transaction do
571
      self.merge_requests_closing_issues.delete_all
572

573
      closes_issues(current_user).each do |issue|
574
        self.merge_requests_closing_issues.create!(issue: issue)
575 576 577 578
      end
    end
  end

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

      Gitlab::ClosingIssueExtractor.new(project, current_user).
        closed_by_message(messages.join("\n"))
587 588 589 590 591
    else
      []
    end
  end

592
  def issues_mentioned_but_not_closing(current_user)
593
    return [] unless target_branch == project.default_branch
594

595
    ext = Gitlab::ReferenceExtractor.new(project, current_user)
596
    ext.analyze("#{title}\n#{description}")
597

598
    ext.issues - closes_issues(current_user)
599 600
  end

601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
  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

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

625 626
  def target_project_namespace
    if target_project && target_project.namespace
627
      target_project.namespace.full_path
628 629 630 631 632
    else
      "(removed)"
    end
  end

633 634 635 636 637 638 639 640 641 642 643 644
  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

645
  def merge_commit_message(include_description: false)
646 647 648 649
    closes_issues_references = closes_issues.map do |issue|
      issue.to_reference(target_project)
    end

650 651 652 653
    message = [
      "Merge branch '#{source_branch}' into '#{target_branch}'",
      title
    ]
654

655
    if !include_description && closes_issues_references.present?
656
      message << "Closes #{closes_issues_references.to_sentence}"
657 658
    end

659
    message << "#{description}" if include_description && description.present?
660 661
    message << "See merge request #{to_reference}"

662
    message.join("\n\n")
663
  end
664

665 666
  def reset_merge_when_pipeline_succeeds
    return unless merge_when_pipeline_succeeds?
667

668
    self.merge_when_pipeline_succeeds = false
669
    self.merge_user = nil
670 671 672 673
    if merge_params
      merge_params.delete('should_remove_source_branch')
      merge_params.delete('commit_message')
    end
674 675 676 677

    self.save
  end

678
  # Return array of possible target branches
Steven Burgart committed
679
  # depends on target project of MR
680 681 682 683 684 685 686 687 688
  def target_branches
    if target_project.nil?
      []
    else
      target_project.repository.branch_names
    end
  end

  # Return array of possible source branches
Steven Burgart committed
689
  # depends on source project of MR
690 691 692 693 694 695 696
  def source_branches
    if source_project.nil?
      []
    else
      source_project.repository.branch_names
    end
  end
697 698

  def locked_long_ago?
Ben Bodenmiller committed
699 700 701
    return false unless locked?

    locked_at.nil? || locked_at < (Time.now - 1.day)
702
  end
703 704

  def has_ci?
705 706 707 708
    has_ci_integration = source_project.try(:ci_service)
    uses_gitlab_ci = all_pipelines.any?

    (has_ci_integration || uses_gitlab_ci) && commits.any?
709 710 711 712 713
  end

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

715
  def broken?
716
    has_no_commits? || branch_missing? || cannot_be_merged?
717 718
  end

719
  def can_be_merged_by?(user)
720 721 722 723 724 725 726
    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)
727 728
  end

729
  def mergeable_ci_state?
730
    return true unless project.only_allow_merge_if_pipeline_succeeds?
731

732
    !head_pipeline || head_pipeline.success? || head_pipeline.skipped?
733 734
  end

Douwe Maan committed
735
  def environments_for(current_user)
736
    return [] unless diff_head_commit
737

Douwe Maan committed
738 739 740
    @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
741

Douwe Maan committed
742 743 744 745
      if source_project
        envs.concat EnvironmentsFinder.new(source_project, current_user,
          ref: source_branch, commit: diff_head_commit).execute
      end
746

Douwe Maan committed
747
      h[current_user] = envs.uniq
748
    end
Douwe Maan committed
749 750

    @environments[current_user]
751 752
  end

753 754 755 756 757 758 759 760 761
  def state_human_name
    if merged?
      "Merged"
    elsif closed?
      "Closed"
    else
      "Open"
    end
  end
762

763 764 765 766 767 768 769 770 771 772
  def state_icon_name
    if merged?
      "check"
    elsif closed?
      "times"
    else
      "circle-o"
    end
  end

773 774 775 776
  def fetch_ref
    target_project.repository.fetch_ref(
      source_project.repository.path_to_repo,
      "refs/heads/#{source_branch}",
777
      ref_path
778 779 780
    )
  end

781 782 783 784
  def ref_path
    "refs/merge-requests/#{iid}/head"
  end

785 786
  def ref_fetched?
    project.repository.ref_exists?(ref_path)
787 788 789
  end

  def ensure_ref_fetched
790
    fetch_ref unless ref_fetched?
791 792
  end

793 794 795 796 797 798 799 800
  def in_locked_state
    begin
      lock_mr
      yield
    ensure
      unlock_mr if locked?
    end
  end
801

802 803 804
  def diverged_commits_count
    cache = Rails.cache.read(:"merge_request_#{id}_diverged_commits")

805
    if cache.blank? || cache[:source_sha] != source_branch_sha || cache[:target_sha] != target_branch_sha
806
      cache = {
807 808
        source_sha: source_branch_sha,
        target_sha: target_branch_sha,
809 810 811 812 813 814 815 816 817
        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
818
    return 0 unless source_branch_sha && target_branch_sha
819

820
    Gitlab::Git::Commit.between(target_project.repository.raw_repository, source_branch_sha, target_branch_sha).size
821
  end
822
  private :compute_diverged_commits_count
823 824 825 826 827

  def diverged_from_target_branch?
    diverged_commits_count > 0
  end

828
  def all_pipelines
829
    return Ci::Pipeline.none unless source_project
830

831
    @all_pipelines ||= source_project.pipelines
832 833
      .where(sha: all_commits_sha, ref: source_branch)
      .order(id: :desc)
834
  end
835

836
  # Note that this could also return SHA from now dangling commits
837
  #
838
  def all_commits_sha
839 840
    if persisted?
      merge_request_diffs.flat_map(&:commits_sha).uniq
841 842
    elsif compare_commits
      compare_commits.to_a.reverse.map(&:id)
843
    else
844
      [diff_head_sha]
845
    end
846 847
  end

848 849 850 851
  def merge_commit
    @merge_commit ||= project.commit(merge_commit_sha) if merge_commit_sha
  end

852
  def can_be_reverted?(current_user)
853
    merge_commit && !merge_commit.has_been_reverted?(current_user, self)
854
  end
855 856

  def can_be_cherry_picked?
857
    merge_commit.present?
858
  end
859

860
  def has_complete_diff_refs?
861
    diff_sha_refs && diff_sha_refs.complete?
862 863
  end

864
  def update_diff_notes_positions(old_diff_refs:, new_diff_refs:)
865
    return unless has_complete_diff_refs?
866 867
    return if new_diff_refs == old_diff_refs

868 869
    active_diff_notes = self.notes.new_diff_notes.select do |note|
      note.active?(old_diff_refs)
870 871 872 873 874 875 876 877 878 879 880 881 882 883
    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
    )

884 885 886 887 888
    transaction do
      active_diff_notes.each do |note|
        service.execute(note)
        Gitlab::Timeless.timeless(note, &:save)
      end
889 890 891
    end
  end

892 893 894
  def keep_around_commit
    project.repository.keep_around(self.merge_commit_sha)
  end
895

896
  def has_commits?
897
    merge_request_diff && commits_count > 0
898 899 900 901 902
  end

  def has_no_commits?
    !has_commits?
  end
903 904 905 906 907 908 909 910 911 912 913 914

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