Package org.variantsync.diffdetective.variation.diff.parse

Class VariationDiffParser

java.lang.Object

org.variantsync.diffdetective.variation.diff.parse.VariationDiffParser

public class VariationDiffParser
extends Object

Parser that parses VariationDiffs from text-based diffs.

Note: Weird line continuations and comments can cause misidentification of conditional macros. The following examples are all correct according to the C11 standard: (comment end is marked by *\/):

/* #ifdef A *\/

#ifdef /* *\/ A #endif

# /**\/ ifdef #endif

# \ ifdef #endif

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static final record	VariationDiffParser.DiffLine	One line of a diff.

Field Summary

Fields

Modifier and Type	Field	Description
private final Stack<DiffNode<DiffLinesLabel>>	afterStack	A stack containing the current path after the edit from the root of the currently parsed VariationDiff to the currently parsed DiffNode.
private final Stack<DiffNode<DiffLinesLabel>>	beforeStack	A stack containing the current path before the edit from the root of the currently parsed VariationDiff to the currently parsed DiffNode.
private DiffNode<DiffLinesLabel>	lastArtifact	The last artifact node which was parsed by parseLine(org.variantsync.diffdetective.variation.diff.parse.LogicalLine, org.variantsync.diffdetective.variation.diff.DiffType, org.variantsync.diffdetective.diff.text.DiffLineNumber).
(package private) final VariationDiffParseOptions	options

Constructor Summary

Constructors

Modifier	Constructor	Description
private	VariationDiffParser(VariationDiffParseOptions options)	Initializes the parse state.

Method Summary

Modifier and Type	Method	Description
private void	addNode(DiffNode<DiffLinesLabel> newNode)	Adds a fully parsed node into the VariationDiff.
static VariationDiff<DiffLinesLabel>	createVariationDiff(BufferedReader fullDiff, VariationDiffParseOptions options)	Default parsing method for VariationDiffs from diffs.
static VariationDiff<DiffLinesLabel>	createVariationDiff(String fullDiff, VariationDiffParseOptions parseOptions)	The same as createVariationDiff(BufferedReader, VariationDiffParseOptions) but with the diff given as a single string with line breaks instead of a BufferedReader.
static VariationDiff<DiffLinesLabel>	createVariationTree(BufferedReader file, VariationDiffParseOptions options)	Parses a variation tree from a source file.
private VariationDiff<DiffLinesLabel>	parse(org.apache.commons.lang3.function.FailableSupplier<VariationDiffParser.DiffLine,IOException> lines)	Parses the line diff fullDiff.
static CommitDiff	parseCommit(Repository repo, String commitHash)	Parses the given commit of the given repository.
private void	parseLine(LogicalLine line, DiffType diffType, DiffLineNumber lastLineNumber)	Parses one logical line and most notably, handles conditional macros.
static PatchDiff	parsePatch(Repository repo, String file, String commitHash)	Parses the given patch of the given repository.
private void	popIfChain(Stack<DiffNode<DiffLinesLabel>> stack, DiffLineNumber elseLineNumber)	Pop stack until an IF node is popped.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

options

final VariationDiffParseOptions options

beforeStack

private final Stack<DiffNode<DiffLinesLabel>> beforeStack

A stack containing the current path before the edit from the root of the currently parsed VariationDiff to the currently parsed DiffNode.

The granularity of the VariationDiffs parsed by this class is always lines because line diffs can't represent different granularities. This implies that there are no nested artifact nodes in the resulting VariationDiff and therefore beforeStack will never contain an artifact node.

afterStack

private final Stack<DiffNode<DiffLinesLabel>> afterStack

A stack containing the current path after the edit from the root of the currently parsed VariationDiff to the currently parsed DiffNode.

See beforeStack for more explanations.

lastArtifact

private DiffNode<DiffLinesLabel> lastArtifact

The last artifact node which was parsed by parseLine(org.variantsync.diffdetective.variation.diff.parse.LogicalLine, org.variantsync.diffdetective.variation.diff.DiffType, org.variantsync.diffdetective.diff.text.DiffLineNumber). If the last parsed DiffNode was not an artifact, lastArtifact is null.

This state is used to implement VariationDiffParseOptions.collapseMultipleCodeLines().

Constructor Details

VariationDiffParser

private VariationDiffParser(VariationDiffParseOptions options)

Initializes the parse state.

See Also:

• createVariationDiff(BufferedReader, VariationDiffParseOptions)

Method Details

createVariationDiff

public static VariationDiff<DiffLinesLabel> createVariationDiff(String fullDiff,
 VariationDiffParseOptions parseOptions)
                                                         throws DiffParseException

The same as createVariationDiff(BufferedReader, VariationDiffParseOptions) but with the diff given as a single string with line breaks instead of a BufferedReader.

Throws:

DiffParseException - if fullDiff couldn't be parsed

createVariationDiff

public static VariationDiff<DiffLinesLabel> createVariationDiff(BufferedReader fullDiff,
 VariationDiffParseOptions options)
                                                         throws IOException,
DiffParseException

Default parsing method for VariationDiffs from diffs. This implementation has options to collapse multiple code lines into one node and to discard empty lines. This parsing algorithm is described in detail in Sören Viegener's bachelor's thesis.

Parameters:

fullDiff - The full diff of a patch obtained from a buffered reader.

options - VariationDiffParseOptions for the parsing process.

Returns:

A parsed VariationDiff upon success or an error indicating why parsing failed.

Throws:

IOException - when reading from fullDiff fails.

DiffParseException - if an error in the diff or macro syntax is detected

createVariationTree

public static VariationDiff<DiffLinesLabel> createVariationTree(BufferedReader file,
 VariationDiffParseOptions options)
                                                         throws IOException,
DiffParseException

Parses a variation tree from a source file. This method is similar to createVariationDiff(BufferedReader, VariationDiffParseOptions) but acts as if all lines where unmodified.

Parameters:

file - The source code file (not a diff) to be parsed.

options - VariationDiffParseOptions for the parsing process.

Returns:

A parsed VariationDiff.

Throws:

IOException - iff file throws an IOException

DiffParseException - if an error in the diff or macro syntax is detected

parse

private VariationDiff<DiffLinesLabel> parse(org.apache.commons.lang3.function.FailableSupplier<VariationDiffParser.DiffLine,IOException> lines)
                                     throws IOException,
DiffParseException

Parses the line diff fullDiff.

Parameters:

lines - should supply successive lines of the diff to be parsed, or null if there are no more lines to be parsed.

Returns:

the parsed VariationDiff

Throws:

IOException - iff lines.get() throws IOException

DiffParseException - if an error in the line diff or the underlying preprocessor syntax is detected

parseLine

private void parseLine(LogicalLine line,
 DiffType diffType,
 DiffLineNumber lastLineNumber)
                throws DiffParseException

Parses one logical line and most notably, handles conditional macros.

Parameters:

line - a logical line with line.isComplete() == true

diffType - whether line was added, inserted or unchanged

lastLineNumber - the last physical line of line

Throws:

DiffParseException - if erroneous preprocessor macros are detected

popIfChain

private void popIfChain(Stack<DiffNode<DiffLinesLabel>> stack,
 DiffLineNumber elseLineNumber)
                 throws DiffParseException

Pop stack until an IF node is popped. If there were ELSEs or ELIFs between an IF and an ENDIF, they were placed on the stack and have to be popped now. The end line numbers are adjusted

Parameters:

stack - the stack which should be popped

elseLineNumber - the first line of the else which causes this IF to be popped

Throws:

DiffParseException - if stack doesn't contain an IF node

addNode

private void addNode(DiffNode<DiffLinesLabel> newNode)
              throws DiffParseException

Adds a fully parsed node into the VariationDiff. Annotations also pushed to the relevant stacks.

Parameters:

newNode - the fully parsed node to be added

Throws:

DiffParseException - if line erroneous preprocessor macros are detected

parseCommit

public static CommitDiff parseCommit(Repository repo,
 String commitHash)
                              throws IOException

Parses the given commit of the given repository.

Parameters:

repo - The repository from which a commit should be parsed.

commitHash - Hash of the commit to parse.

Returns:

A CommitDiff describing edits to variability introduced by the given commit relative to its first parent commit.

Throws:

IOException - when an error occurred.

parsePatch

public static PatchDiff parsePatch(Repository repo,
 String file,
 String commitHash)
                            throws IOException

Parses the given patch of the given repository.

Parameters:

repo - The repository from which a patch should be parsed.

file - The file that was edited by the patch.

commitHash - The hash of the commit in which the patch was made.

Returns:

A PatchDiff describing edits to variability introduced by the given patch relative to the corresponding commit's first parent commit.

Throws:

IOException - when an error occurred.

AssertionError - when no such patch exists.