debian-mirror-gitlab/app/models/repository.rb

421 lines
8.7 KiB
Ruby
Raw Normal View History

2014-09-02 18:07:02 +05:30
class Repository
include Gitlab::ShellAdapter
2015-09-11 14:41:01 +05:30
attr_accessor :raw_repository, :path_with_namespace, :project
2014-09-02 18:07:02 +05:30
2015-09-11 14:41:01 +05:30
def initialize(path_with_namespace, default_branch = nil, project = nil)
2014-09-02 18:07:02 +05:30
@path_with_namespace = path_with_namespace
2015-09-11 14:41:01 +05:30
@project = project
if path_with_namespace
@raw_repository = Gitlab::Git::Repository.new(path_to_repo)
@raw_repository.autocrlf = :input
end
2014-09-02 18:07:02 +05:30
rescue Gitlab::Git::Repository::NoRepository
nil
end
# Return absolute path to repository
def path_to_repo
@path_to_repo ||= File.expand_path(
File.join(Gitlab.config.gitlab_shell.repos_path, path_with_namespace + ".git")
)
end
def exists?
raw_repository
end
def empty?
raw_repository.empty?
end
2015-04-26 12:48:37 +05:30
def commit(id = 'HEAD')
2014-09-02 18:07:02 +05:30
return nil unless raw_repository
commit = Gitlab::Git::Commit.find(raw_repository, id)
2015-09-11 14:41:01 +05:30
commit = Commit.new(commit, @project) if commit
2014-09-02 18:07:02 +05:30
commit
2015-04-26 12:48:37 +05:30
rescue Rugged::OdbError
nil
2014-09-02 18:07:02 +05:30
end
2015-04-26 12:48:37 +05:30
def commits(ref, path = nil, limit = nil, offset = nil, skip_merges = false)
2014-09-02 18:07:02 +05:30
commits = Gitlab::Git::Commit.where(
repo: raw_repository,
ref: ref,
path: path,
limit: limit,
offset: offset,
)
2015-09-11 14:41:01 +05:30
commits = Commit.decorate(commits, @project) if commits.present?
2014-09-02 18:07:02 +05:30
commits
end
def commits_between(from, to)
commits = Gitlab::Git::Commit.between(raw_repository, from, to)
2015-09-11 14:41:01 +05:30
commits = Commit.decorate(commits, @project) if commits.present?
2014-09-02 18:07:02 +05:30
commits
end
def find_branch(name)
branches.find { |branch| branch.name == name }
end
def find_tag(name)
tags.find { |tag| tag.name == name }
end
def add_branch(branch_name, ref)
2015-04-26 12:48:37 +05:30
cache.expire(:branch_names)
@branches = nil
2014-09-02 18:07:02 +05:30
gitlab_shell.add_branch(path_with_namespace, branch_name, ref)
end
2015-04-26 12:48:37 +05:30
def add_tag(tag_name, ref, message = nil)
cache.expire(:tag_names)
@tags = nil
2014-09-02 18:07:02 +05:30
2015-04-26 12:48:37 +05:30
gitlab_shell.add_tag(path_with_namespace, tag_name, ref, message)
2014-09-02 18:07:02 +05:30
end
def rm_branch(branch_name)
2015-04-26 12:48:37 +05:30
cache.expire(:branch_names)
@branches = nil
2014-09-02 18:07:02 +05:30
gitlab_shell.rm_branch(path_with_namespace, branch_name)
end
def rm_tag(tag_name)
2015-04-26 12:48:37 +05:30
cache.expire(:tag_names)
@tags = nil
2014-09-02 18:07:02 +05:30
gitlab_shell.rm_tag(path_with_namespace, tag_name)
end
def branch_names
2015-04-26 12:48:37 +05:30
cache.fetch(:branch_names) { raw_repository.branch_names }
2014-09-02 18:07:02 +05:30
end
def tag_names
2015-04-26 12:48:37 +05:30
cache.fetch(:tag_names) { raw_repository.tag_names }
2014-09-02 18:07:02 +05:30
end
def commit_count
2015-04-26 12:48:37 +05:30
cache.fetch(:commit_count) do
2014-09-02 18:07:02 +05:30
begin
raw_repository.commit_count(self.root_ref)
rescue
0
end
end
end
# Return repo size in megabytes
# Cached in redis
def size
2015-04-26 12:48:37 +05:30
cache.fetch(:size) { raw_repository.size }
2014-09-02 18:07:02 +05:30
end
2015-09-11 14:41:01 +05:30
def cache_keys
%i(size branch_names tag_names commit_count
readme version contribution_guide changelog license)
end
def build_cache
cache_keys.each do |key|
unless cache.exist?(key)
send(key)
end
end
end
2014-09-02 18:07:02 +05:30
def expire_cache
2015-09-11 14:41:01 +05:30
cache_keys.each do |key|
2015-04-26 12:48:37 +05:30
cache.expire(key)
end
2014-09-02 18:07:02 +05:30
end
2015-09-11 14:41:01 +05:30
def rebuild_cache
cache_keys.each do |key|
cache.expire(key)
send(key)
2014-09-02 18:07:02 +05:30
end
end
2015-04-26 12:48:37 +05:30
def lookup_cache
@lookup_cache ||= {}
2014-09-02 18:07:02 +05:30
end
2015-09-11 14:41:01 +05:30
def expire_branch_names
cache.expire(:branch_names)
end
2014-09-02 18:07:02 +05:30
def method_missing(m, *args, &block)
2015-04-26 12:48:37 +05:30
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
2014-09-02 18:07:02 +05:30
end
2015-09-11 14:41:01 +05:30
def respond_to_missing?(method, include_private = false)
raw_repository.respond_to?(method, include_private) || super
2014-09-02 18:07:02 +05:30
end
def blob_at(sha, path)
2015-09-11 14:41:01 +05:30
unless Gitlab::Git.blank_ref?(sha)
Gitlab::Git::Blob.find(self, sha, path)
end
2014-09-02 18:07:02 +05:30
end
def blob_by_oid(oid)
Gitlab::Git::Blob.raw(self, oid)
end
def readme
2015-04-26 12:48:37 +05:30
cache.fetch(:readme) { tree(:head).readme }
2014-09-02 18:07:02 +05:30
end
def version
2015-04-26 12:48:37 +05:30
cache.fetch(:version) do
2014-09-02 18:07:02 +05:30
tree(:head).blobs.find do |file|
file.name.downcase == 'version'
end
end
end
def contribution_guide
2015-04-26 12:48:37 +05:30
cache.fetch(:contribution_guide) do
tree(:head).blobs.find do |file|
file.contributing?
end
end
end
def changelog
cache.fetch(:changelog) do
tree(:head).blobs.find do |file|
file.name =~ /\A(changelog|history)/i
end
end
end
def license
cache.fetch(:license) do
tree(:head).blobs.find do |file|
file.name =~ /\Alicense/i
end
2014-09-02 18:07:02 +05:30
end
end
def head_commit
2015-04-26 12:48:37 +05:30
@head_commit ||= commit(self.root_ref)
end
def head_tree
@head_tree ||= Tree.new(self, head_commit.sha, nil)
2014-09-02 18:07:02 +05:30
end
def tree(sha = :head, path = nil)
if sha == :head
2015-04-26 12:48:37 +05:30
if path.nil?
return head_tree
else
sha = head_commit.sha
end
2014-09-02 18:07:02 +05:30
end
Tree.new(self, sha, path)
end
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
# Returns url for submodule
#
# Ex.
# @repository.submodule_url_for('master', 'rack')
# # => git@localhost:rack.git
#
def submodule_url_for(ref, path)
if submodules(ref).any?
submodule = submodules(ref)[path]
if submodule
submodule['url']
end
end
end
def last_commit_for_path(sha, path)
2015-04-26 12:48:37 +05:30
args = %W(git rev-list --max-count=1 #{sha} -- #{path})
sha = Gitlab::Popen.popen(args, path_to_repo).first.strip
commit(sha)
2014-09-02 18:07:02 +05:30
end
# Remove archives older than 2 hours
def clean_old_archives
2015-04-26 12:48:37 +05:30
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))
2014-09-02 18:07:02 +05:30
end
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
def contributors
2015-04-26 12:48:37 +05:30
commits = self.commits(nil, nil, 2000, 0, true)
2014-09-02 18:07:02 +05:30
2015-04-26 12:48:37 +05:30
commits.group_by(&:author_email).map do |email, commits|
2014-09-02 18:07:02 +05:30
contributor = Gitlab::Contributor.new
contributor.email = email
2015-04-26 12:48:37 +05:30
commits.each do |commit|
2014-09-02 18:07:02 +05:30
if contributor.name.blank?
2015-04-26 12:48:37 +05:30
contributor.name = commit.author_name
2014-09-02 18:07:02 +05:30
end
contributor.commits += 1
end
contributor
end
end
def blob_for_diff(commit, diff)
file = blob_at(commit.id, diff.new_path)
unless file
file = prev_blob_for_diff(commit, diff)
end
file
end
def prev_blob_for_diff(commit, diff)
if commit.parent_id
blob_at(commit.parent_id, diff.old_path)
end
end
2015-04-26 12:48:37 +05:30
def branch_names_contains(sha)
args = %W(git branch --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
def tag_names_contains(sha)
args = %W(git tag --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
def branches
@branches ||= raw_repository.branches
end
def tags
@tags ||= raw_repository.tags
end
def root_ref
@root_ref ||= raw_repository.root_ref
end
2015-09-11 14:41:01 +05:30
def merged_to_root_ref?(branch_name)
branch_commit = commit(branch_name)
root_ref_commit = commit(root_ref)
if branch_commit
rugged.merge_base(root_ref_commit.id, branch_commit.id) == branch_commit.id
else
nil
end
end
def search_files(query, ref)
offset = 2
args = %W(git grep -i -n --before-context #{offset} --after-context #{offset} #{query} #{ref || root_ref})
Gitlab::Popen.popen(args, path_to_repo).first.scrub.split(/^--$/)
end
def parse_search_result(result)
ref = nil
filename = 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
break
end
end
data = ""
result.each_line do |line|
data << line.sub(ref, '').sub(filename, '').sub(/^:-\d+-/, '').sub(/^::\d+:/, '')
end
OpenStruct.new(
filename: filename,
ref: ref,
startline: startline,
data: data
)
end
2015-04-26 12:48:37 +05:30
private
def cache
@cache ||= RepositoryCache.new(path_with_namespace)
end
2014-09-02 18:07:02 +05:30
end