reviewboard.reviews.views.diff_fragments¶

Views for rendering diff fragments.

class CommentFragment[source]¶

Bases: TypedDict

A comment fragment.

New in version 6.0.

comment: Comment¶

The diff comment.

Type:: reviewboard.reviews.models.diff_comment.Comment

html: SafeString¶

The rendered diff fragment HTML.

Type:: django.utils.safestring.SafeString

chunks: List[Dict]¶

The diff chunks included in the fragment.

This is the information returned by get_file_chunks_in_range().

Type:: list

__annotations__ = {'chunks': ForwardRef('List[Dict]', module='reviewboard.reviews.views.diff_fragments'), 'comment': ForwardRef('Comment', module='reviewboard.reviews.views.diff_fragments'), 'html': ForwardRef('SafeString', module='reviewboard.reviews.views.diff_fragments')}¶

__closed__ = False¶

__extra_items__ = None¶

__mutable_keys__ = frozenset({'chunks', 'comment', 'html'})¶

__optional_keys__ = frozenset({})¶

__orig_bases__ = (<function TypedDict>,)¶

__readonly_keys__ = frozenset({})¶

__required_keys__ = frozenset({'chunks', 'comment', 'html'})¶

__total__ = True¶

build_diff_comment_fragments(*, comments: List[Comment], context: Dict[str, Any], comment_template_name: str = 'reviews/diff_comment_fragment.html', error_template_name: str = 'diffviewer/diff_fragment_error.html', lines_of_context: Optional[List[int]] = None, show_controls: bool = False, request: Optional[HttpRequest] = None) → Tuple[bool, List[CommentFragment]][source]¶

Construct and return the comment fragment data.

Parameters:

comments (list of reviewboard.reviews.models.diff_comment.Comment) – The comments to return diff fragments for.
context (dict) – The rendering context.
comment_template_name (str, optional) – The template to use for rendering the comment fragment.
error_template_name (str, optional) – The template to use for rendering errors.
lines_of_context (list of int, optional) – A 2-element list containing the number of additional lines of context to render above and below each fragment.
show_controls (bool, optional) – Whether to show expand controls in the rendered output.
request (django.http.HttpRequest, optional) – The HTTP request from the client, if available.

Returns:

A 2-tuple containing:

Tuple:

0 (bool) – Whether any errors occurred.
1 (list of CommentFragment) – The rendered comment fragments.

Return type:

tuple

class CommentDiffFragmentsView(**kwargs)[source]¶

Bases: ReviewRequestViewMixin, ETagViewMixin, ContextMixin, View

View for rendering a section of a diff that a comment pertains to.

This takes in one or more Comment IDs (comma-separated) as part of the URL and returns a payload containing data and HTML for each comment’s diff fragment, which the client can parse in order to dynamically load the fragments into the page.

The resulting format is a custom, condensed format containing the comment ID and HTML for each diff fragment. It’s designed to be quick to parse and reduces the amount of data to send across the wire (unlike a format like JSON, which would add overhead to the serialization/deserialization time and data size when storing HTML, or JavaScript, which releases prior to 3.0 used to handle injecting fragments into the DOM).

Each entry in the payload is in the following format, with all entries joined together:

<comment ID>n <html length>n <html content>

The format is subject to change without notice, and should not be relied upon by third parties.

The following URL query options are supported:

allow_expansion:: Whether expansion controls should be shown to the user. To enable this, the caller must pass a value of 1. This is disabled by default.
lines_of_context:: The number of lines of context before and after the commented region of the diff. This is in the form of pre,post, where both are the numbers of lines. This defaults to 0,0.

comment_template_name = 'reviews/diff_comment_fragment.html'[source]¶

error_template_name = 'diffviewer/diff_fragment_error.html'[source]¶

content_type = 'application/javascript'[source]¶

EXPIRATION_SECONDS = 31536000[source]¶

get_etag_data(request: HttpRequest, comment_ids: str, *args, **kwargs) → str[source]¶

Return an ETag for the view.

This will look up state needed for the request and generate a suitable ETag. Some of the information will be stored for later computation of the template context.

Parameters:

request (django.http.HttpRequest) – The HTTP request from the client.
comment_ids (str) – A list of comment IDs to render.
*args (tuple, unused) – Positional arguments passed to the handler.
**kwargs (dict, unused) – Keyword arguments passed to the handler.

Returns:

The ETag for the page.

Return type:

str

get(request: HttpRequest, **kwargs) → HttpResponse[source]¶

Handle HTTP GET requests for this view.

This will generate a payload for the diff comments being loaded and pass them in a format that can be parsed by the client.

Parameters:

request (django.http.HttpRequest) – The HTTP request from the client.
**kwargs (dict) – Keyword arguments passed to the view.

Returns:

The HTTP response containing the fragments payload.

Return type:

django.http.HttpResponse

__annotations__ = {}¶

class ReviewsDiffFragmentView(**kwargs)[source]¶

Bases: ReviewRequestViewMixin, DiffFragmentView

Renders a fragment from a file in the diff viewer.

Displays just a fragment of a diff or interdiff owned by the given review request. The fragment is identified by the chunk index in the diff.

review_request_id:: The ID of the ReviewRequest containing the diff to render.
revision:: The DiffSet revision to render.
filediff_id:: The ID of the FileDiff within the DiffSet.

The following may also be provided:

interdiff_revision:: The second DiffSet revision in an interdiff revision range.
chunk_index:: The index (0-based) of the chunk to render. If left out, the entire file will be rendered.
local_site:: The LocalSite the ReviewRequest must be on, if any.

See DiffFragmentView for the accepted query parameters.

process_diffset_info(revision: int, interdiff_revision: Optional[int] = None, **kwargs) → dict[str, Any][source]¶

Process and return information on the desired diff.

The diff IDs and other data passed to the view can be processed and converted into DiffSets. A dictionary with the DiffSet and FileDiff information will be returned.

If the review request cannot be accessed by the user, an HttpResponse will be returned instead.

Parameters:

revision (int) – The revision of the diff to view.
interdiff_revision (int, optional) – The second diff revision if viewing an interdiff.
**kwargs (dict) – Keyword arguments passed to the view.

Returns:

Information on the diff for use in the template and in queries.

Return type:

dict

create_renderer(context: dict[str, Any], renderer_settings: dict[str, Any], diff_file: dict[str, Any], *args, **kwargs) → DiffRenderer[source]¶

Create the DiffRenderer for this fragment.

This will augment the renderer for binary files by looking up file attachments, if review UIs are involved, disabling caching.

Parameters:

context (dict) – The current render context.
renderer_settings (dict) – The diff renderer settings.
diff_file (dict) – The information on the diff file to render.
*args (tuple) – Additional positional arguments from the parent class.
**kwargs (dict) – Additional keyword arguments from the parent class.

Returns:

The resulting diff renderer.

Return type:

reviewboard.diffviewer.renderers.DiffRenderer

get_context_data(**kwargs) → Dict[str, Any][source]¶

“Return context for rendering the view.

Parameters:: **kwargs (dict) – Keyword arguments passed to the view.
Returns:: Context to use for rendering templates.
Return type:: dict

__annotations__ = {}¶