2014-09-08 13:25:50 +00:00
|
|
|
module Gitlab
|
|
|
|
module Diff
|
|
|
|
class File
|
2017-05-15 18:19:49 +00:00
|
|
|
attr_reader :diff, :repository, :diff_refs, :fallback_diff_refs
|
2014-09-08 13:25:50 +00:00
|
|
|
|
2017-05-15 17:10:29 +00:00
|
|
|
delegate :new_file?, :deleted_file?, :renamed_file?,
|
|
|
|
:old_path, :new_path, :a_mode, :b_mode, :mode_changed?,
|
2017-09-11 12:52:27 +00:00
|
|
|
:submodule?, :expanded?, :too_large?, :collapsed?, :line_count, :has_binary_notice?, to: :diff, prefix: false
|
2017-06-06 21:28:06 +00:00
|
|
|
|
|
|
|
# Finding a viewer for a diff file happens based only on extension and whether the
|
|
|
|
# diff file blobs are binary or text, which means 1 diff file should only be matched by 1 viewer,
|
|
|
|
# and the order of these viewers doesn't really matter.
|
|
|
|
#
|
|
|
|
# However, when the diff file blobs are LFS pointers, we cannot know for sure whether the
|
|
|
|
# file being pointed to is binary or text. In this case, we match only on
|
|
|
|
# extension, preferring binary viewers over text ones if both exist, since the
|
|
|
|
# large files referred to in "Large File Storage" are much more likely to be
|
|
|
|
# binary than text.
|
|
|
|
RICH_VIEWERS = [
|
|
|
|
DiffViewer::Image
|
|
|
|
].sort_by { |v| v.binary? ? 0 : 1 }.freeze
|
2014-09-08 13:25:50 +00:00
|
|
|
|
2017-05-15 18:19:49 +00:00
|
|
|
def initialize(diff, repository:, diff_refs: nil, fallback_diff_refs: nil)
|
2014-09-08 13:25:50 +00:00
|
|
|
@diff = diff
|
2016-06-20 16:51:48 +00:00
|
|
|
@repository = repository
|
2016-01-20 17:44:27 +00:00
|
|
|
@diff_refs = diff_refs
|
2017-05-15 18:19:49 +00:00
|
|
|
@fallback_diff_refs = fallback_diff_refs
|
2016-01-20 17:44:27 +00:00
|
|
|
end
|
|
|
|
|
2017-10-07 04:25:17 +00:00
|
|
|
def position(position_marker, position_type: :text)
|
2016-06-20 17:17:25 +00:00
|
|
|
return unless diff_refs
|
|
|
|
|
2017-10-07 04:25:17 +00:00
|
|
|
data = {
|
|
|
|
diff_refs: diff_refs,
|
|
|
|
position_type: position_type.to_s,
|
2016-06-20 17:17:25 +00:00
|
|
|
old_path: old_path,
|
2017-10-07 04:25:17 +00:00
|
|
|
new_path: new_path
|
|
|
|
}
|
|
|
|
|
|
|
|
if position_type == :text
|
|
|
|
data.merge!(text_position_properties(position_marker))
|
|
|
|
else
|
|
|
|
data.merge!(image_position_properties(position_marker))
|
|
|
|
end
|
|
|
|
|
|
|
|
Position.new(data)
|
2016-06-20 17:17:25 +00:00
|
|
|
end
|
|
|
|
|
2016-06-20 17:15:44 +00:00
|
|
|
def line_code(line)
|
|
|
|
return if line.meta?
|
|
|
|
|
2017-10-06 22:42:56 +00:00
|
|
|
Gitlab::Git::DiffLineCode.generate(file_path, line.new_pos, line.old_pos)
|
2016-06-20 17:15:44 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def line_for_line_code(code)
|
|
|
|
diff_lines.find { |line| line_code(line) == code }
|
|
|
|
end
|
|
|
|
|
2016-06-20 17:17:25 +00:00
|
|
|
def line_for_position(pos)
|
|
|
|
diff_lines.find { |line| position(line) == pos }
|
|
|
|
end
|
|
|
|
|
|
|
|
def position_for_line_code(code)
|
|
|
|
line = line_for_line_code(code)
|
|
|
|
position(line) if line
|
|
|
|
end
|
|
|
|
|
|
|
|
def line_code_for_position(pos)
|
|
|
|
line = line_for_position(pos)
|
|
|
|
line_code(line) if line
|
|
|
|
end
|
|
|
|
|
2017-05-15 18:19:49 +00:00
|
|
|
def old_sha
|
|
|
|
diff_refs&.base_sha
|
|
|
|
end
|
|
|
|
|
|
|
|
def new_sha
|
|
|
|
diff_refs&.head_sha
|
|
|
|
end
|
|
|
|
|
2017-06-06 21:24:32 +00:00
|
|
|
def new_content_sha
|
|
|
|
return if deleted_file?
|
|
|
|
return @new_content_sha if defined?(@new_content_sha)
|
2017-05-15 18:19:49 +00:00
|
|
|
|
|
|
|
refs = diff_refs || fallback_diff_refs
|
2017-06-06 21:24:32 +00:00
|
|
|
@new_content_sha = refs&.head_sha
|
2017-05-15 18:19:49 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def old_content_sha
|
|
|
|
return if new_file?
|
|
|
|
return @old_content_sha if defined?(@old_content_sha)
|
2016-07-06 23:29:41 +00:00
|
|
|
|
2017-05-15 18:19:49 +00:00
|
|
|
refs = diff_refs || fallback_diff_refs
|
|
|
|
@old_content_sha = refs&.base_sha
|
2016-06-20 16:54:53 +00:00
|
|
|
end
|
|
|
|
|
2017-06-06 21:24:32 +00:00
|
|
|
def new_blob
|
|
|
|
return @new_blob if defined?(@new_blob)
|
2017-05-15 18:19:49 +00:00
|
|
|
|
2017-06-06 21:24:32 +00:00
|
|
|
sha = new_content_sha
|
|
|
|
return @new_blob = nil unless sha
|
2017-05-15 18:19:49 +00:00
|
|
|
|
2017-06-06 21:24:32 +00:00
|
|
|
@new_blob = repository.blob_at(sha, file_path)
|
2016-01-20 17:44:27 +00:00
|
|
|
end
|
|
|
|
|
2017-05-15 18:19:49 +00:00
|
|
|
def old_blob
|
|
|
|
return @old_blob if defined?(@old_blob)
|
|
|
|
|
|
|
|
sha = old_content_sha
|
|
|
|
return @old_blob = nil unless sha
|
|
|
|
|
|
|
|
@old_blob = repository.blob_at(sha, old_path)
|
2014-09-08 13:25:50 +00:00
|
|
|
end
|
|
|
|
|
2017-06-06 21:24:32 +00:00
|
|
|
def content_sha
|
|
|
|
new_content_sha || old_content_sha
|
|
|
|
end
|
|
|
|
|
|
|
|
def blob
|
|
|
|
new_blob || old_blob
|
|
|
|
end
|
|
|
|
|
2016-07-26 07:21:42 +00:00
|
|
|
attr_writer :highlighted_diff_lines
|
2016-07-20 16:25:36 +00:00
|
|
|
|
2016-06-20 16:51:48 +00:00
|
|
|
# Array of Gitlab::Diff::Line objects
|
2014-09-08 13:25:50 +00:00
|
|
|
def diff_lines
|
2016-07-20 16:25:36 +00:00
|
|
|
@diff_lines ||= Gitlab::Diff::Parser.new.parse(raw_diff.each_line).to_a
|
2016-03-11 16:40:59 +00:00
|
|
|
end
|
|
|
|
|
2015-12-30 05:52:50 +00:00
|
|
|
def highlighted_diff_lines
|
2016-06-20 16:51:48 +00:00
|
|
|
@highlighted_diff_lines ||= Gitlab::Diff::Highlight.new(self, repository: self.repository).highlight
|
2015-12-30 05:52:50 +00:00
|
|
|
end
|
|
|
|
|
2016-07-20 16:25:36 +00:00
|
|
|
# Array[<Hash>] with right/left keys that contains Gitlab::Diff::Line objects which text is hightlighted
|
2016-01-20 13:51:56 +00:00
|
|
|
def parallel_diff_lines
|
2016-06-20 16:51:48 +00:00
|
|
|
@parallel_diff_lines ||= Gitlab::Diff::ParallelDiff.new(self).parallelize
|
2016-01-20 13:51:56 +00:00
|
|
|
end
|
|
|
|
|
2014-09-08 18:54:52 +00:00
|
|
|
def raw_diff
|
2014-09-24 10:26:53 +00:00
|
|
|
diff.diff.to_s
|
2014-09-08 18:54:52 +00:00
|
|
|
end
|
|
|
|
|
2014-09-08 13:25:50 +00:00
|
|
|
def next_line(index)
|
|
|
|
diff_lines[index + 1]
|
|
|
|
end
|
|
|
|
|
|
|
|
def prev_line(index)
|
2016-06-20 16:57:10 +00:00
|
|
|
diff_lines[index - 1] if index > 0
|
2014-09-08 13:25:50 +00:00
|
|
|
end
|
2014-09-08 18:54:52 +00:00
|
|
|
|
2016-06-20 17:17:25 +00:00
|
|
|
def paths
|
|
|
|
[old_path, new_path].compact
|
|
|
|
end
|
|
|
|
|
2014-09-08 18:54:52 +00:00
|
|
|
def file_path
|
2016-06-20 16:57:10 +00:00
|
|
|
new_path.presence || old_path
|
2014-09-08 18:54:52 +00:00
|
|
|
end
|
2015-10-01 11:52:08 +00:00
|
|
|
|
|
|
|
def added_lines
|
2015-12-15 02:53:52 +00:00
|
|
|
diff_lines.count(&:added?)
|
2015-10-01 11:52:08 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def removed_lines
|
2015-12-15 02:53:52 +00:00
|
|
|
diff_lines.count(&:removed?)
|
2015-10-01 11:52:08 +00:00
|
|
|
end
|
2016-06-20 16:54:53 +00:00
|
|
|
|
2016-11-10 17:24:12 +00:00
|
|
|
def file_identifier
|
2017-05-15 17:10:29 +00:00
|
|
|
"#{file_path}-#{new_file?}-#{deleted_file?}-#{renamed_file?}"
|
2016-10-12 13:34:47 +00:00
|
|
|
end
|
2017-06-06 21:24:32 +00:00
|
|
|
|
|
|
|
def diffable?
|
|
|
|
repository.attributes(file_path).fetch('diff') { true }
|
|
|
|
end
|
|
|
|
|
|
|
|
def binary?
|
2017-09-11 12:52:27 +00:00
|
|
|
has_binary_notice? || old_blob&.binary? || new_blob&.binary?
|
2017-06-06 21:24:32 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def text?
|
|
|
|
!binary?
|
|
|
|
end
|
2017-06-06 21:28:06 +00:00
|
|
|
|
|
|
|
def external_storage_error?
|
|
|
|
old_blob&.external_storage_error? || new_blob&.external_storage_error?
|
|
|
|
end
|
|
|
|
|
|
|
|
def stored_externally?
|
|
|
|
old_blob&.stored_externally? || new_blob&.stored_externally?
|
|
|
|
end
|
|
|
|
|
|
|
|
def external_storage
|
|
|
|
old_blob&.external_storage || new_blob&.external_storage
|
|
|
|
end
|
|
|
|
|
|
|
|
def content_changed?
|
2017-08-22 15:27:09 +00:00
|
|
|
return blobs_changed? if diff_refs
|
|
|
|
return false if new_file? || deleted_file? || renamed_file?
|
|
|
|
|
|
|
|
text? && diff_lines.any?
|
2017-06-06 21:28:06 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def different_type?
|
|
|
|
old_blob && new_blob && old_blob.binary? != new_blob.binary?
|
|
|
|
end
|
|
|
|
|
|
|
|
def size
|
|
|
|
[old_blob&.size, new_blob&.size].compact.sum
|
|
|
|
end
|
|
|
|
|
|
|
|
def raw_size
|
|
|
|
[old_blob&.raw_size, new_blob&.raw_size].compact.sum
|
|
|
|
end
|
|
|
|
|
|
|
|
def raw_binary?
|
|
|
|
old_blob&.raw_binary? || new_blob&.raw_binary?
|
|
|
|
end
|
|
|
|
|
|
|
|
def raw_text?
|
|
|
|
!raw_binary? && !different_type?
|
|
|
|
end
|
|
|
|
|
|
|
|
def simple_viewer
|
|
|
|
@simple_viewer ||= simple_viewer_class.new(self)
|
|
|
|
end
|
|
|
|
|
|
|
|
def rich_viewer
|
|
|
|
return @rich_viewer if defined?(@rich_viewer)
|
|
|
|
|
|
|
|
@rich_viewer = rich_viewer_class&.new(self)
|
|
|
|
end
|
|
|
|
|
|
|
|
def rendered_as_text?(ignore_errors: true)
|
|
|
|
simple_viewer.is_a?(DiffViewer::Text) && (ignore_errors || simple_viewer.render_error.nil?)
|
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
|
2017-10-07 04:25:17 +00:00
|
|
|
def text_position_properties(line)
|
|
|
|
{ old_line: line.old_line, new_line: line.new_line }
|
|
|
|
end
|
|
|
|
|
|
|
|
def image_position_properties(image_point)
|
|
|
|
image_point.to_h
|
|
|
|
end
|
|
|
|
|
2017-08-22 15:27:09 +00:00
|
|
|
def blobs_changed?
|
|
|
|
old_blob && new_blob && old_blob.id != new_blob.id
|
|
|
|
end
|
|
|
|
|
2017-06-06 21:28:06 +00:00
|
|
|
def simple_viewer_class
|
|
|
|
return DiffViewer::NotDiffable unless diffable?
|
|
|
|
|
|
|
|
if content_changed?
|
|
|
|
if raw_text?
|
|
|
|
DiffViewer::Text
|
|
|
|
else
|
|
|
|
DiffViewer::NoPreview
|
|
|
|
end
|
|
|
|
elsif new_file?
|
|
|
|
if raw_text?
|
|
|
|
DiffViewer::Text
|
|
|
|
else
|
|
|
|
DiffViewer::Added
|
|
|
|
end
|
|
|
|
elsif deleted_file?
|
|
|
|
if raw_text?
|
|
|
|
DiffViewer::Text
|
|
|
|
else
|
|
|
|
DiffViewer::Deleted
|
|
|
|
end
|
|
|
|
elsif renamed_file?
|
|
|
|
DiffViewer::Renamed
|
|
|
|
elsif mode_changed?
|
|
|
|
DiffViewer::ModeChanged
|
2017-08-22 13:04:54 +00:00
|
|
|
else
|
|
|
|
DiffViewer::NoPreview
|
2017-06-06 21:28:06 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def rich_viewer_class
|
|
|
|
viewer_class_from(RICH_VIEWERS)
|
|
|
|
end
|
|
|
|
|
|
|
|
def viewer_class_from(classes)
|
|
|
|
return unless diffable?
|
|
|
|
return if different_type? || external_storage_error?
|
|
|
|
return unless new_file? || deleted_file? || content_changed?
|
|
|
|
|
|
|
|
verify_binary = !stored_externally?
|
|
|
|
|
|
|
|
classes.find { |viewer_class| viewer_class.can_render?(self, verify_binary: verify_binary) }
|
|
|
|
end
|
2014-09-08 13:25:50 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|