Class: MergeRequest

Defined Under Namespace

Classes: CleanupSchedule, Metrics

Constant Summary collapse

SORTING_PREFERENCE_FIELD =
:merge_requests_sort
KNOWN_MERGE_PARAMS =
[
  :auto_merge_strategy,
  :should_remove_source_branch,
  :force_remove_source_branch,
  :commit_message,
  :squash_commit_message,
  :sha
].freeze
RebaseLockTimeout =
Class.new(StandardError)
DRAFT_REGEX =

WIP is deprecated in favor of Draft. Currently both options are supported gitlab.com/gitlab-org/gitlab/-/issues/227426

/\A*#{Regexp.union(Gitlab::Regex.merge_request_wip, Gitlab::Regex.merge_request_draft)}+\s*/i.freeze

Constants included from ReactiveCaching

ReactiveCaching::ExceededReactiveCacheLimit, ReactiveCaching::InvalidateReactiveCache, ReactiveCaching::WORK_TYPE

Constants included from ThrottledTouch

ThrottledTouch::TOUCH_INTERVAL

Constants included from Noteable

Noteable::MAX_NOTES_LIMIT

Constants included from Issuable

Issuable::DESCRIPTION_HTML_LENGTH_MAX, Issuable::DESCRIPTION_LENGTH_MAX, Issuable::STATE_ID_MAP, Issuable::TITLE_HTML_LENGTH_MAX, Issuable::TITLE_LENGTH_MAX

Constants included from Taskable

Taskable::COMPLETED, Taskable::COMPLETE_PATTERN, Taskable::INCOMPLETE, Taskable::INCOMPLETE_PATTERN, Taskable::ITEM_PATTERN

Constants included from CacheMarkdownField

CacheMarkdownField::INVALIDATED_BY

Constants included from Redactable

Redactable::UNSUBSCRIBE_PATTERN

Constants included from Gitlab::SQL::Pattern

Gitlab::SQL::Pattern::MIN_CHARS_FOR_PARTIAL_MATCHING, Gitlab::SQL::Pattern::REGEX_QUOTED_WORD

Instance Attribute Summary collapse

Attributes included from Noteable

#system_note_timestamp

Attributes included from Importable

#imported, #importing

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Gitlab::Utils::Override

extended, extensions, included, method_added, override, prepended, queue_verification, verify!

Methods included from ApprovableBase

#approved_by?, #can_be_approved_by?

Methods included from DeprecatedAssignee

#assignee, #assignee=, #assignee_id, #assignee_id=, #assignee_ids, #assignee_ids=, #assignees, #assignees=

Methods included from Gitlab::Utils::StrongMemoize

#clear_memoization, #strong_memoize, #strong_memoized?

Methods included from ThrottledTouch

#touch

Methods included from TimeTrackable

#human_time_estimate, #human_total_time_spent, #spend_time, #time_estimate=, #total_time_spent

Methods included from Presentable

#present

Methods included from Referable

#referable_inspect, #reference_link_text, #to_reference_base

Methods included from Noteable

#after_note_created, #after_note_destroyed, #base_class_name, #capped_notes_count, #discussion_ids_relation, #discussions, #discussions_can_be_resolved_by?, #discussions_resolvable?, #discussions_resolved?, #discussions_to_be_resolved, #expire_note_etag_cache, #grouped_diff_discussions, #has_any_diff_note_positions?, #human_class_name, #lockable?, #note_etag_key, #resolvable_discussions, #supports_discussions?, #supports_replying_to_individual_notes?, #supports_resolvable_notes?

Methods included from Issuable

#assignee_list, #assignee_or_author?, #assignee_username_list, #can_assign_epic?, #can_move?, #card_attributes, #created_hours_ago, #label_names, #labels_array, #new?, #notes_with_associations, #open?, #overdue?, #resource_parent, #state, #state=, #subscribed_without_subscriptions?, #to_ability_name, #to_hook_data, #today?, #updated_tasks, #user_notes_count

Methods included from AfterCommitQueue

#run_after_commit, #run_after_commit_or_now

Methods included from Editable

#edited?, #last_edited_by

Methods included from Taskable

get_tasks, get_updated_tasks, #task_completion_status, #task_list_items, #task_status, #task_status_short, #tasks, #tasks?

Methods included from Awardable

#awarded_emoji?, #downvotes, #emoji_awardable?, #grouped_awards, #upvotes, #user_authored?, #user_can_award?

Methods included from StripAttribute

#strip_attributes

Methods included from Subscribable

#set_subscription, #subscribe, #subscribed?, #subscribed_without_subscriptions?, #subscribers, #toggle_subscription, #unsubscribe

Methods included from Milestoneable

#milestone_available?, #supports_milestone?

Methods included from Mentionable

#all_references, #create_cross_references!, #create_new_cross_references!, #directly_addressed_users, #extractors, #gfm_reference, #local_reference, #matches_cross_reference_regex?, #mentioned_users, #referenced_group_users, #referenced_groups, #referenced_mentionables, #referenced_project_users, #referenced_projects, #referenced_users, #store_mentions!

Methods included from Participable

#participants

Methods included from CacheMarkdownField

#attribute_invalidated?, #cached_html_for, #cached_html_up_to_date?, #can_cache_field?, #invalidated_markdown_cache?, #latest_cached_markdown_version, #local_version, #parent_user, #refresh_markdown_cache, #refresh_markdown_cache!, #rendered_field_content, #skip_project_check?, #updated_cached_html_for

Methods included from IidRoutes

#to_param

Methods included from AtomicInternalId

group_init, #internal_id_read_scope, #internal_id_scope_attrs, #internal_id_scope_usage, project_init, scope_attrs, scope_usage

Methods inherited from ApplicationRecord

at_most, id_in, id_not_in, iid_in, pluck_primary_key, primary_key_in, safe_ensure_unique, safe_find_or_create_by, safe_find_or_create_by!, underscore, where_exists, with_fast_statement_timeout, without_order

Instance Attribute Details

#allow_brokenObject

When this attribute is true some MR validation is ignored It allows us to close or modify broken merge requests


128
129
130
# File 'app/models/merge_request.rb', line 128

def allow_broken
  @allow_broken
end

#can_be_createdObject

Temporary fields to store compare vars when creating new merge request


132
133
134
# File 'app/models/merge_request.rb', line 132

def can_be_created
  @can_be_created
end

#compareObject

Temporary fields to store compare vars when creating new merge request


132
133
134
# File 'app/models/merge_request.rb', line 132

def compare
  @compare
end

#compare_commitsObject

Temporary fields to store compare vars when creating new merge request


132
133
134
# File 'app/models/merge_request.rb', line 132

def compare_commits
  @compare_commits
end

#diff_optionsObject

Temporary fields to store compare vars when creating new merge request


132
133
134
# File 'app/models/merge_request.rb', line 132

def diff_options
  @diff_options
end

#source_branch_shaObject


788
789
790
# File 'app/models/merge_request.rb', line 788

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

#target_branch_shaObject


784
785
786
# File 'app/models/merge_request.rb', line 784

def target_branch_sha
  @target_branch_sha || target_branch_head.try(:sha)
end

Class Method Details

.available_state_namesObject

Keep states definition to be evaluated before the state_machine block to avoid spec failures. If this gets evaluated after, the `merged` and `locked` states which are overrided can be nil.


138
139
140
# File 'app/models/merge_request.rb', line 138

def self.available_state_names
  super + [:merged, :locked]
end

.in_projects(relation) ⇒ Object

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.


448
449
450
451
452
453
454
455
# File 'app/models/merge_request.rb', line 448

def self.in_projects(relation)
  # unscoping unnecessary conditions that'll be applied
  # when executing `where("merge_requests.id IN (#{union.to_sql})")`
  source = unscoped.where(source_project_id: relation)
  target = unscoped.where(target_project_id: relation)

  from_union([source, target])
end

426
427
428
# File 'app/models/merge_request.rb', line 426

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

.merge_request_ref?(ref) ⇒ Boolean

Returns:

  • (Boolean)

1333
1334
1335
# File 'app/models/merge_request.rb', line 1333

def self.merge_request_ref?(ref)
  ref.start_with?("refs/#{Repository::REF_MERGE_REQUEST}/")
end

.merge_train_ref?(ref) ⇒ Boolean

Returns:

  • (Boolean)

1337
1338
1339
# File 'app/models/merge_request.rb', line 1337

def self.merge_train_ref?(ref)
  %r{\Arefs/#{Repository::REF_MERGE_REQUEST}/\d+/train\z}.match?(ref)
end

.project_foreign_keyObject


434
435
436
# File 'app/models/merge_request.rb', line 434

def self.project_foreign_key
  'target_project_id'
end

.recent_target_branches(limit: 100) ⇒ Object

Returns the top 100 target branches

The returned value is a Array containing branch names sort by updated_at of merge request:

['master', 'develop', 'production']

limit - The maximum number of target branch to return.


372
373
374
375
376
377
378
# File 'app/models/merge_request.rb', line 372

def self.recent_target_branches(limit: 100)
  group(:target_branch)
    .select(:target_branch)
    .reorder(arel_table[:updated_at].maximum.desc)
    .limit(limit)
    .pluck(:target_branch)
end

.reference_patternObject

Pattern used to extract `!123` merge request references from text

This pattern supports cross-project references.


419
420
421
422
423
424
# File 'app/models/merge_request.rb', line 419

def self.reference_pattern
  @reference_pattern ||= %r{
    (#{Project.reference_pattern})?
    #{Regexp.escape(reference_prefix)}(?<merge_request>\d+)
  }x
end

.reference_prefixObject


360
361
362
# File 'app/models/merge_request.rb', line 360

def self.reference_prefix
  '!'
end

.reference_valid?(reference) ⇒ Boolean

Returns:

  • (Boolean)

430
431
432
# File 'app/models/merge_request.rb', line 430

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

.reviewers_subqueryObject


389
390
391
392
393
# File 'app/models/merge_request.rb', line 389

def self.reviewers_subquery
  MergeRequestReviewer.arel_table
    .project('true')
    .where(Arel::Nodes::SqlLiteral.new("#{to_ability_name}_id = #{to_ability_name}s.id"))
end

.set_latest_merge_request_diff_ids!Object

This is used after project import, to reset the IDs to the correct values. It is not intended to be called without having already scoped the relation.


460
461
462
463
464
465
466
467
468
469
470
471
# File 'app/models/merge_request.rb', line 460

def self.set_latest_merge_request_diff_ids!
  update = '
    latest_merge_request_diff_id = (
      SELECT MAX(id)
      FROM merge_request_diffs
      WHERE merge_requests.id = merge_request_diffs.merge_request_id
    )'.squish

  self.each_batch do |batch|
    batch.update_all(update)
  end
end

.sort_by_attribute(method, excluded_labels: []) ⇒ Object


380
381
382
383
384
385
386
387
# File 'app/models/merge_request.rb', line 380

def self.sort_by_attribute(method, excluded_labels: [])
  case method.to_s
  when 'merged_at', 'merged_at_asc' then order_merged_at_asc.with_order_id_desc
  when 'merged_at_desc' then order_merged_at_desc.with_order_id_desc
  else
    super
  end
end

.wip_title(title) ⇒ Object


485
486
487
# File 'app/models/merge_request.rb', line 485

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

.wipless_title(title) ⇒ Object


481
482
483
# File 'app/models/merge_request.rb', line 481

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

.work_in_progress?(title) ⇒ Boolean

Returns:

  • (Boolean)

477
478
479
# File 'app/models/merge_request.rb', line 477

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

Instance Method Details

#actual_head_pipelineObject

Use this method whenever you need to make sure the head_pipeline is synced with the branch head commit, for example checking if a merge request can be merged. For more information check: gitlab.com/gitlab-org/gitlab-foss/issues/40004


402
403
404
# File 'app/models/merge_request.rb', line 402

def actual_head_pipeline
  head_pipeline&.matches_sha_or_source_sha?(diff_head_sha) ? head_pipeline : nil
end

#all_commit_shasObject

Note that this could also return SHA from now dangling commits


1514
1515
1516
1517
1518
1519
1520
# File 'app/models/merge_request.rb', line 1514

def all_commit_shas
  @all_commit_shas ||= begin
    return commit_shas unless persisted?

    all_commits.pluck(:sha).uniq
  end
end

#all_commitsObject


1506
1507
1508
1509
1510
# File 'app/models/merge_request.rb', line 1506

def all_commits
  MergeRequestDiffCommit
    .where(merge_request_diff: merge_request_diffs.recent)
    .limit(10_000)
end

#all_pipelinesObject


1383
1384
1385
1386
1387
# File 'app/models/merge_request.rb', line 1383

def all_pipelines
  strong_memoize(:all_pipelines) do
    Ci::PipelinesForMergeRequestFinder.new(self, nil).all
  end
end

#allow_collaborationObject Also known as: allow_collaboration?


1671
1672
1673
# File 'app/models/merge_request.rb', line 1671

def allow_collaboration
  collaborative_push_possible? && allow_maintainer_to_push
end

#allows_multiple_reviewers?Boolean

Returns:

  • (Boolean)

1740
1741
1742
# File 'app/models/merge_request.rb', line 1740

def allows_multiple_reviewers?
  false
end

#allows_reviewers?Boolean

Returns:

  • (Boolean)

1736
1737
1738
# File 'app/models/merge_request.rb', line 1736

def allows_reviewers?
  Feature.enabled?(:merge_request_reviewers, project)
end

#auto_merge_strategyObject


1051
1052
1053
1054
1055
# File 'app/models/merge_request.rb', line 1051

def auto_merge_strategy
  return unless auto_merge_enabled?

  merge_params['auto_merge_strategy'] || AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS
end

#auto_merge_strategy=(strategy) ⇒ Object


1057
1058
1059
# File 'app/models/merge_request.rb', line 1057

def auto_merge_strategy=(strategy)
  merge_params['auto_merge_strategy'] = strategy
end

#banzai_render_context(field) ⇒ Object


1708
1709
1710
# File 'app/models/merge_request.rb', line 1708

def banzai_render_context(field)
  super.merge(label_url_method: :project_merge_requests_url)
end

#base_pipelineObject


1639
1640
1641
1642
1643
# File 'app/models/merge_request.rb', line 1639

def base_pipeline
  @base_pipeline ||= project.ci_pipelines
    .order(id: :desc)
    .find_by(sha: diff_base_sha, ref: target_branch)
end

#branch_merge_base_commitObject


775
776
777
778
779
780
781
782
# File 'app/models/merge_request.rb', line 775

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

#branch_merge_base_shaObject


812
813
814
# File 'app/models/merge_request.rb', line 812

def branch_merge_base_sha
  branch_merge_base_commit.try(:sha)
end

#branch_missing?Boolean

Returns:

  • (Boolean)

1250
1251
1252
# File 'app/models/merge_request.rb', line 1250

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

#broken?Boolean

Returns:

  • (Boolean)

1254
1255
1256
# File 'app/models/merge_request.rb', line 1254

def broken?
  has_no_commits? || branch_missing? || cannot_be_merged?
end

#cache_merge_request_closes_issues!(current_user = self.author) ⇒ Object

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. This optimization does not apply to issues from external sources.


1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
# File 'app/models/merge_request.rb', line 1117

def cache_merge_request_closes_issues!(current_user = self.author)
  return unless project.issues_enabled?
  return if closed? || merged?

  transaction do
    self.merge_requests_closing_issues.delete_all

    closes_issues(current_user).each do |issue|
      next if issue.is_a?(ExternalIssue)

      self.merge_requests_closing_issues.create!(issue: issue)
    end
  end
end

#calculate_reactive_cache(identifier, current_user_id = nil, report_type = nil, *args) ⇒ Object

Raises:

  • (NameError)

1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
# File 'app/models/merge_request.rb', line 1495

def calculate_reactive_cache(identifier, current_user_id = nil, report_type = nil, *args)
  service_class = identifier.constantize

  # TODO: the type check should change to something that includes exposed artifacts service
  # issue: https://gitlab.com/gitlab-org/gitlab/issues/34224
  raise NameError, service_class unless service_class < Ci::CompareReportsBaseService

  current_user = User.find_by(id: current_user_id)
  service_class.new(project, current_user, id: id, report_type: report_type).execute(base_pipeline, actual_head_pipeline)
end

#can_allow_collaboration?(user) ⇒ Boolean

Returns:

  • (Boolean)

1684
1685
1686
1687
# File 'app/models/merge_request.rb', line 1684

def can_allow_collaboration?(user)
  collaborative_push_possible? &&
    Ability.allowed?(user, :push_code, source_project)
end

#can_be_cherry_picked?Boolean

Returns:

  • (Boolean)

1569
1570
1571
# File 'app/models/merge_request.rb', line 1569

def can_be_cherry_picked?
  merge_commit.present?
end

#can_be_merged_by?(user) ⇒ Boolean

Returns:

  • (Boolean)

1258
1259
1260
1261
# File 'app/models/merge_request.rb', line 1258

def can_be_merged_by?(user)
  access = ::Gitlab::UserAccess.new(user, container: project)
  access.can_update_branch?(target_branch)
end

#can_be_merged_via_command_line_by?(user) ⇒ Boolean

Returns:

  • (Boolean)

1263
1264
1265
1266
# File 'app/models/merge_request.rb', line 1263

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

#can_be_reverted?(current_user) ⇒ Boolean

Returns:

  • (Boolean)

1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
# File 'app/models/merge_request.rb', line 1543

def can_be_reverted?(current_user)
  return false unless merge_commit
  return false unless merged_at

  # It is not guaranteed that Note#created_at will be strictly later than
  # MergeRequestMetric#merged_at. Nanoseconds on MySQL may break this
  # comparison, as will a HA environment if clocks are not *precisely*
  # synchronized. Add a minute's leeway to compensate for both possibilities
  cutoff = merged_at - 1.minute

  notes_association = notes_with_associations.where('created_at >= ?', cutoff)

  !merge_commit.has_been_reverted?(current_user, notes_association)
end

#can_cancel_auto_merge?(current_user) ⇒ Boolean

Returns:

  • (Boolean)

1031
1032
1033
# File 'app/models/merge_request.rb', line 1031

def can_cancel_auto_merge?(current_user)
  can_be_merged_by?(current_user) || self.author == current_user
end

#can_remove_source_branch?(current_user) ⇒ Boolean

Returns:

  • (Boolean)

1035
1036
1037
1038
1039
1040
1041
# File 'app/models/merge_request.rb', line 1035

def can_remove_source_branch?(current_user)
  source_project &&
    !ProtectedBranch.protected?(source_project, source_branch) &&
    !source_project.root_ref?(source_branch) &&
    Ability.allowed?(current_user, :push_code, source_project) &&
    diff_head_sha == source_branch_head.try(:sha)
end

#check_mergeability(async: false) ⇒ Object


961
962
963
964
965
966
967
968
969
970
971
# File 'app/models/merge_request.rb', line 961

def check_mergeability(async: false)
  return unless recheck_merge_status?

  check_service = MergeRequests::MergeabilityCheckService.new(self)

  if async
    check_service.async_execute
  else
    check_service.execute(retry_lease: false)
  end
end

#cleanup_refs(only: :all) ⇒ Object


1324
1325
1326
1327
1328
1329
1330
1331
# File 'app/models/merge_request.rb', line 1324

def cleanup_refs(only: :all)
  target_refs = []
  target_refs << ref_path       if %i[all head].include?(only)
  target_refs << merge_ref_path if %i[all merge].include?(only)
  target_refs << train_ref_path if %i[all train].include?(only)

  project.repository.delete_refs(*target_refs)
end

#clear_memoized_shasObject


940
941
942
943
944
945
# File 'app/models/merge_request.rb', line 940

def clear_memoized_shas
  @target_branch_sha = @source_branch_sha = nil

  clear_memoization(:source_branch_head)
  clear_memoization(:target_branch_head)
end

#closed_eventObject


988
989
990
# File 'app/models/merge_request.rb', line 988

def closed_event
  @closed_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: :closed).last
end

#closed_without_fork?Boolean

Returns:

  • (Boolean)

879
880
881
# File 'app/models/merge_request.rb', line 879

def closed_without_fork?
  closed? && source_project_missing?
end

#closes_issues(current_user = self.author) ⇒ Object

Return the set of issues that will be closed if this merge request is accepted.


1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
# File 'app/models/merge_request.rb', line 1145

def closes_issues(current_user = self.author)
  if target_branch == project.default_branch
    messages = [title, description]
    messages.concat(commits.map(&:safe_message)) if merge_request_diff.persisted?

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

#collaborative_push_possible?Boolean

Returns:

  • (Boolean)

1677
1678
1679
1680
1681
1682
# File 'app/models/merge_request.rb', line 1677

def collaborative_push_possible?
  source_project.present? && for_fork? &&
    target_project.visibility_level > Gitlab::VisibilityLevel::PRIVATE &&
    source_project.visibility_level > Gitlab::VisibilityLevel::PRIVATE &&
    !ProtectedBranch.protected?(source_project, source_branch)
end

#commit_notesObject


1088
1089
1090
1091
1092
1093
1094
1095
1096
# File 'app/models/merge_request.rb', line 1088

def commit_notes
  # Fetch comments only from last 100 commits
  commit_ids = commit_shas(limit: 100)

  Note
    .user
    .where(project_id: [source_project_id, target_project_id])
    .for_commit_id(commit_ids)
end

#commit_shas(limit: nil) ⇒ Object


549
550
551
552
553
554
555
556
557
558
559
560
# File 'app/models/merge_request.rb', line 549

def commit_shas(limit: nil)
  return merge_request_diff.commit_shas(limit: limit) if merge_request_diff.persisted?

  shas =
    if compare_commits
      compare_commits.to_a.reverse.map(&:sha)
    else
      Array(diff_head_sha)
    end

  limit ? shas.take(limit) : shas
end

#commits(limit: nil) ⇒ Object


522
523
524
525
526
527
528
529
530
531
532
533
# File 'app/models/merge_request.rb', line 522

def commits(limit: nil)
  return merge_request_diff.commits(limit: limit) if merge_request_diff.persisted?

  commits_arr = if compare_commits
                  reversed_commits = compare_commits.reverse
                  limit ? reversed_commits.take(limit) : reversed_commits
                else
                  []
                end

  CommitCollection.new(source_project, commits_arr, source_branch)
end

#commits_countObject


539
540
541
542
543
544
545
546
547
# File 'app/models/merge_request.rb', line 539

def commits_count
  if merge_request_diff.persisted?
    merge_request_diff.commits_count
  elsif compare_commits
    compare_commits.size
  else
    0
  end
end

#committersObject


489
490
491
# File 'app/models/merge_request.rb', line 489

def committers
  @committers ||= commits.committers
end

#compare_accessibility_reportsObject


1437
1438
1439
1440
1441
1442
1443
# File 'app/models/merge_request.rb', line 1437

def compare_accessibility_reports
  unless has_accessibility_reports?
    return { status: :error, status_reason: _('This merge request does not have accessibility reports') }
  end

  compare_reports(Ci::CompareAccessibilityReportsService)
end

#compare_reports(service_class, current_user = nil, report_type = nil) ⇒ Object

TODO: consider renaming this as with exposed artifacts we generate reports, not always compare issue: gitlab.com/gitlab-org/gitlab/issues/34224


1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
# File 'app/models/merge_request.rb', line 1484

def compare_reports(service_class, current_user = nil, report_type = nil )
  with_reactive_cache(service_class.name, current_user&.id, report_type) do |data|
    unless service_class.new(project, current_user, id: id, report_type: report_type)
      .latest?(base_pipeline, actual_head_pipeline, data)
      raise InvalidateReactiveCache
    end

    data
  end || { status: :parsing }
end

#compare_test_reportsObject


1417
1418
1419
1420
1421
1422
1423
# File 'app/models/merge_request.rb', line 1417

def compare_test_reports
  unless has_test_reports?
    return { status: :error, status_reason: 'This merge request does not have test reports' }
  end

  compare_reports(Ci::CompareTestReportsService)
end

#context_commits(limit: nil) ⇒ Object


510
511
512
# File 'app/models/merge_request.rb', line 510

def context_commits(limit: nil)
  @context_commits ||= merge_request_context_commits.order_by_committed_date_desc.limit(limit).map(&:to_commit)
end

#context_commits_countObject


518
519
520
# File 'app/models/merge_request.rb', line 518

def context_commits_count
  context_commits.count
end

#create_merge_request_diffObject


898
899
900
901
902
903
904
905
906
# File 'app/models/merge_request.rb', line 898

def create_merge_request_diff
  fetch_ref!

  # n+1: https://gitlab.com/gitlab-org/gitlab-foss/issues/37435
  Gitlab::GitalyClient.allow_n_plus_1_calls do
    merge_request_diffs.create!
    reload_merge_request_diff
  end
end

#default_merge_commit_message(include_description: false) ⇒ Object


1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
# File 'app/models/merge_request.rb', line 1210

def default_merge_commit_message(include_description: false)
  closes_issues_references = visible_closing_issues_for.map do |issue|
    issue.to_reference(target_project)
  end

  message = [
    "Merge branch '#{source_branch}' into '#{target_branch}'",
    title
  ]

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

  message << "#{description}" if include_description && description.present?
  message << "See merge request #{to_reference(full: true)}"

  message.join("\n\n")
end

#default_squash_commit_messageObject

Returns the oldest multi-line commit message, or the MR title if none found


1231
1232
1233
1234
1235
# File 'app/models/merge_request.rb', line 1231

def default_squash_commit_message
  strong_memoize(:default_squash_commit_message) do
    recent_commits.without_merge_commits.reverse_each.find(&:description?)&.safe_message || title
  end
end

#diff_base_commitObject


693
694
695
696
697
698
699
# File 'app/models/merge_request.rb', line 693

def diff_base_commit
  if merge_request_diff.persisted?
    merge_request_diff.base_commit
  else
    branch_merge_base_commit
  end
end

#diff_base_shaObject


725
726
727
728
729
730
731
# File 'app/models/merge_request.rb', line 725

def diff_base_sha
  if merge_request_diff.persisted?
    merge_request_diff.base_commit_sha
  else
    branch_merge_base_commit.try(:sha)
  end
end

#diff_head_commitObject


709
710
711
712
713
714
715
# File 'app/models/merge_request.rb', line 709

def diff_head_commit
  if merge_request_diff.persisted?
    merge_request_diff.head_commit
  else
    source_branch_head
  end
end

#diff_head_shaObject


733
734
735
736
737
738
739
# File 'app/models/merge_request.rb', line 733

def diff_head_sha
  if merge_request_diff.persisted?
    merge_request_diff.head_commit_sha
  else
    source_branch_head.try(:sha)
  end
end

#diff_refsObject


792
793
794
795
796
797
798
# File 'app/models/merge_request.rb', line 792

def diff_refs
  if importing? || persisted?
    merge_request_diff.diff_refs
  else
    repository_diff_refs
  end
end

#diff_sizeObject


673
674
675
676
677
# File 'app/models/merge_request.rb', line 673

def diff_size
  # Calling `merge_request_diff.diffs.real_size` will also perform
  # highlighting, which we don't need here.
  merge_request_diff&.real_size || diff_stats&.real_size(project: project) || diffs.real_size
end

#diff_start_commitObject


701
702
703
704
705
706
707
# File 'app/models/merge_request.rb', line 701

def diff_start_commit
  if merge_request_diff.persisted?
    merge_request_diff.start_commit
  else
    target_branch_head
  end
end

#diff_start_shaObject


717
718
719
720
721
722
723
# File 'app/models/merge_request.rb', line 717

def diff_start_sha
  if merge_request_diff.persisted?
    merge_request_diff.start_commit_sha
  else
    target_branch_head.try(:sha)
  end
end

#diff_statsObject


665
666
667
668
669
670
671
# File 'app/models/merge_request.rb', line 665

def diff_stats
  return unless diff_refs

  strong_memoize(:diff_stats) do
    project.repository.diff_stats(diff_refs.base_sha, diff_refs.head_sha)
  end
end

#diffable_merge_ref?Boolean

rubocop: enable CodeReuse/ServiceClass

Returns:

  • (Boolean)

974
975
976
# File 'app/models/merge_request.rb', line 974

def diffable_merge_ref?
  open? && merge_ref_head.present? && (Feature.enabled?(:display_merge_conflicts_in_diff, project) || can_be_merged?)
end

#diffs(diff_options = {}) ⇒ Object


618
619
620
621
622
623
624
625
626
627
# File 'app/models/merge_request.rb', line 618

def diffs(diff_options = {})
  if compare
    # When saving MR diffs, `expanded` 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(expanded: true))
  else
    merge_request_diff.diffs(diff_options)
  end
end

#discussions_diffsObject


654
655
656
657
658
659
660
661
662
663
# File 'app/models/merge_request.rb', line 654

def discussions_diffs
  strong_memoize(:discussions_diffs) do
    note_diff_files = NoteDiffFile
      .joins(:diff_note)
      .merge(notes.or(commit_notes))
      .includes(diff_note: :project)

    Gitlab::DiscussionsDiff::FileCollection.new(note_diff_files.to_a)
  end
end

#discussions_rendered_on_frontend?Boolean

Returns:

  • (Boolean)

1651
1652
1653
# File 'app/models/merge_request.rb', line 1651

def discussions_rendered_on_frontend?
  true
end

#diverged_commits_countObject


1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
# File 'app/models/merge_request.rb', line 1356

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

  if cache.blank? || cache[:source_sha] != source_branch_sha || cache[:target_sha] != target_branch_sha
    cache = {
      source_sha: source_branch_sha,
      target_sha: target_branch_sha,
      diverged_commits_count: compute_diverged_commits_count
    }
    Rails.cache.write(:"merge_request_#{id}_diverged_commits", cache)
  end

  cache[:diverged_commits_count]
end

#diverged_from_target_branch?Boolean

Returns:

  • (Boolean)

1379
1380
1381
# File 'app/models/merge_request.rb', line 1379

def diverged_from_target_branch?
  diverged_commits_count > 0
end

#ensure_merge_request_diffObject


894
895
896
# File 'app/models/merge_request.rb', line 894

def ensure_merge_request_diff
  merge_request_diff.persisted? || create_merge_request_diff
end

#ensure_metricsObject


1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
# File 'app/models/merge_request.rb', line 1713

def ensure_metrics
  # Backward compatibility: some merge request metrics records will not have target_project_id filled in.
  # In that case the first `safe_find_or_create_by` will return false.
  # The second finder call will be eliminated in https://gitlab.com/gitlab-org/gitlab/-/issues/233507
  metrics_record = MergeRequest::Metrics.safe_find_or_create_by(merge_request_id: id, target_project_id: target_project_id) || MergeRequest::Metrics.safe_find_or_create_by(merge_request_id: id)

  metrics_record.tap do |metrics_record|
    # Make sure we refresh the loaded association object with the newly created/loaded item.
    # This is needed in order to have the exact functionality than before.
    #
    # Example:
    #
    # merge_request.metrics.destroy
    # merge_request.ensure_metrics
    # merge_request.metrics # should return the metrics record and not nil
    # merge_request.metrics.merge_request # should return the same MR record

    metrics_record.target_project_id = target_project_id
    metrics_record.association(:merge_request).target = self
    association(:metrics).target = metrics_record
  end
end

#environmentsObject

This method is for looking for active environments which created via pipelines for merge requests. Since deployments run on a merge request ref (e.g. `refs/merge-requests/:iid/head`), we cannot look up environments with source branch name.


1294
1295
1296
1297
1298
# File 'app/models/merge_request.rb', line 1294

def environments
  return Environment.none unless actual_head_pipeline&.merge_request?

  actual_head_pipeline.environments
end

#environments_for(current_user, latest: false) ⇒ Object


1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
# File 'app/models/merge_request.rb', line 1276

def environments_for(current_user, latest: false)
  return [] unless diff_head_commit

  envs = EnvironmentsFinder.new(target_project, current_user,
    ref: target_branch, commit: diff_head_commit, with_tags: true, find_latest: latest).execute

  if source_project
    envs.concat EnvironmentsFinder.new(source_project, current_user,
      ref: source_branch, commit: diff_head_commit, find_latest: latest).execute
  end

  envs.uniq
end

#etag_caching_enabled?Boolean

Returns:

  • (Boolean)

1700
1701
1702
# File 'app/models/merge_request.rb', line 1700

def etag_caching_enabled?
  true
end

#fetch_ref!Object


1300
1301
1302
# File 'app/models/merge_request.rb', line 1300

def fetch_ref!
  target_project.repository.fetch_source_branch!(source_project.repository, source_branch, ref_path)
end

#ff_merge_possible?Boolean

Returns:

  • (Boolean)

1023
1024
1025
# File 'app/models/merge_request.rb', line 1023

def ff_merge_possible?
  project.repository.ancestor?(target_branch_sha, diff_head_sha)
end

#find_actual_head_pipelineObject


1696
1697
1698
# File 'app/models/merge_request.rb', line 1696

def find_actual_head_pipeline
  all_pipelines.for_sha_or_source_sha(diff_head_sha).first
end

#find_coverage_reportsObject

TODO: this method and compare_test_reports use the same result type, which is handled by the controller's #reports_response. we should minimize mistakes by isolating the common parts. issue: gitlab.com/gitlab-org/gitlab/issues/34224


1449
1450
1451
1452
1453
1454
1455
# File 'app/models/merge_request.rb', line 1449

def find_coverage_reports
  unless has_coverage_reports?
    return { status: :error, status_reason: 'This merge request does not have coverage reports' }
  end

  compare_reports(Ci::GenerateCoverageReportsService)
end

#find_exposed_artifactsObject

TODO: this method and compare_test_reports use the same result type, which is handled by the controller's #reports_response. we should minimize mistakes by isolating the common parts. issue: gitlab.com/gitlab-org/gitlab/issues/34224


1473
1474
1475
1476
1477
1478
1479
# File 'app/models/merge_request.rb', line 1473

def find_exposed_artifacts
  unless has_exposed_artifacts?
    return { status: :error, status_reason: 'This merge request does not have exposed artifacts' }
  end

  compare_reports(Ci::GenerateExposedArtifactsReportService)
end

#find_terraform_reportsObject


1457
1458
1459
1460
1461
1462
1463
# File 'app/models/merge_request.rb', line 1457

def find_terraform_reports
  unless has_terraform_reports?
    return { status: :error, status_reason: 'This merge request does not have terraform reports' }
  end

  compare_reports(Ci::GenerateTerraformReportsService)
end

#first_commitObject


610
611
612
# File 'app/models/merge_request.rb', line 610

def first_commit
  compare_commits.present? ? compare_commits.first : merge_request_diff.first_commit
end

#first_contribution?Boolean

rubocop: enable CodeReuse/ServiceClass

Returns:

  • (Boolean)

1661
1662
1663
1664
1665
# File 'app/models/merge_request.rb', line 1661

def first_contribution?
  return false if project.team.max_member_access(author_id) > Gitlab::Access::GUEST

  !project.merge_requests.merged.exists?(author_id: author_id)
end

#for_fork?Boolean

Returns:

  • (Boolean)

1104
1105
1106
# File 'app/models/merge_request.rb', line 1104

def for_fork?
  target_project != source_project
end

#for_same_project?Boolean

Returns:

  • (Boolean)

1108
1109
1110
# File 'app/models/merge_request.rb', line 1108

def for_same_project?
  target_project == source_project
end

#force_remove_source_branch?Boolean

Returns:

  • (Boolean)

1047
1048
1049
# File 'app/models/merge_request.rb', line 1047

def force_remove_source_branch?
  Gitlab::Utils.to_boolean(merge_params['force_remove_source_branch'])
end

#has_accessibility_reports?Boolean

Returns:

  • (Boolean)

1425
1426
1427
# File 'app/models/merge_request.rb', line 1425

def has_accessibility_reports?
  actual_head_pipeline.present? && actual_head_pipeline.has_reports?(Ci::JobArtifact.accessibility_reports)
end

#has_ci?Boolean

Returns:

  • (Boolean)

1244
1245
1246
1247
1248
# File 'app/models/merge_request.rb', line 1244

def has_ci?
  return false if has_no_commits?

  !!(head_pipeline_id || all_pipelines.any? || source_project&.ci_service)
end

#has_commits?Boolean

Returns:

  • (Boolean)

1613
1614
1615
# File 'app/models/merge_request.rb', line 1613

def has_commits?
  merge_request_diff.persisted? && commits_count.to_i > 0
end

#has_complete_diff_refs?Boolean

Returns:

  • (Boolean)

1573
1574
1575
# File 'app/models/merge_request.rb', line 1573

def has_complete_diff_refs?
  diff_refs && diff_refs.complete?
end

#has_coverage_reports?Boolean

Returns:

  • (Boolean)

1429
1430
1431
# File 'app/models/merge_request.rb', line 1429

def has_coverage_reports?
  actual_head_pipeline&.has_coverage_reports?
end

#has_exposed_artifacts?Boolean

Returns:

  • (Boolean)

1465
1466
1467
# File 'app/models/merge_request.rb', line 1465

def has_exposed_artifacts?
  actual_head_pipeline&.has_exposed_artifacts?
end

#has_no_commits?Boolean

Returns:

  • (Boolean)

1617
1618
1619
# File 'app/models/merge_request.rb', line 1617

def has_no_commits?
  !has_commits?
end

#has_terraform_reports?Boolean

Returns:

  • (Boolean)

1433
1434
1435
# File 'app/models/merge_request.rb', line 1433

def has_terraform_reports?
  actual_head_pipeline&.has_reports?(Ci::JobArtifact.terraform_reports)
end

#has_test_reports?Boolean

Returns:

  • (Boolean)

1396
1397
1398
# File 'app/models/merge_request.rb', line 1396

def has_test_reports?
  actual_head_pipeline&.has_reports?(Ci::JobArtifact.test_reports)
end

#hook_attrsObject


499
500
501
# File 'app/models/merge_request.rb', line 499

def hook_attrs
  Gitlab::HookData::MergeRequestBuilder.new(self).build
end

#in_locked_stateObject


1341
1342
1343
1344
1345
1346
# File 'app/models/merge_request.rb', line 1341

def in_locked_state
  lock_mr
  yield
ensure
  unlock_mr
end

#issues_mentioned_but_not_closing(current_user) ⇒ Object


1157
1158
1159
1160
1161
1162
1163
1164
# File 'app/models/merge_request.rb', line 1157

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

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

  ext.issues - visible_closing_issues_for(current_user)
end

#keep_around_commitObject

rubocop: enable CodeReuse/ServiceClass


1609
1610
1611
# File 'app/models/merge_request.rb', line 1609

def keep_around_commit
  project.repository.keep_around(self.merge_commit_sha)
end

#merge_async(user_id, params) ⇒ Object

Calls `MergeWorker` to proceed with the merge process and updates `merge_jid` with the MergeWorker#jid. This helps tracking enqueued and ongoing merge jobs.


569
570
571
572
573
574
575
576
# File 'app/models/merge_request.rb', line 569

def merge_async(user_id, params)
  jid = MergeWorker.perform_async(id, user_id, params.to_h)
  update_column(:merge_jid, jid)

  # merge_ongoing? depends on merge_jid
  # expire etag cache since the attribute is changed without triggering callbacks
  expire_etag_cache
end

#merge_base_pipelineObject


1645
1646
1647
1648
1649
# File 'app/models/merge_request.rb', line 1645

def merge_base_pipeline
  @merge_base_pipeline ||= project.ci_pipelines
    .order(id: :desc)
    .find_by(sha: actual_head_pipeline.target_sha, ref: target_branch)
end

#merge_commitObject


1522
1523
1524
# File 'app/models/merge_request.rb', line 1522

def merge_commit
  @merge_commit ||= project.commit(merge_commit_sha) if merge_commit_sha
end

#merge_eventObject


984
985
986
# File 'app/models/merge_request.rb', line 984

def merge_event
  @merge_event ||= target_project.events.where(target_id: self.id, target_type: "MergeRequest", action: :merged).last
end

#merge_ongoing?Boolean

Returns:

  • (Boolean)

871
872
873
874
875
876
877
# File 'app/models/merge_request.rb', line 871

def merge_ongoing?
  # While the MergeRequest is locked, it should present itself as 'merge ongoing'.
  # The unlocking process is handled by StuckMergeJobsWorker scheduled in Cron.
  return true if locked?

  !!merge_jid && !merged? && Gitlab::SidekiqStatus.running?(merge_jid)
end

#merge_participantsObject


600
601
602
603
604
605
606
607
608
# File 'app/models/merge_request.rb', line 600

def merge_participants
  participants = [author]

  if auto_merge_enabled? && !participants.include?(merge_user)
    participants << merge_user
  end

  participants.select { |participant| Ability.allowed?(participant, :read_merge_request, self) }
end

#merge_pipelineObject


406
407
408
409
410
411
412
413
414
# File 'app/models/merge_request.rb', line 406

def merge_pipeline
  return unless merged?

  # When the merge_method is :merge there will be a merge_commit_sha, however
  # when it is fast-forward there is no merge commit, so we must fall back to
  # either the squash commit (if the MR was squashed) or the diff head commit.
  sha = merge_commit_sha || squash_commit_sha || diff_head_sha
  target_project.latest_pipeline(target_branch, sha)
end

#merge_ref_headObject

Returns the current merge-ref HEAD commit.


1306
1307
1308
1309
1310
# File 'app/models/merge_request.rb', line 1306

def merge_ref_head
  return project.repository.commit(merge_ref_sha) if merge_ref_sha

  project.repository.commit(merge_ref_path)
end

#merge_ref_pathObject


1316
1317
1318
# File 'app/models/merge_request.rb', line 1316

def merge_ref_path
  "refs/#{Repository::REF_MERGE_REQUEST}/#{iid}/merge"
end

#merge_request_diffObject

This is the same as latest_merge_request_diff unless:

  1. There are arguments - in which case we might be trying to force-reload.

  2. This association is already loaded.

  3. The latest diff does not exist.

  4. It doesn't have any merge_request_diffs - it returns an empty MergeRequestDiff

The second one in particular is important - MergeRequestDiff#merge_request is the inverse of MergeRequest#merge_request_diff, which means it may not be the latest diff, because we could have loaded any diff from this particular MR. If we haven't already loaded a diff, then it's fine to load the latest.


74
75
76
77
78
# File 'app/models/merge_request.rb', line 74

def merge_request_diff
  fallback = latest_merge_request_diff unless association(:merge_request_diff).loaded?

  fallback || super || MergeRequestDiff.new(merge_request_id: id)
end

#merge_request_diff_for(diff_refs_or_sha) ⇒ Object


912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
# File 'app/models/merge_request.rb', line 912

def merge_request_diff_for(diff_refs_or_sha)
  matcher =
    if diff_refs_or_sha.is_a?(Gitlab::Diff::DiffRefs)
      {
        'start_commit_sha' => diff_refs_or_sha.start_sha,
        'head_commit_sha' => diff_refs_or_sha.head_sha,
        'base_commit_sha' => diff_refs_or_sha.base_sha
      }
    else
      { 'head_commit_sha' => diff_refs_or_sha }
    end

  viewable_diffs.find do |diff|
    diff.attributes.slice(*matcher.keys) == matcher
  end
end

#mergeable?(skip_ci_check: false, skip_discussions_check: false) ⇒ Boolean

Returns:

  • (Boolean)

1004
1005
1006
1007
1008
1009
1010
1011
# File 'app/models/merge_request.rb', line 1004

def mergeable?(skip_ci_check: false, skip_discussions_check: false)
  return false unless mergeable_state?(skip_ci_check: skip_ci_check,
                                       skip_discussions_check: skip_discussions_check)

  check_mergeability

  can_be_merged? && !should_be_rebased?
end

#mergeable_ci_state?Boolean

Returns:

  • (Boolean)

1268
1269
1270
1271
1272
1273
1274
# File 'app/models/merge_request.rb', line 1268

def mergeable_ci_state?
  return true unless project.only_allow_merge_if_pipeline_succeeds?
  return false unless actual_head_pipeline
  return true if project.allow_merge_on_skipped_pipeline? && actual_head_pipeline.skipped?

  actual_head_pipeline.success?
end

#mergeable_discussions_state?Boolean

Returns:

  • (Boolean)

1098
1099
1100
1101
1102
# File 'app/models/merge_request.rb', line 1098

def mergeable_discussions_state?
  return true unless project.only_allow_merge_if_all_discussions_are_resolved?

  unresolved_notes.none?(&:to_be_resolved?)
end

#mergeable_state?(skip_ci_check: false, skip_discussions_check: false) ⇒ Boolean

Returns:

  • (Boolean)

1013
1014
1015
1016
1017
1018
1019
1020
1021
# File 'app/models/merge_request.rb', line 1013

def mergeable_state?(skip_ci_check: false, skip_discussions_check: false)
  return false unless open?
  return false if work_in_progress?
  return false if broken?
  return false unless skip_ci_check || mergeable_ci_state?
  return false unless skip_discussions_check || mergeable_discussions_state?

  true
end

#mergeable_with_quick_action?(current_user, autocomplete_precheck: false, last_diff_sha: nil) ⇒ Boolean

Returns:

  • (Boolean)

1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
# File 'app/models/merge_request.rb', line 1621

def mergeable_with_quick_action?(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 actual_head_pipeline && !(actual_head_pipeline.success? || actual_head_pipeline.active?)
  return false if last_diff_sha != diff_head_sha

  true
end

#merged_atObject


1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
# File 'app/models/merge_request.rb', line 1558

def merged_at
  strong_memoize(:merged_at) do
    next unless merged?

    metrics&.merged_at ||
      merge_event&.created_at ||
      resource_state_events.find_by(state: :merged)&.created_at ||
      notes.system.reorder(nil).find_by(note: 'merged')&.created_at
  end
end

#merged_commit_shaObject


1530
1531
1532
1533
1534
1535
# File 'app/models/merge_request.rb', line 1530

def merged_commit_sha
  return unless merged?

  sha = merge_commit_sha || squash_commit_sha || diff_head_sha
  sha.presence
end

#modified_paths(past_merge_request_diff: nil, fallback_on_overflow: false) ⇒ Object


679
680
681
682
683
684
685
686
687
# File 'app/models/merge_request.rb', line 679

def modified_paths(past_merge_request_diff: nil, fallback_on_overflow: false)
  if past_merge_request_diff
    past_merge_request_diff.modified_paths(fallback_on_overflow: fallback_on_overflow)
  elsif compare
    diff_stats&.paths || compare.modified_paths
  else
    merge_request_diff.modified_paths(fallback_on_overflow: fallback_on_overflow)
  end
end

#new_pathsObject


689
690
691
# File 'app/models/merge_request.rb', line 689

def new_paths
  diffs.diff_files.map(&:new_path)
end

#non_latest_diffsObject


629
630
631
# File 'app/models/merge_request.rb', line 629

def non_latest_diffs
  merge_request_diffs.where.not(id: merge_request_diff.id)
end

#note_positions_for_paths(paths, user = nil) ⇒ Object


633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
# File 'app/models/merge_request.rb', line 633

def note_positions_for_paths(paths, user = nil)
  positions = notes.new_diff_notes.joins(:note_diff_file)
    .where('note_diff_files.old_path IN (?) OR note_diff_files.new_path IN (?)', paths, paths)
    .positions

  collection = Gitlab::Diff::PositionCollection.new(positions, diff_head_sha)

  return collection unless user

  positions = draft_notes
    .authored_by(user)
    .positions
    .select { |pos| paths.include?(pos.file_path) }

  collection.concat(positions)
end

#notify_conflict?Boolean

Returns:

  • (Boolean)

1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
# File 'app/models/merge_request.rb', line 1065

def notify_conflict?
  (opened? || locked?) &&
    has_commits? &&
    !branch_missing? &&
    !project.repository.can_be_merged?(diff_head_sha, target_branch)
rescue Gitlab::Git::CommandError
  # Checking mergeability can trigger exception, e.g. non-utf8
  # We ignore this type of errors.
  false
end

#pipeline_coverage_deltaObject


1633
1634
1635
1636
1637
# File 'app/models/merge_request.rb', line 1633

def pipeline_coverage_delta
  if base_pipeline&.coverage && head_pipeline&.coverage
    '%.2f' % (head_pipeline.coverage.to_f - base_pipeline.coverage.to_f)
  end
end

#predefined_variablesObject


1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
# File 'app/models/merge_request.rb', line 1400

def predefined_variables
  Gitlab::Ci::Variables::Collection.new.tap do |variables|
    variables.append(key: 'CI_MERGE_REQUEST_ID', value: id.to_s)
    variables.append(key: 'CI_MERGE_REQUEST_IID', value: iid.to_s)
    variables.append(key: 'CI_MERGE_REQUEST_REF_PATH', value: ref_path.to_s)
    variables.append(key: 'CI_MERGE_REQUEST_PROJECT_ID', value: project.id.to_s)
    variables.append(key: 'CI_MERGE_REQUEST_PROJECT_PATH', value: project.full_path)
    variables.append(key: 'CI_MERGE_REQUEST_PROJECT_URL', value: project.web_url)
    variables.append(key: 'CI_MERGE_REQUEST_TARGET_BRANCH_NAME', value: target_branch.to_s)
    variables.append(key: 'CI_MERGE_REQUEST_TITLE', value: title)
    variables.append(key: 'CI_MERGE_REQUEST_ASSIGNEES', value: assignee_username_list) if assignees.present?
    variables.append(key: 'CI_MERGE_REQUEST_MILESTONE', value: milestone.title) if milestone
    variables.append(key: 'CI_MERGE_REQUEST_LABELS', value: label_names.join(',')) if labels.present?
    variables.concat(source_project_variables)
  end
end

#preloads_discussion_diff_highlighting?Boolean

Returns:

  • (Boolean)

650
651
652
# File 'app/models/merge_request.rb', line 650

def preloads_discussion_diff_highlighting?
  true
end

#public_merge_statusObject

Returns current merge_status except it returns `cannot_be_merged_rechecking` as `checking` to avoid exposing unnecessary internal state


232
233
234
# File 'app/models/merge_request.rb', line 232

def public_merge_status
  cannot_be_merged_rechecking? ? 'checking' : merge_status
end

#raw_diffs(*args) ⇒ Object


614
615
616
# File 'app/models/merge_request.rb', line 614

def raw_diffs(*args)
  compare.present? ? compare.raw_diffs(*args) : merge_request_diff.raw_diffs(*args)
end

#rebase_async(user_id, skip_ci: false) ⇒ Object

Set off a rebase asynchronously, atomically updating the `rebase_jid` of the MR so that the status of the operation can be tracked.


580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
# File 'app/models/merge_request.rb', line 580

def rebase_async(user_id, skip_ci: false)
  with_rebase_lock do
    raise ActiveRecord::StaleObjectError if !open? || rebase_in_progress?

    # Although there is a race between setting rebase_jid here and clearing it
    # in the RebaseWorker, it can't do any harm since we check both that the
    # attribute is set *and* that the sidekiq job is still running. So a JID
    # for a completed RebaseWorker is equivalent to a nil JID.
    jid = Sidekiq::Worker.skipping_transaction_check do
      RebaseWorker.perform_async(id, user_id, skip_ci)
    end

    update_column(:rebase_jid, jid)
  end

  # rebase_in_progress? depends on rebase_jid
  # expire etag cache since the attribute is changed without triggering callbacks
  expire_etag_cache
end

#rebase_in_progress?Boolean

Returns:

  • (Boolean)

395
396
397
# File 'app/models/merge_request.rb', line 395

def rebase_in_progress?
  rebase_jid.present? && Gitlab::SidekiqStatus.running?(rebase_jid)
end

#recent_commitsObject


535
536
537
# File 'app/models/merge_request.rb', line 535

def recent_commits
  commits(limit: MergeRequestDiff::COMMITS_SAFE_SIZE)
end

#recent_context_commitsObject


514
515
516
# File 'app/models/merge_request.rb', line 514

def recent_context_commits
  context_commits(limit: MergeRequestDiff::COMMITS_SAFE_SIZE)
end

#recent_visible_deploymentsObject


1704
1705
1706
# File 'app/models/merge_request.rb', line 1704

def recent_visible_deployments
  deployments.visible.includes(:environment).order(id: :desc).limit(10)
end

#recheck_merge_status?Boolean

Returns boolean indicating the merge_status should be rechecked in order to switch to either can_be_merged or cannot_be_merged.

Returns:

  • (Boolean)

980
981
982
# File 'app/models/merge_request.rb', line 980

def recheck_merge_status?
  self.class.state_machines[:merge_status].check_state?(merge_status)
end

#ref_pathObject


1312
1313
1314
# File 'app/models/merge_request.rb', line 1312

def ref_path
  "refs/#{Repository::REF_MERGE_REQUEST}/#{iid}/head"
end

1076
1077
1078
1079
1080
1081
1082
1083
1084
# File 'app/models/merge_request.rb', line 1076

def related_notes
  # We're using a UNION ALL here since this results in better performance
  # compared to using OR statements. We're using UNION ALL since the queries
  # used won't produce any duplicates (e.g. a note for a commit can't also be
  # a note for an MR).
  Note
    .from_union([notes, commit_notes], remove_duplicates: false)
    .includes(:noteable)
end

#reload_diff(current_user = nil) ⇒ Object

rubocop: disable CodeReuse/ServiceClass


955
956
957
958
959
# File 'app/models/merge_request.rb', line 955

def reload_diff(current_user = nil)
  return unless open?

  MergeRequests::ReloadDiffsService.new(self, current_user).execute
end

#reload_diff_if_branch_changedObject


947
948
949
950
951
952
# File 'app/models/merge_request.rb', line 947

def reload_diff_if_branch_changed
  if (saved_change_to_source_branch? || saved_change_to_target_branch?) &&
      (source_branch_head && target_branch_head)
    reload_diff
  end
end

#remove_source_branch?Boolean

Returns:

  • (Boolean)

1061
1062
1063
# File 'app/models/merge_request.rb', line 1061

def remove_source_branch?
  should_remove_source_branch? || force_remove_source_branch?
end

#reopenable?Boolean

Returns:

  • (Boolean)

890
891
892
# File 'app/models/merge_request.rb', line 890

def reopenable?
  closed? && !source_project_missing? && source_branch_exists?
end

#repository_diff_refsObject

Instead trying to fetch the persisted diff_refs, this method goes straight to the repository to get the most recent data possible.


804
805
806
807
808
809
810
# File 'app/models/merge_request.rb', line 804

def repository_diff_refs
  Gitlab::Diff::DiffRefs.new(
    base_sha:  branch_merge_base_sha,
    start_sha: target_branch_sha,
    head_sha:  source_branch_sha
  )
end

#short_merge_commit_shaObject


1526
1527
1528
# File 'app/models/merge_request.rb', line 1526

def short_merge_commit_sha
  Commit.truncate_sha(merge_commit_sha) if merge_commit_sha
end

#short_merged_commit_shaObject


1537
1538
1539
1540
1541
# File 'app/models/merge_request.rb', line 1537

def short_merged_commit_sha
  if sha = merged_commit_sha
    Commit.truncate_sha(sha)
  end
end

#should_be_rebased?Boolean

Returns:

  • (Boolean)

1027
1028
1029
# File 'app/models/merge_request.rb', line 1027

def should_be_rebased?
  project.ff_merge_must_be_possible? && !ff_merge_possible?
end

#should_remove_source_branch?Boolean

Returns:

  • (Boolean)

1043
1044
1045
# File 'app/models/merge_request.rb', line 1043

def should_remove_source_branch?
  Gitlab::Utils.to_boolean(merge_params['should_remove_source_branch'])
end

#source_branch_exists?Boolean

Returns:

  • (Boolean)

1198
1199
1200
1201
1202
# File 'app/models/merge_request.rb', line 1198

def source_branch_exists?
  return false unless self.source_project

  self.source_project.repository.branch_exists?(self.source_branch)
end

#source_branch_headObject


761
762
763
764
765
766
767
# File 'app/models/merge_request.rb', line 761

def source_branch_head
  strong_memoize(:source_branch_head) do
    if source_project && source_branch_ref
      source_project.repository.commit(source_branch_ref)
    end
  end
end

#source_branch_refObject


747
748
749
750
751
752
# File 'app/models/merge_request.rb', line 747

def source_branch_ref
  return @source_branch_sha if @source_branch_sha
  return unless source_branch

  Gitlab::Git::BRANCH_REF_PREFIX + source_branch
end

#source_project_missing?Boolean

Returns:

  • (Boolean)

883
884
885
886
887
888
# File 'app/models/merge_request.rb', line 883

def source_project_missing?
  return false unless for_fork?
  return true unless source_project

  !source_project.in_fork_network_of?(target_project)
end

#source_project_namespaceObject


1182
1183
1184
1185
1186
1187
1188
# File 'app/models/merge_request.rb', line 1182

def source_project_namespace
  if source_project && source_project.namespace
    source_project.namespace.full_path
  else
    "(removed)"
  end
end

#source_project_pathObject


1174
1175
1176
1177
1178
1179
1180
# File 'app/models/merge_request.rb', line 1174

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

#squash_in_progress?Boolean

Returns:

  • (Boolean)

1689
1690
1691
1692
1693
1694
# File 'app/models/merge_request.rb', line 1689

def squash_in_progress?
  # The source project can be deleted
  return false unless source_project

  source_project.repository.squash_in_progress?(id)
end

#squash_on_merge?Boolean

Returns:

  • (Boolean)

1237
1238
1239
1240
1241
1242
# File 'app/models/merge_request.rb', line 1237

def squash_on_merge?
  return true if target_project.squash_always?
  return false if target_project.squash_never?

  squash?
end

#supports_suggestion?Boolean

Returns:

  • (Boolean)

562
563
564
# File 'app/models/merge_request.rb', line 562

def supports_suggestion?
  true
end

#target_branch_exists?Boolean

Returns:

  • (Boolean)

1204
1205
1206
1207
1208
# File 'app/models/merge_request.rb', line 1204

def target_branch_exists?
  return false unless self.target_project

  self.target_project.repository.branch_exists?(self.target_branch)
end

#target_branch_headObject


769
770
771
772
773
# File 'app/models/merge_request.rb', line 769

def target_branch_head
  strong_memoize(:target_branch_head) do
    target_project.repository.commit(target_branch_ref)
  end
end

#target_branch_refObject


754
755
756
757
758
759
# File 'app/models/merge_request.rb', line 754

def target_branch_ref
  return @target_branch_sha if @target_branch_sha
  return unless target_branch

  Gitlab::Git::BRANCH_REF_PREFIX + target_branch
end

#target_project_namespaceObject


1190
1191
1192
1193
1194
1195
1196
# File 'app/models/merge_request.rb', line 1190

def target_project_namespace
  if target_project && target_project.namespace
    target_project.namespace.full_path
  else
    "(removed)"
  end
end

#target_project_pathObject


1166
1167
1168
1169
1170
1171
1172
# File 'app/models/merge_request.rb', line 1166

def target_project_path
  if target_project
    target_project.full_path
  else
    "(removed)"
  end
end

#to_reference(from = nil, full: false) ⇒ Object

`from` argument can be a Namespace or Project.


504
505
506
507
508
# File 'app/models/merge_request.rb', line 504

def to_reference(from = nil, full: false)
  reference = "#{self.class.reference_prefix}#{iid}"

  "#{project.to_reference_base(from, full: full)}#{reference}"
end

#train_ref_pathObject


1320
1321
1322
# File 'app/models/merge_request.rb', line 1320

def train_ref_path
  "refs/#{Repository::REF_MERGE_REQUEST}/#{iid}/train"
end

#update_and_mark_in_progress_merge_commit_sha(commit_id) ⇒ Object


1348
1349
1350
1351
1352
1353
1354
# File 'app/models/merge_request.rb', line 1348

def update_and_mark_in_progress_merge_commit_sha(commit_id)
  self.update(in_progress_merge_commit_sha: commit_id)
  # Since another process checks for matching merge request, we need
  # to make it possible to detect whether the query should go to the
  # primary.
  target_project.mark_primary_write_location
end

#update_diff_discussion_positions(old_diff_refs:, new_diff_refs:, current_user: nil) ⇒ Object

rubocop: disable CodeReuse/ServiceClass


1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
# File 'app/models/merge_request.rb', line 1578

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

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

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

  service = Discussions::UpdateDiffPositionService.new(
    self.project,
    current_user,
    old_diff_refs: old_diff_refs,
    new_diff_refs: new_diff_refs,
    paths: paths
  )

  active_diff_discussions.each do |discussion|
    service.execute(discussion)
  end

  if project.resolve_outdated_diff_discussions?
    MergeRequests::ResolvedDiscussionNotificationService
      .new(project, current_user)
      .execute(self)
  end
end

#update_head_pipelineObject


1389
1390
1391
1392
1393
1394
# File 'app/models/merge_request.rb', line 1389

def update_head_pipeline
  find_actual_head_pipeline.try do |pipeline|
    self.head_pipeline = pipeline
    update_column(:head_pipeline_id, head_pipeline.id) if head_pipeline_id_changed?
  end
end

#update_project_counter_cachesObject

rubocop: disable CodeReuse/ServiceClass


1656
1657
1658
# File 'app/models/merge_request.rb', line 1656

def update_project_counter_caches
  Projects::OpenMergeRequestsCountService.new(target_project).refresh_cache
end

#validate_branch_name(attr) ⇒ Object


846
847
848
849
850
851
852
853
854
# File 'app/models/merge_request.rb', line 846

def validate_branch_name(attr)
  return unless will_save_change_to_attribute?(attr)

  branch = read_attribute(attr)

  return unless branch

  errors.add(attr) unless Gitlab::GitRefValidator.validate_merge_request_branch(branch)
end

#validate_branchesObject


816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
# File 'app/models/merge_request.rb', line 816

def validate_branches
  return unless target_project && source_project

  if target_project == source_project && target_branch == source_branch
    errors.add :branch_conflict, "You can't use same project/branch for source and target"
    return
  end

  [:source_branch, :target_branch].each { |attr| validate_branch_name(attr) }

  if opened?
    similar_mrs = target_project
      .merge_requests
      .where(source_branch: source_branch, target_branch: target_branch)
      .where(source_project_id: source_project&.id)
      .opened

    similar_mrs = similar_mrs.where.not(id: id) if persisted?

    conflict = similar_mrs.first

    if conflict.present?
      errors.add(
        :validate_branches,
        "Another open merge request already exists for this source branch: #{conflict.to_reference}"
      )
    end
  end
end

#validate_forkObject


862
863
864
865
866
867
868
869
# File 'app/models/merge_request.rb', line 862

def validate_fork
  return true unless target_project && source_project
  return true if target_project == source_project
  return true unless source_project_missing?

  errors.add :validate_fork,
             'Source project is not a fork of the target project'
end

#validate_target_projectObject


856
857
858
859
860
# File 'app/models/merge_request.rb', line 856

def validate_target_project
  return true if target_project.merge_requests_enabled?

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

#version_params_for(diff_refs) ⇒ Object


929
930
931
932
933
934
935
936
937
938
# File 'app/models/merge_request.rb', line 929

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

#viewable_diffsObject


908
909
910
# File 'app/models/merge_request.rb', line 908

def viewable_diffs
  @viewable_diffs ||= merge_request_diffs.viewable.to_a
end

#visible_closing_issues_for(current_user = self.author) ⇒ Object


1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
# File 'app/models/merge_request.rb', line 1132

def visible_closing_issues_for(current_user = self.author)
  strong_memoize(:visible_closing_issues_for) do
    if self.target_project.has_external_issue_tracker?
      closes_issues(current_user)
    else
      cached_closes_issues.select do |issue|
        Ability.allowed?(current_user, :read_issue, issue)
      end
    end
  end
end

#wip_titleObject


1000
1001
1002
# File 'app/models/merge_request.rb', line 1000

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

#wipless_titleObject


996
997
998
# File 'app/models/merge_request.rb', line 996

def wipless_title
  self.class.wipless_title(self.title)
end

#wipless_title_changed(old_title) ⇒ Object

Verifies if title has changed not taking into account Draft prefix for merge requests.


495
496
497
# File 'app/models/merge_request.rb', line 495

def wipless_title_changed(old_title)
  self.class.wipless_title(old_title) != self.wipless_title
end

#work_in_progress?Boolean

Returns:

  • (Boolean)

992
993
994
# File 'app/models/merge_request.rb', line 992

def work_in_progress?
  self.class.work_in_progress?(title)
end