Package com.github.zafarkhaja.semver.expr

Class ExpressionParser

  • All Implemented Interfaces:
    Parser<Expression>
    public class ExpressionParser
extends java.lang.Object
implements Parser<Expression>
    A parser for the SemVer Expressions.
    Since:
    0.7.0

    • Field Detail

      • lexer

        private final Lexer lexer
        The lexer instance used for tokenization of the input string.

      • tokens

        private Stream<Lexer.Token> tokens
        The stream of tokens produced by the lexer.

    • Constructor Detail

      • ExpressionParser

        ExpressionParser​(Lexer lexer)
        Constructs a ExpressionParser instance with the corresponding lexer.
        Parameters:
        lexer - the lexer to use for tokenization of the input string

    • Method Detail

      • newInstance

        public static Parser<Expression> newInstance()
        Creates and returns new instance of the ExpressionParser class. This method implements the Static Factory Method pattern.
        Returns:
        a new instance of the ExpressionParser class

      • parse

        public Expression parse​(java.lang.String input)
        Parses the SemVer Expressions.
        Specified by:
        parse in interface Parser<Expression>
        Parameters:
        input - a string representing the SemVer Expression
        Returns:
        the AST for the SemVer Expressions
        Throws:
        LexerException - when encounters an illegal character
        UnexpectedTokenException - when consumes a token of an unexpected type

      • parseSemVerExpression

        private CompositeExpression parseSemVerExpression()
        Parses the <semver-expr> non-terminal. 
         
 <semver-expr> ::= "(" <semver-expr> ")"
                 | "!" "(" <semver-expr> ")"
                 | <semver-expr> <more-expr>
                 | <range>
        Returns:
        the expression AST

      • parseMoreExpressions

        private CompositeExpression parseMoreExpressions​(CompositeExpression expr)
        Parses the <more-expr> non-terminal. 
         
 <more-expr> ::= <boolean-op> <semver-expr> | epsilon
        Parameters:
        expr - the left-hand expression of the logical operators
        Returns:
        the expression AST

      • parseRange

        private CompositeExpression parseRange()
        Parses the <range> non-terminal. 
         
 <expr> ::= <comparison-range>
          | <wildcard-expr>
          | <tilde-range>
          | <caret-range>
          | <hyphen-range>
          | <partial-version-range>
        Returns:
        the expression AST

      • parseComparisonRange

        private CompositeExpression parseComparisonRange()
        Parses the <comparison-range> non-terminal. 
         
 <comparison-range> ::= <comparison-op> <version> | <version>
        Returns:
        the expression AST

      • parseTildeRange

        private CompositeExpression parseTildeRange()
        Parses the <tilde-range> non-terminal. 
         
 <tilde-range> ::= "~" <version>
        Returns:
        the expression AST

      • parseCaretRange

        private CompositeExpression parseCaretRange()
        Parses the <caret-range> non-terminal. 
         
 <caret-range> ::= "^" <version>
        Returns:
        the expression AST

      • isWildcardRange

        private boolean isWildcardRange()
        Determines if the following version terminals are part of the <wildcard-range> non-terminal.
        Returns:
        true if the following version terminals are part of the <wildcard-range> non-terminal or false otherwise

      • parseWildcardRange

        private CompositeExpression parseWildcardRange()
        Parses the <wildcard-range> non-terminal. 
         
 <wildcard-range> ::= <wildcard>
                    | <major> "." <wildcard>
                    | <major> "." <minor> "." <wildcard>

 <wildcard> ::= "*" | "x" | "X"
        Returns:
        the expression AST

      • isHyphenRange

        private boolean isHyphenRange()
        Determines if the following version terminals are part of the <hyphen-range> non-terminal.
        Returns:
        true if the following version terminals are part of the <hyphen-range> non-terminal or false otherwise

      • parseHyphenRange

        private CompositeExpression parseHyphenRange()
        Parses the <hyphen-range> non-terminal. 
         
 <hyphen-range> ::= <version> "-" <version>
        Returns:
        the expression AST

      • isPartialVersionRange

        private boolean isPartialVersionRange()
        Determines if the following version terminals are part of the <partial-version-range> non-terminal.
        Returns:
        true if the following version terminals are part of the <partial-version-range> non-terminal or false otherwise

      • parsePartialVersionRange

        private CompositeExpression parsePartialVersionRange()
        Parses the <partial-version-range> non-terminal. 
         
 <partial-version-range> ::= <major> | <major> "." <minor>
        Returns:
        the expression AST

      • parseVersion

        private Version parseVersion()
        Parses the <version> non-terminal. 
         
 <version> ::= <major>
             | <major> "." <minor>
             | <major> "." <minor> "." <patch>
        Returns:
        the parsed version

      • isVersionFollowedBy

        private boolean isVersionFollowedBy​(Stream.ElementType<Lexer.Token> type)
        Determines if the version terminals are followed by the specified token type. This method is essentially a lookahead(k) method which allows to solve the grammar's ambiguities.
        Parameters:
        type - the token type to check
        Returns:
        true if the version terminals are followed by the specified token type or false otherwise

      • versionFor

        private Version versionFor​(int major)
        Creates a Version instance for the specified major version.
        Parameters:
        major - the major version number
        Returns:
        the version for the specified major version

      • versionFor

        private Version versionFor​(int major,
                           int minor)
        Creates a Version instance for the specified major and minor versions.
        Parameters:
        major - the major version number
        minor - the minor version number
        Returns:
        the version for the specified major and minor versions

      • versionFor

        private Version versionFor​(int major,
                           int minor,
                           int patch)
        Creates a Version instance for the specified major, minor and patch versions.
        Parameters:
        major - the major version number
        minor - the minor version number
        patch - the patch version number
        Returns:
        the version for the specified major, minor and patch versions

      • intOf

        private int intOf​(java.lang.String value)
        Returns a int representation of the specified string.
        Parameters:
        value - the string to convert into an integer
        Returns:
        the integer value of the specified string

      • consumeNextToken

        private Lexer.Token consumeNextToken​(Lexer.Token.Type... expected)
        Tries to consume the next token in the stream.
        Parameters:
        expected - the expected types of the next token
        Returns:
        the next token in the stream
        Throws:
        UnexpectedTokenException - when encounters an unexpected token type