Class: Repository

Inherits:
Object
  • Object
show all
Includes:
Gitlab::ShellAdapter
Defined in:
app/models/repository.rb

Defined Under Namespace

Classes: CommitError

Constant Summary collapse

AVATAR_FILES =

Files to use as a project avatar in case no avatar was uploaded via the web UI.

%w{logo.png logo.jpg logo.gif}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Gitlab::ShellAdapter

#gitlab_shell

Constructor Details

#initialize(path_with_namespace, project) ⇒ Repository

Returns a new instance of Repository


24
25
26
27
 
# File 'app/models/repository.rb', line 24

def initialize(path_with_namespace, project)
  @path_with_namespace = path_with_namespace
  @project = project
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *args, &block) ⇒ Object 


426
427
428
429
430
431
432
433
 
# File 'app/models/repository.rb', line 426

def method_missing(m, *args, &block)
  if m == :lookup && !block_given?
    lookup_cache[m] ||= {}
    lookup_cache[m][args.join(":")] ||= raw_repository.send(m, *args, &block)
  else
    raw_repository.send(m, *args, &block)
  end
end

Instance Attribute Details

#path_with_namespace ⇒ Object

Returns the value of attribute path_with_namespace


12
13
14
 
# File 'app/models/repository.rb', line 12

def path_with_namespace
  @path_with_namespace
end

#project ⇒ Object

Returns the value of attribute project


12
13
14
 
# File 'app/models/repository.rb', line 12

def project
  @project
end

Class Method Details

.clean_old_archives ⇒ Object 


14
15
16
17
18
19
20
21
22
 
# File 'app/models/repository.rb', line 14

def self.clean_old_archives
  Gitlab::Metrics.measure(:clean_old_archives) do
    repository_downloads_path = Gitlab.config.gitlab.repository_downloads_path

    return unless File.directory?(repository_downloads_path)

    Gitlab::Popen.popen(%W(find #{repository_downloads_path} -not -path #{repository_downloads_path} -mmin +120 -delete))
  end
end

Instance Method Details

#add_branch(user, branch_name, target) ⇒ Object 


136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'app/models/repository.rb', line 136

def add_branch(user, branch_name, target)
  oldrev = Gitlab::Git::BLANK_SHA
  ref    = Gitlab::Git::BRANCH_REF_PREFIX + branch_name
  target = commit(target).try(:id)

  return false unless target

  GitHooksService.new.execute(user, path_to_repo, oldrev, target, ref) do
    rugged.branches.create(branch_name, target)
  end

  after_create_branch
  find_branch(branch_name)
end

#add_tag(user, tag_name, target, message = nil) ⇒ Object 


151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'app/models/repository.rb', line 151

def add_tag(user, tag_name, target, message = nil)
  oldrev = Gitlab::Git::BLANK_SHA
  ref    = Gitlab::Git::TAG_REF_PREFIX + tag_name
  target = commit(target).try(:id)

  return false unless target

  options = { message: message, tagger: user_to_committer(user) } if message

  GitHooksService.new.execute(user, path_to_repo, oldrev, target, ref) do
    rugged.tags.create(tag_name, target, options)
  end

  find_tag(tag_name)
end

#after_create ⇒ Object

Runs code after a repository has been created.


354
355
356
357
358
 
# File 'app/models/repository.rb', line 354

def after_create
  expire_exists_cache
  expire_root_ref_cache
  expire_emptiness_caches
end

#after_create_branch ⇒ Object

Runs code after a new branch has been created.


408
409
410
411
412
 
# File 'app/models/repository.rb', line 408

def after_create_branch
  expire_branches_cache
  expire_has_visible_content_cache
  expire_branch_count_cache
end

#after_import ⇒ Object

Runs code after a repository has been forked/imported.


397
398
399
400
 
# File 'app/models/repository.rb', line 397

def after_import
  expire_emptiness_caches
  expire_exists_cache
end

#after_push_commit(branch_name, revision) ⇒ Object

Runs code after a new commit has been pushed.


403
404
405
 
# File 'app/models/repository.rb', line 403

def after_push_commit(branch_name, revision)
  expire_cache(branch_name, revision)
end

#after_remove_branch ⇒ Object

Runs code after an existing branch has been removed.


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

def after_remove_branch
  expire_has_visible_content_cache
  expire_branch_count_cache
  expire_branches_cache
end

#avatar ⇒ Object 


969
970
971
972
973
974
975
976
977
 
# File 'app/models/repository.rb', line 969

def avatar
  return nil unless exists?

  @avatar ||= cache.fetch(:avatar) do
    AVATAR_FILES.find do |file|
      blob_at_branch('master', file)
    end
  end
end

#before_change_head ⇒ Object

Runs code just before the HEAD of a repository is changed.


372
373
374
375
376
 
# File 'app/models/repository.rb', line 372

def before_change_head
  # Cached divergent commit counts are based on repository head
  expire_branch_cache
  expire_root_ref_cache
end

#before_delete ⇒ Object

Runs code just before a repository is deleted.


361
362
363
364
365
366
367
368
369
 
# File 'app/models/repository.rb', line 361

def before_delete
  expire_exists_cache

  expire_cache if exists?

  expire_root_ref_cache
  expire_emptiness_caches
  expire_exists_cache
end

#before_import ⇒ Object 


391
392
393
394
 
# File 'app/models/repository.rb', line 391

def before_import
  expire_emptiness_caches
  expire_exists_cache
end

#before_push_tag ⇒ Object

Runs code before pushing (= creating or removing) a tag.


379
380
381
382
383
 
# File 'app/models/repository.rb', line 379

def before_push_tag
  expire_cache
  expire_tags_cache
  expire_tag_count_cache
end

#before_remove_branch ⇒ Object

Runs code before removing an existing branch.


415
416
417
 
# File 'app/models/repository.rb', line 415

def before_remove_branch
  expire_branches_cache
end

#before_remove_tag ⇒ Object

Runs code before removing a tag.


386
387
388
389
 
# File 'app/models/repository.rb', line 386

def before_remove_tag
  expire_tags_cache
  expire_tag_count_cache
end

#blob_at(sha, path) ⇒ Object 


439
440
441
442
443
 
# File 'app/models/repository.rb', line 439

def blob_at(sha, path)
  unless Gitlab::Git.blank_ref?(sha)
    Gitlab::Git::Blob.find(self, sha, path)
  end
end

#blob_at_branch(branch_name, path) ⇒ Object 


527
528
529
530
531
532
533
534
535
 
# File 'app/models/repository.rb', line 527

def blob_at_branch(branch_name, path)
  last_commit = commit(branch_name)

  if last_commit
    blob_at(last_commit.sha, path)
  else
    nil
  end
end

#blob_by_oid(oid) ⇒ Object 


445
446
447
 
# File 'app/models/repository.rb', line 445

def blob_by_oid(oid)
  Gitlab::Git::Blob.raw(self, oid)
end

#blob_for_diff(commit, diff) ⇒ Object 


608
609
610
 
# File 'app/models/repository.rb', line 608

def blob_for_diff(commit, diff)
  blob_at(commit.id, diff.file_path)
end

#branch_count ⇒ Object 


212
213
214
 
# File 'app/models/repository.rb', line 212

def branch_count
  @branch_count ||= cache.fetch(:branch_count) { branches.size }
end

#branch_names ⇒ Object 


194
195
196
 
# File 'app/models/repository.rb', line 194

def branch_names
  cache.fetch(:branch_names) { branches.map(&:name) }
end

#branch_names_contains(sha) ⇒ Object 


635
636
637
 
# File 'app/models/repository.rb', line 635

def branch_names_contains(sha)
  refs_contains_sha('branch', sha)
end

#branches_sorted_by(value) ⇒ Object

Remove archives older than 2 hours


574
575
576
577
578
579
580
581
582
583
584
585
586
587
 
# File 'app/models/repository.rb', line 574

def branches_sorted_by(value)
  case value
  when 'recently_updated'
    branches.sort do |a, b|
      commit(b.target).committed_date <=> commit(a.target).committed_date
    end
  when 'last_updated'
    branches.sort do |a, b|
      commit(a.target).committed_date <=> commit(b.target).committed_date
    end
  else
    branches
  end
end

#build_cache ⇒ Object 


247
248
249
250
251
252
253
 
# File 'app/models/repository.rb', line 247

def build_cache
  cache_keys.each do |key|
    unless cache.exist?(key)
      send(key)
    end
  end
end

#cache_keys ⇒ Object 


241
242
243
244
245
 
# File 'app/models/repository.rb', line 241

def cache_keys
  %i(size branch_names tag_names commit_count
     readme version contribution_guide changelog
     license_blob license_key)
end

#can_be_merged?(source_sha, target_branch) ⇒ Boolean

Returns:

  • (Boolean) 

723
724
725
726
727
728
729
730
731
732
 
# File 'app/models/repository.rb', line 723

def can_be_merged?(source_sha, target_branch)
  our_commit = rugged.branches[target_branch].target
  their_commit = rugged.lookup(source_sha)

  if our_commit && their_commit
    !rugged.merge_commits(our_commit, their_commit).conflicts?
  else
    false
  end
end

#changelog ⇒ Object 


469
470
471
472
473
474
475
 
# File 'app/models/repository.rb', line 469

def changelog
  cache.fetch(:changelog) do
    tree(:head).blobs.find do |file|
      file.name =~ /\A(changelog|history|changes|news)/i
    end
  end
end

#check_cherry_pick_content(commit, base_branch) ⇒ Object 


809
810
811
812
813
814
815
816
817
818
819
820
821
 
# File 'app/models/repository.rb', line 809

def check_cherry_pick_content(commit, base_branch)
  source_sha = find_branch(base_branch).target
  args       = [commit.id, source_sha]
  args       << 1 if commit.merge_commit?

  cherry_pick_index = rugged.cherrypick_commit(*args)
  return false if cherry_pick_index.conflicts?

  tree_id = cherry_pick_index.write_tree(rugged)
  return false unless diff_exists?(source_sha, tree_id)

  tree_id
end

#check_revert_content(commit, base_branch) ⇒ Object 


795
796
797
798
799
800
801
802
803
804
805
806
807
 
# File 'app/models/repository.rb', line 795

def check_revert_content(commit, base_branch)
  source_sha = find_branch(base_branch).target
  args       = [commit.id, source_sha]
  args       << { mainline: 1 } if commit.merge_commit?

  revert_index = rugged.revert_commit(*args)
  return false if revert_index.conflicts?

  tree_id = revert_index.write_tree(rugged)
  return false unless diff_exists?(source_sha, tree_id)

  tree_id
end

#cherry_pick(user, commit, base_branch, cherry_pick_tree_id = nil) ⇒ Object 


773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
 
# File 'app/models/repository.rb', line 773

def cherry_pick(user, commit, base_branch, cherry_pick_tree_id = nil)
  source_sha = find_branch(base_branch).target
  cherry_pick_tree_id ||= check_cherry_pick_content(commit, base_branch)

  return false unless cherry_pick_tree_id

  commit_with_hooks(user, base_branch) do |ref|
    committer = user_to_committer(user)
    source_sha = Rugged::Commit.create(rugged,
      message: commit.message,
      author: {
        email: commit.author_email,
        name: commit.author_name,
        time: commit.authored_date
      },
      committer: committer,
      tree: cherry_pick_tree_id,
      parents: [rugged.lookup(source_sha)],
      update_ref: ref)
  end
end

#commit(id = 'HEAD') ⇒ Object 


81
82
83
84
85
86
87
88
 
# File 'app/models/repository.rb', line 81

def commit(id = 'HEAD')
  return nil unless exists?
  commit = Gitlab::Git::Commit.find(raw_repository, id)
  commit = Commit.new(commit, @project) if commit
  commit
rescue Rugged::OdbError
  nil
end

#commit_count ⇒ Object 


202
203
204
205
206
207
208
209
210
 
# File 'app/models/repository.rb', line 202

def commit_count
  cache.fetch(:commit_count) do
    begin
      raw_repository.commit_count(self.root_ref)
    rescue
      0
    end
  end
end

#commit_dir(user, path, message, branch) ⇒ Object 


659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
 
# File 'app/models/repository.rb', line 659

def commit_dir(user, path, message, branch)
  commit_with_hooks(user, branch) do |ref|
    committer = user_to_committer(user)
    options = {}
    options[:committer] = committer
    options[:author] = committer

    options[:commit] = {
      message: message,
      branch: ref,
    }

    raw_repository.mkdir(path, options)
  end
end

#commit_file(user, path, content, message, branch, update) ⇒ Object 


675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
 
# File 'app/models/repository.rb', line 675

def commit_file(user, path, content, message, branch, update)
  commit_with_hooks(user, branch) do |ref|
    committer = user_to_committer(user)
    options = {}
    options[:committer] = committer
    options[:author] = committer
    options[:commit] = {
      message: message,
      branch: ref,
    }

    options[:file] = {
      content: content,
      path: path,
      update: update
    }

    Gitlab::Git::Blob.commit(raw_repository, options)
  end
end

#commit_with_hooks(current_user, branch) ⇒ Object 


907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
 
# File 'app/models/repository.rb', line 907

def commit_with_hooks(current_user, branch)
  update_autocrlf_option

  oldrev = Gitlab::Git::BLANK_SHA
  ref = Gitlab::Git::BRANCH_REF_PREFIX + branch
  target_branch = find_branch(branch)
  was_empty = empty?

  if !was_empty && target_branch
    oldrev = target_branch.target
  end

  with_tmp_ref(oldrev) do |tmp_ref|
    # Make commit in tmp ref
    newrev = yield(tmp_ref)

    unless newrev
      raise CommitError.new('Failed to create commit')
    end

    GitHooksService.new.execute(current_user, path_to_repo, oldrev, newrev, ref) do
      if was_empty || !target_branch
        # Create branch
        rugged.references.create(ref, newrev)
      else
        # Update head
        current_head = find_branch(branch).target

        # Make sure target branch was not changed during pre-receive hook
        if current_head == oldrev
          rugged.references.update(ref, newrev)
        else
          raise CommitError.new('Commit was rejected because branch received new push')
        end
      end
    end

    newrev
  end
end

#commits(ref, path: nil, limit: nil, offset: nil, skip_merges: false, after: nil, before: nil) ⇒ Object 


90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'app/models/repository.rb', line 90

def commits(ref, path: nil, limit: nil, offset: nil, skip_merges: false, after: nil, before: nil)
  options = {
    repo: raw_repository,
    ref: ref,
    path: path,
    limit: limit,
    offset: offset,
    after: after,
    before: before,
    # --follow doesn't play well with --skip. See:
    # https://gitlab.com/gitlab-org/gitlab-ce/issues/3574#note_3040520
    follow: false,
    skip_merges: skip_merges
  }

  commits = Gitlab::Git::Commit.where(options)
  commits = Commit.decorate(commits, @project) if commits.present?
  commits
end

#commits_between(from, to) ⇒ Object 


110
111
112
113
114
 
# File 'app/models/repository.rb', line 110

def commits_between(from, to)
  commits = Gitlab::Git::Commit.between(raw_repository, from, to)
  commits = Commit.decorate(commits, @project) if commits.present?
  commits
end

#contribution_guide ⇒ Object 


461
462
463
464
465
466
467
 
# File 'app/models/repository.rb', line 461

def contribution_guide
  cache.fetch(:contribution_guide) do
    tree(:head).blobs.find do |file|
      file.contributing?
    end
  end
end

#contributors ⇒ Object 


589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
 
# File 'app/models/repository.rb', line 589

def contributors
  commits = self.commits(nil, limit: 2000, offset: 0, skip_merges: true)

  commits.group_by(&:author_email).map do |email, commits|
    contributor = Gitlab::Contributor.new
    contributor.email = email

    commits.each do |commit|
      if contributor.name.blank?
        contributor.name = commit.author_name
      end

      contributor.commits += 1
    end

    contributor
  end
end

#copy_gitattributes(ref) ⇒ Object 


953
954
955
956
957
958
959
960
961
 
# File 'app/models/repository.rb', line 953

def copy_gitattributes(ref)
  actual_ref = ref || root_ref
  begin
    raw_repository.copy_gitattributes(actual_ref)
    true
  rescue Gitlab::Git::Repository::InvalidRef
    false
  end
end

#diff_exists?(sha1, sha2) ⇒ Boolean

Returns:

  • (Boolean) 

823
824
825
 
# File 'app/models/repository.rb', line 823

def diff_exists?(sha1, sha2)
  rugged.diff(sha1, sha2).size > 0
end

#diverging_commit_counts(branch) ⇒ Object 


226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'app/models/repository.rb', line 226

def diverging_commit_counts(branch)
  root_ref_hash = raw_repository.rev_parse_target(root_ref).oid
  cache.fetch(:"diverging_commit_counts_#{branch.name}") do
    # Rugged seems to throw a `ReferenceError` when given branch_names rather
    # than SHA-1 hashes
    number_commits_behind = raw_repository.
      count_commits_between(branch.target, root_ref_hash)

    number_commits_ahead = raw_repository.
      count_commits_between(root_ref_hash, branch.target)

    { behind: number_commits_behind, ahead: number_commits_ahead }
  end
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 

58
59
60
61
62
 
# File 'app/models/repository.rb', line 58

def empty?
  return @empty unless @empty.nil?

  @empty = cache.fetch(:empty?) { raw_repository.empty? }
end

#exists? ⇒ Boolean

Returns:

  • (Boolean) 

46
47
48
49
50
51
52
53
54
55
56
 
# File 'app/models/repository.rb', line 46

def exists?
  return @exists unless @exists.nil?

  @exists = cache.fetch(:exists?) do
    begin
      raw_repository && raw_repository.rugged ? true : false
    rescue Gitlab::Git::Repository::NoRepository
      false
    end
  end
end

#expire_avatar_cache(branch_name = nil, revision = nil) ⇒ Object 


331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'app/models/repository.rb', line 331

def expire_avatar_cache(branch_name = nil, revision = nil)
  # Avatars are pulled from the default branch, thus if somebody pushes to a
  # different branch there's no need to expire anything.
  return if branch_name && branch_name != root_ref

  # We don't want to flush the cache if the commit didn't actually make any
  # changes to any of the possible avatar files.
  if revision && commit = self.commit(revision)
    return unless commit.diffs.
      any? { |diff| AVATAR_FILES.include?(diff.new_path) }
  end

  cache.expire(:avatar)

  @avatar = nil
end

#expire_branch_cache(branch_name = nil) ⇒ Object 


280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'app/models/repository.rb', line 280

def expire_branch_cache(branch_name = nil)
  # When we push to the root branch we have to flush the cache for all other
  # branches as their statistics are based on the commits relative to the
  # root branch.
  if !branch_name || branch_name == root_ref
    branches.each do |branch|
      cache.expire(:"diverging_commit_counts_#{branch.name}")
    end
  # In case a commit is pushed to a non-root branch we only have to flush the
  # cache for said branch.
  else
    cache.expire(:"diverging_commit_counts_#{branch_name}")
  end
end

#expire_branch_count_cache ⇒ Object 


313
314
315
316
 
# File 'app/models/repository.rb', line 313

def expire_branch_count_cache
  cache.expire(:branch_count)
  @branch_count = nil
end

#expire_branch_names ⇒ Object 


327
328
329
 
# File 'app/models/repository.rb', line 327

def expire_branch_names
  cache.expire(:branch_names)
end

#expire_branches_cache ⇒ Object 


260
261
262
263
 
# File 'app/models/repository.rb', line 260

def expire_branches_cache
  cache.expire(:branch_names)
  @local_branches = nil
end

#expire_cache(branch_name = nil, revision = nil) ⇒ Object 


265
266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'app/models/repository.rb', line 265

def expire_cache(branch_name = nil, revision = nil)
  cache_keys.each do |key|
    cache.expire(key)
  end

  expire_branch_cache(branch_name)
  expire_avatar_cache(branch_name, revision)

  # This ensures this particular cache is flushed after the first commit to a
  # new repository.
  expire_emptiness_caches if empty?
  expire_branch_count_cache
  expire_tag_count_cache
end

#expire_emptiness_caches ⇒ Object

Expires the cache(s) used to determine if a repository is empty or not.


301
302
303
304
305
306
 
# File 'app/models/repository.rb', line 301

def expire_emptiness_caches
  cache.expire(:empty?)
  @empty = nil

  expire_has_visible_content_cache
end

#expire_exists_cache ⇒ Object 


348
349
350
351
 
# File 'app/models/repository.rb', line 348

def expire_exists_cache
  cache.expire(:exists?)
  @exists = nil
end

#expire_has_visible_content_cache ⇒ Object 


308
309
310
311
 
# File 'app/models/repository.rb', line 308

def expire_has_visible_content_cache
  cache.expire(:has_visible_content?)
  @has_visible_content = nil
end

#expire_root_ref_cache ⇒ Object 


295
296
297
298
 
# File 'app/models/repository.rb', line 295

def expire_root_ref_cache
  cache.expire(:root_ref)
  @root_ref = nil
end

#expire_tag_count_cache ⇒ Object 


318
319
320
321
 
# File 'app/models/repository.rb', line 318

def expire_tag_count_cache
  cache.expire(:tag_count)
  @tag_count = nil
end

#expire_tags_cache ⇒ Object 


255
256
257
258
 
# File 'app/models/repository.rb', line 255

def expire_tags_cache
  cache.expire(:tag_names)
  @tags = nil
end

#fetch_ref(source_path, source_ref, target_ref) ⇒ Object 


888
889
890
891
 
# File 'app/models/repository.rb', line 888

def fetch_ref(source_path, source_ref, target_ref)
  args = %W(#{Gitlab.config.git.bin_path} fetch --no-tags -f #{source_path} #{source_ref}:#{target_ref})
  Gitlab::Popen.popen(args, path_to_repo)
end

#find_branch(name) ⇒ Object 


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

def find_branch(name)
  raw_repository.branches.find { |branch| branch.name == name }
end

#find_commits_by_message(query, ref = nil, path = nil, limit = 1000, offset = 0) ⇒ Object 


116
117
118
119
120
121
122
123
124
125
126
 
# File 'app/models/repository.rb', line 116

def find_commits_by_message(query, ref = nil, path = nil, limit = 1000, offset = 0)
  ref ||= root_ref

  # Limited to 1000 commits for now, could be parameterized?
  args = %W(#{Gitlab.config.git.bin_path} log #{ref} --pretty=%H --skip #{offset} --max-count #{limit} --grep=#{query})
  args = args.concat(%W(-- #{path})) if path.present?

  git_log_results = Gitlab::Popen.popen(args, path_to_repo).first.lines.map(&:chomp)
  commits = git_log_results.map { |c| commit(c) }
  commits
end

#find_tag(name) ⇒ Object 


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

def find_tag(name)
  raw_repository.tags.find { |tag| tag.name == name }
end

#gitlab_ci_yml ⇒ Object 


495
496
497
498
499
500
501
502
503
504
505
 
# File 'app/models/repository.rb', line 495

def gitlab_ci_yml
  return nil if !exists? || empty?

  @gitlab_ci_yml ||= tree(:head).blobs.find do |file|
    file.name == '.gitlab-ci.yml'
  end
rescue Rugged::ReferenceError
  # For unknow reason spinach scenario "Scenario: I change project path"
  # lead to "Reference 'HEAD' not found" exception from Repository#empty?
  nil
end

#has_visible_content? ⇒ Boolean

Git repository can contains some hidden refs like:

/refs/notes/*
/refs/git-as-svn/*
/refs/pulls/*

This refs by default not visible in project page and not cloned to client side.

This method return true if repository contains some content visible in project page.

Returns:

  • (Boolean) 

73
74
75
76
77
78
79
 
# File 'app/models/repository.rb', line 73

def has_visible_content?
  return @has_visible_content unless @has_visible_content.nil?

  @has_visible_content = cache.fetch(:has_visible_content?) do
    branch_count > 0
  end
end

#head_commit ⇒ Object 


507
508
509
 
# File 'app/models/repository.rb', line 507

def head_commit
  @head_commit ||= commit(self.root_ref)
end

#head_tree ⇒ Object 


511
512
513
 
# File 'app/models/repository.rb', line 511

def head_tree
  @head_tree ||= Tree.new(self, head_commit.sha, nil)
end

#is_ancestor?(ancestor_id, descendant_id) ⇒ Boolean

Returns:

  • (Boolean) 

846
847
848
 
# File 'app/models/repository.rb', line 846

def is_ancestor?(ancestor_id, descendant_id)
  merge_base(ancestor_id, descendant_id) == ancestor_id
end

#last_commit_for_path(sha, path) ⇒ Object 


553
554
555
556
557
 
# File 'app/models/repository.rb', line 553

def last_commit_for_path(sha, path)
  args = %W(#{Gitlab.config.git.bin_path} rev-list --max-count=1 #{sha} -- #{path})
  sha = Gitlab::Popen.popen(args, path_to_repo).first.strip
  commit(sha)
end

#license_blob ⇒ Object 


477
478
479
480
481
482
483
484
485
 
# File 'app/models/repository.rb', line 477

def license_blob
  return nil if !exists? || empty?

  cache.fetch(:license_blob) do
    tree(:head).blobs.find do |file|
      file.name =~ /\A(licen[sc]e|copying)(\..+|\z)/i
    end
  end
end

#license_key ⇒ Object 


487
488
489
490
491
492
493
 
# File 'app/models/repository.rb', line 487

def license_key
  return nil if !exists? || empty?

  cache.fetch(:license_key) do
    Licensee.license(path).try(:key)
  end
end

#local_branches ⇒ Object Also known as: branches 


643
644
645
646
647
 
# File 'app/models/repository.rb', line 643

def local_branches
  @local_branches ||= rugged.branches.each(:local).map do |branch|
    Gitlab::Git::Branch.new(branch.name, branch.target)
  end
end

#lookup_cache ⇒ Object 


323
324
325
 
# File 'app/models/repository.rb', line 323

def lookup_cache
  @lookup_cache ||= {}
end

#ls_files(ref) ⇒ Object 


948
949
950
951
 
# File 'app/models/repository.rb', line 948

def ls_files(ref)
  actual_ref = ref || root_ref
  raw_repository.ls_files(actual_ref)
end

#main_language ⇒ Object 


963
964
965
966
967
 
# File 'app/models/repository.rb', line 963

def main_language
  return if empty? || rugged.head_unborn?

  Linguist::Repository.new(rugged, rugged.head.target_id).language
end

#merge(user, source_sha, target_branch, options = {}) ⇒ Object 


734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
 
# File 'app/models/repository.rb', line 734

def merge(user, source_sha, target_branch, options = {})
  our_commit = rugged.branches[target_branch].target
  their_commit = rugged.lookup(source_sha)

  raise "Invalid merge target" if our_commit.nil?
  raise "Invalid merge source" if their_commit.nil?

  merge_index = rugged.merge_commits(our_commit, their_commit)
  return false if merge_index.conflicts?

  commit_with_hooks(user, target_branch) do |ref|
    actual_options = options.merge(
      parents: [our_commit, their_commit],
      tree: merge_index.write_tree(rugged),
      update_ref: ref
    )

    Rugged::Commit.create(rugged, actual_options)
  end
end

#merge_base(first_commit_id, second_commit_id) ⇒ Object 


838
839
840
841
842
843
844
 
# File 'app/models/repository.rb', line 838

def merge_base(first_commit_id, second_commit_id)
  first_commit_id = commit(first_commit_id).try(:id) || first_commit_id
  second_commit_id = commit(second_commit_id).try(:id) || second_commit_id
  rugged.merge_base(first_commit_id, second_commit_id)
rescue Rugged::ReferenceError
  nil
end

#merged_to_root_ref?(branch_name) ⇒ Boolean

Returns:

  • (Boolean) 

827
828
829
830
831
832
833
834
835
836
 
# File 'app/models/repository.rb', line 827

def merged_to_root_ref?(branch_name)
  branch_commit = commit(branch_name)
  root_ref_commit = commit(root_ref)

  if branch_commit
    is_ancestor?(branch_commit.id, root_ref_commit.id)
  else
    nil
  end
end

#next_branch(name, opts = {}) ⇒ Object 


559
560
561
562
563
564
565
566
567
568
569
570
571
 
# File 'app/models/repository.rb', line 559

def next_branch(name, opts={})
  branch_ids = self.branch_names.map do |n|
    next 1 if n == name
    result = n.match(/\A#{name}-([0-9]+)\z/)
    result[1].to_i if result
  end.compact

  highest_branch_id = branch_ids.max || 0

  return name if opts[:mild] && 0 == highest_branch_id

  "#{name}-#{highest_branch_id + 1}"
end

#parse_search_result(result) ⇒ Object 


857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
 
# File 'app/models/repository.rb', line 857

def parse_search_result(result)
  ref = nil
  filename = nil
  basename = nil
  startline = 0

  result.each_line.each_with_index do |line, index|
    if line =~ /^.*:.*:\d+:/
      ref, filename, startline = line.split(':')
      startline = startline.to_i - index
      extname = File.extname(filename)
      basename = filename.sub(/#{extname}$/, '')
      break
    end
  end

  data = ""

  result.each_line do |line|
    data << line.sub(ref, '').sub(filename, '').sub(/^:-\d+-/, '').sub(/^::\d+:/, '')
  end

  OpenStruct.new(
    filename: filename,
    basename: basename,
    ref: ref,
    startline: startline,
    data: data
  )
end

#path_to_repo ⇒ Object

Return absolute path to repository


40
41
42
43
44
 
# File 'app/models/repository.rb', line 40

def path_to_repo
  @path_to_repo ||= File.expand_path(
    File.join(Gitlab.config.gitlab_shell.repos_path, path_with_namespace + ".git")
  )
end

#prev_blob_for_diff(commit, diff) ⇒ Object 


612
613
614
615
616
 
# File 'app/models/repository.rb', line 612

def prev_blob_for_diff(commit, diff)
  if commit.parent_id
    blob_at(commit.parent_id, diff.old_path)
  end
end

#raw_repository ⇒ Object 


29
30
31
32
33
 
# File 'app/models/repository.rb', line 29

def raw_repository
  return nil unless path_with_namespace

  @raw_repository ||= Gitlab::Git::Repository.new(path_to_repo)
end

#readme ⇒ Object 


449
450
451
 
# File 'app/models/repository.rb', line 449

def readme
  cache.fetch(:readme) { tree(:head).readme }
end

#refs_contains_sha(ref_type, sha) ⇒ Object 


618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
 
# File 'app/models/repository.rb', line 618

def refs_contains_sha(ref_type, sha)
  args = %W(#{Gitlab.config.git.bin_path} #{ref_type} --contains #{sha})
  names = Gitlab::Popen.popen(args, path_to_repo).first

  if names.respond_to?(:split)
    names = names.split("\n").map(&:strip)

    names.each do |name|
      name.slice! '* '
    end

    names
  else
    []
  end
end

#remove_file(user, path, message, branch) ⇒ Object 


696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
 
# File 'app/models/repository.rb', line 696

def remove_file(user, path, message, branch)
  commit_with_hooks(user, branch) do |ref|
    committer = user_to_committer(user)
    options = {}
    options[:committer] = committer
    options[:author] = committer
    options[:commit] = {
      message: message,
      branch: ref
    }

    options[:file] = {
      path: path
    }

    Gitlab::Git::Blob.remove(raw_repository, options)
  end
end

#respond_to_missing?(method, include_private = false) ⇒ Boolean

Returns:

  • (Boolean) 

435
436
437
 
# File 'app/models/repository.rb', line 435

def respond_to_missing?(method, include_private = false)
  raw_repository.respond_to?(method, include_private) || super
end

#revert(user, commit, base_branch, revert_tree_id = nil) ⇒ Object 


755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
 
# File 'app/models/repository.rb', line 755

def revert(user, commit, base_branch, revert_tree_id = nil)
  source_sha = find_branch(base_branch).target
  revert_tree_id ||= check_revert_content(commit, base_branch)

  return false unless revert_tree_id

  commit_with_hooks(user, base_branch) do |ref|
    committer = user_to_committer(user)
    source_sha = Rugged::Commit.create(rugged,
      message: commit.revert_message,
      author: committer,
      committer: committer,
      tree: revert_tree_id,
      parents: [rugged.lookup(source_sha)],
      update_ref: ref)
  end
end

#rm_branch(user, branch_name) ⇒ Object 


167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'app/models/repository.rb', line 167

def rm_branch(user, branch_name)
  before_remove_branch

  branch = find_branch(branch_name)
  oldrev = branch.try(:target)
  newrev = Gitlab::Git::BLANK_SHA
  ref    = Gitlab::Git::BRANCH_REF_PREFIX + branch_name

  GitHooksService.new.execute(user, path_to_repo, oldrev, newrev, ref) do
    rugged.branches.delete(branch_name)
  end

  after_remove_branch
  true
end

#rm_tag(tag_name) ⇒ Object 


183
184
185
186
187
188
189
190
191
192
 
# File 'app/models/repository.rb', line 183

def rm_tag(tag_name)
  before_remove_tag

  begin
    rugged.tags.delete(tag_name)
    true
  rescue Rugged::ReferenceError
    false
  end
end

#root_ref ⇒ Object 


655
656
657
 
# File 'app/models/repository.rb', line 655

def root_ref
  @root_ref ||= cache.fetch(:root_ref) { raw_repository.root_ref }
end

#search_files(query, ref) ⇒ Object 


851
852
853
854
855
 
# File 'app/models/repository.rb', line 851

def search_files(query, ref)
  offset = 2
  args = %W(#{Gitlab.config.git.bin_path} grep -i -I -n --before-context #{offset} --after-context #{offset} -e #{Regexp.escape(query)} #{ref || root_ref})
  Gitlab::Popen.popen(args, path_to_repo).first.scrub.split(/^--$/)
end

#size ⇒ Object

Return repo size in megabytes Cached in redis


222
223
224
 
# File 'app/models/repository.rb', line 222

def size
  cache.fetch(:size) { raw_repository.size }
end

#submodule_url_for(ref, path) ⇒ Object

Returns url for submodule

Ex.

@repository.submodule_url_for('master', 'rack')
# => [email protected]:rack.git


543
544
545
546
547
548
549
550
551
 
# File 'app/models/repository.rb', line 543

def submodule_url_for(ref, path)
  if submodules(ref).any?
    submodule = submodules(ref)[path]

    if submodule
      submodule['url']
    end
  end
end

#tag_count ⇒ Object 


216
217
218
 
# File 'app/models/repository.rb', line 216

def tag_count
  @tag_count ||= cache.fetch(:tag_count) { raw_repository.rugged.tags.count }
end

#tag_names ⇒ Object 


198
199
200
 
# File 'app/models/repository.rb', line 198

def tag_names
  cache.fetch(:tag_names) { raw_repository.tag_names }
end

#tag_names_contains(sha) ⇒ Object 


639
640
641
 
# File 'app/models/repository.rb', line 639

def tag_names_contains(sha)
  refs_contains_sha('tag', sha)
end

#tags ⇒ Object 


651
652
653
 
# File 'app/models/repository.rb', line 651

def tags
  @tags ||= raw_repository.tags
end

#tree(sha = :head, path = nil) ⇒ Object 


515
516
517
518
519
520
521
522
523
524
525
 
# File 'app/models/repository.rb', line 515

def tree(sha = :head, path = nil)
  if sha == :head
    if path.nil?
      return head_tree
    else
      sha = head_commit.sha
    end
  end

  Tree.new(self, sha, path)
end

#update_autocrlf_option ⇒ Object 


35
36
37
 
# File 'app/models/repository.rb', line 35

def update_autocrlf_option
  raw_repository.autocrlf = :input if raw_repository.autocrlf != :input
end

#user_to_committer(user) ⇒ Object 


715
716
717
718
719
720
721
 
# File 'app/models/repository.rb', line 715

def user_to_committer(user)
  {
    email: user.email,
    name: user.name,
    time: Time.now
  }
end

#version ⇒ Object 


453
454
455
456
457
458
459
 
# File 'app/models/repository.rb', line 453

def version
  cache.fetch(:version) do
    tree(:head).blobs.find do |file|
      file.name.downcase == 'version'
    end
  end
end

#with_tmp_ref(oldrev = nil) ⇒ Object 


893
894
895
896
897
898
899
900
901
902
903
904
905
 
# File 'app/models/repository.rb', line 893

def with_tmp_ref(oldrev = nil)
  random_string = SecureRandom.hex
  tmp_ref = "refs/tmp/#{random_string}/head"

  if oldrev && !Gitlab::Git.blank_ref?(oldrev)
    rugged.references.create(tmp_ref, oldrev)
  end

  # Make commit in tmp ref
  yield(tmp_ref)
ensure
  rugged.references.delete(tmp_ref) rescue nil
end