pestle 0.1.0

data/sig/grammar/ascii.rbs

@@ -0,0 +1,9 @@
+module Pestle::Grammar
+  class ASCIIRule < BuiltInRule
+    def initialize: (String name, *Array[String] ranges) -> void
+  end
+
+  ASCII_RULE_DEFS: Hash[String, Array[Array[String]]]
+
+  ASCII_RULES: Hash[String, BuiltInRule]
+end

data/sig/grammar/choice.rbs

@@ -0,0 +1,14 @@
+module Pestle::Grammar
+  # The choice operator `|`.
+  class Choice < Expression
+    @expressions: Array[Expression]
+
+    attr_reader expressions: Array[Expression]
+
+    def initialize: (*Expression expressions) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> Array[Expression]
+  end
+end

data/sig/grammar/errors.rbs

@@ -0,0 +1,22 @@
+module Pestle::Grammar
+  # Pest grammar parsing error.
+  class PestGrammarError < StandardError
+    @token: [Symbol, String?, Integer]
+
+    @source: String
+
+    attr_accessor token: [Symbol, String?, Integer]
+
+    attr_accessor source: String
+
+    FULL_MESSAGE: bool
+
+    def initialize: (String message, String source, [Symbol, String?, Integer] token) -> void
+
+    def detailed_message: (?highlight: bool, **untyped kwargs) -> String
+
+    def full_message: (?highlight: bool, ?order: ::Symbol) -> String
+
+    def error_context: (String source, Integer index) -> [Integer, Integer, String]
+  end
+end

data/sig/grammar/expression.rbs

@@ -0,0 +1,39 @@
+module Pestle::Grammar
+  # Base class for all grammar expressions.
+  class Expression
+    @tag: String?
+
+    attr_reader tag: String?
+
+    def initialize: (?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> Array[Expression]
+                
+    def tag_s: () -> String?
+
+    def tree_view: () -> String
+  end
+
+  # Base class for terminal expressions (those without children).
+  class Terminal < Expression
+    def children: () -> ::Array[Expression]
+  end
+
+  class RegexExpression < Terminal
+    @pattern: String
+
+    @re: Regexp
+
+    attr_reader pattern: String
+
+    attr_reader re: Regexp
+
+    def initialize: (String pattern, Regexp re) -> void
+
+    def to_s: () -> ::String
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+end

data/sig/grammar/group.rbs

@@ -0,0 +1,14 @@
+module Pestle::Grammar
+  # An expression surrounded by parentheses.
+  class Group < Expression
+    @expression: Expression
+
+    attr_reader expression: Expression
+
+    def initialize: (Expression expression, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+end

data/sig/grammar/identifier.rbs

@@ -0,0 +1,11 @@
+module Pestle::Grammar
+  class Identifier < Terminal
+    @value: String
+
+    attr_reader value: String
+
+    def initialize: (String value, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+end

data/sig/grammar/lexer.rbs

@@ -0,0 +1,85 @@
+module Pestle::Grammar
+  # Pest grammar tokenizer.
+  class Lexer
+    @grammar: String
+
+    @scanner: StringScanner
+
+    # Start of the current token as a byte index into grammar.
+    @start: Integer
+
+    # Tokens are arrays of (kind, value, start index).
+    # Sometimes we set value to `nil` when the symbol is unambiguous.
+    @tokens: Array[[Symbol, String?, Integer]]
+
+    attr_reader tokens: Array[[Symbol, String?, Integer]]
+
+    RE_WHITESPACE: ::Regexp
+
+    RE_LINE_COMMENT: ::Regexp
+
+    RE_BLOCK_COMMENT_START: ::Regexp
+
+    RE_BLOCK_COMMENT_END: ::Regexp
+
+    RE_BLOCK_COMMENT_CHUNK: ::Regexp
+
+    RE_GRAMMAR_DOC: ::Regexp
+
+    RE_RULE_DOC: ::Regexp
+
+    RE_IDENT: ::Regexp
+
+    RE_TAG: ::Regexp
+
+    RE_PUSH_LITERAL: ::Regexp
+
+    RE_PUSH: ::Regexp
+
+    RE_PEEK: ::Regexp
+
+    RE_PEEK_ALL: ::Regexp
+
+    RE_POP: ::Regexp
+
+    RE_POP_ALL: ::Regexp
+
+    RE_DROP: ::Regexp
+
+    RE_CHAR: ::Regexp
+
+    RE_INTEGER: ::Regexp
+
+    RE_RANGE_OP: ::Regexp
+
+    RE_NUMBER: ::Regexp
+
+    def self.tokenize: (String grammar) -> Array[[Symbol, String?, Integer]]
+
+    def initialize: (String grammar) -> void
+
+    def run: () -> void
+
+    def skip?: (Regexp regex) -> (true | false)
+
+    def skip_block_comment?: () -> (true | false)
+
+    def skip_trivia: () -> untyped
+
+    def lex_grammar: () -> void
+
+    def lex_rules: () -> void
+                
+    def accept_expression: () -> void
+                         
+    def accept_term: () -> void
+                   
+    def accept_terminal?: () -> bool
+                       
+    def accept_postfix_op: () -> void
+                         
+    def accept_string_literal?: () -> bool
+                             
+    def accept_ci_string_literal?: () -> bool
+  end
+end

data/sig/grammar/parser.rbs

@@ -0,0 +1,57 @@
+module Pestle::Grammar
+  # Pest grammar parser.
+  class Parser
+    @source: String
+
+    @tokens: Array[[Symbol, String?, Integer]]
+
+    @pos: Integer
+
+    @eof: [Symbol, String?, Integer]
+
+    PREC_LOWEST: Integer
+    PREC_CHOICE: Integer
+    PREC_SEQUENCE: Integer
+    PREC_PREFIX: Integer
+
+    PRECEDENCES: Hash[Symbol, Integer]
+
+    INFIX_OPERATORS: Set[Symbol]
+
+    def initialize: (String source, Array[[Symbol, String?, Integer]] tokens) -> void
+                  
+    RE_SLASH_X: Regexp
+    RE_SLASH_U: Regexp
+
+    def unescape: (String value, [Symbol, String?, Integer] token) -> String
+
+    # Return the current token without advancing the pointer.
+    # An EOF token is returned if there are no tokens left.
+    def current: () -> [Symbol, String?, Integer]
+
+    # Consume and return the next token.
+    def next: () -> [Symbol, String?, Integer]
+
+    def peek: (?::Integer offset) -> [Symbol, String?, Integer]
+
+    # Consume the next token if its kind matches _kind_, raise an error if it does not.
+    def eat: (Symbol kind, ?String? message) -> [Symbol, String?, Integer]
+
+    def parse: () -> [Hash[String, Rule], String?]
+
+    def parse_rules: () -> Hash[String, Rule]
+
+    def parse_modifier: () -> Integer
+
+    def parse_expression: (Integer precedence) -> Expression
+
+    def parse_infix_expression: (Expression left) -> Expression
+
+    def parse_postfix_expression: (Expression expr) -> Expression
+                                
+    def parse_repeat_expression: (Expression expr) -> Expression
+
+    def parse_peek_expression: (String? tag) -> Expression
+    
+  end
+end

data/sig/grammar/postfix.rbs

@@ -0,0 +1,112 @@
+module Pestle::Grammar
+  # An optional expression `<expression>?`.
+  class Optional < Expression
+    @expression: Expression
+
+    attr_reader expression: Expression
+
+    def initialize: (Expression expression) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  # An expression repeated zero or more times `<expression>*`.
+  class Repeat < Expression
+    @expression: Expression
+
+    attr_reader expression: Expression
+
+    def initialize: (Expression expression) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  # An expression repeated one or more times `<expression>+`.
+  class RepeatOnce < Expression
+    @expression: Expression
+
+    attr_reader expression: Expression
+
+    def initialize: (Expression expression) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  # An expression repeated a specified number of times `<expression>{n}`.
+  class RepeatExact < Expression
+    @expression: Expression
+
+    @number: Integer
+
+    attr_reader expression: Expression
+
+    attr_reader number: Integer
+
+    def initialize: (Expression expression, Integer number) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  # An expression repeated at least specified number of times `<expression>{n,}`.
+  class RepeatMin < Expression
+    @expression: Expression
+
+    @number: Integer
+
+    attr_reader expression: Expression
+
+    attr_reader number: Integer
+
+    def initialize: (Expression expression, Integer number) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  # An expression repeated at most specified number of times `<expression>{,n}`.
+  class RepeatMax < Expression
+    @expression: Expression
+
+    @number: Integer
+
+    attr_reader expression: Expression
+
+    attr_reader number: Integer
+
+    def initialize: (Expression expression, Integer number) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  # An expression repeated a specified range of times `<expression>{n,m}`.
+  class RepeatMinMax < Expression
+    @expression: Expression
+
+    @min: Integer
+
+    @max: Integer
+
+    attr_reader expression: Expression
+
+    attr_reader min: Integer
+
+    attr_reader max: Integer
+
+    def initialize: (Expression expression, Integer min, Integer max) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+end

data/sig/grammar/prefix.rbs

@@ -0,0 +1,27 @@
+module Pestle::Grammar
+  # A positive predicate expression `&<expression>`.
+  class PositivePredicate < Expression
+    @expression: Expression
+
+    attr_reader expression: Expression
+
+    def initialize: (Expression expression, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  # A negative predicate expression `!<expression>`.
+  class NegativePredicate < Expression
+    @expression: Expression
+
+    attr_reader expression: Expression
+
+    def initialize: (Expression expression, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+end

data/sig/grammar/range.rbs

@@ -0,0 +1,20 @@
+module Pestle::Grammar
+  class Range < Terminal
+    @start: String
+
+    @stop: String
+    
+    @re: Regexp
+
+    @s: String
+
+    attr_reader start: String
+
+    attr_reader stop: String
+
+    def initialize: (String start, String stop, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+end
+

data/sig/grammar/rule.rbs

@@ -0,0 +1,40 @@
+module Pestle::Grammar
+  class Rule < Expression
+    @name: String
+
+    @expression: Expression
+
+    @modifier: Integer
+
+    @doc: String?
+
+    attr_reader name: String
+
+    attr_reader modifier: Integer
+
+    attr_reader doc: String?
+
+    SILENT: Integer
+
+    ATOMIC: Integer
+
+    COMPOUND: Integer
+
+    NONATOMIC: Integer
+
+    SILENT_ATOMIC: Integer
+
+    SILENT_COMPOUND: Integer
+
+    SILENT_NONATOMIC: Integer
+
+    def initialize: (String name, Expression expression, ?modifier: Integer, ?doc: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  
+    def children: () -> ::Array[Expression]
+  end
+
+  class BuiltInRule < Rule
+  end
+end

data/sig/grammar/sequence.rbs

@@ -0,0 +1,14 @@
+module Pestle::Grammar
+  # The sequence operator `~`.
+  class Sequence < Expression
+    @expressions: Array[Expression]
+
+    attr_reader expressions: Array[Expression]
+
+    def initialize: (*Expression expressions) -> void
+                  
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> Array[Expression]
+  end
+end

data/sig/grammar/special.rbs

@@ -0,0 +1,39 @@
+module Pestle::Grammar
+  # A builtin rule matching any single Unicode character.
+  class Any < BuiltInRule
+    def initialize: () -> void
+  end
+
+  # A terminal expression matching any single Unicode character.
+  class AnyChar < Terminal
+    def to_s: () -> "ANY"
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  # A builtin rule matching the start of the input string.
+  class SOI < BuiltInRule
+    def initialize: () -> void
+  end
+
+  # A terminal expression matching the start of the input string.
+  class StartOfInput < Terminal
+    def to_s: () -> "SOI"
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  # A builtin rule matching the end of the input string.
+  class EOI < BuiltInRule
+    def initialize: () -> void
+  end
+
+  # A terminal expression matching the end of the input string.
+  class EndOfInput < Terminal
+    def to_s: () -> "EOI"
+            
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  SPECIAL_RULES: { "ANY" => Any, "SOI" => SOI, "EOI" => EOI }
+end

data/sig/grammar/stack.rbs

@@ -0,0 +1,57 @@
+module Pestle::Grammar
+  class PushLiteral < Terminal
+    @value: String
+
+    attr_reader value: String
+
+    def initialize: (String value, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  class Push < Expression
+    @expression: Expression
+
+    attr_reader expression: Expression
+
+    def initialize: (Expression expression, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+
+    def children: () -> ::Array[Expression]
+  end
+
+  class PeekSlice < Terminal
+    @start: Integer?
+
+    @stop: Integer?
+
+    attr_reader start: Integer?
+
+    attr_reader stop: Integer?
+
+    def initialize: (Integer? start, Integer? stop, ?tag: String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  class Peek < Terminal
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  class PeekAll < Terminal
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  class Pop < Terminal
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  class PopAll < Terminal
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  class Drop < Terminal
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+end

data/sig/grammar/string.rbs

@@ -0,0 +1,27 @@
+module Pestle::Grammar
+  class StringLiteral < Terminal
+    @value: ::String
+
+    @re: Regexp
+
+    attr_reader value: ::String
+
+    def initialize: (::String value, ?tag: ::String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+
+  class InsensitiveString < Terminal
+    @value: ::String
+
+    @re: Regexp
+
+    @s: String
+
+    attr_reader value: ::String
+
+    def initialize: (::String value, ?tag: ::String?) -> void
+
+    def parse: (Pestle::ParserState state, Array[Pestle::Pair] pairs) -> bool
+  end
+end

data/sig/grammar/unicode.rbs

@@ -0,0 +1,15 @@
+module Pestle::Grammar
+  # A builtin rule matching Unicode property.
+  class UnicodeRule < BuiltInRule
+    def initialize: (String name, Regexp re) -> void
+  end
+
+  GENERAL_CATEGORY_MAP: Hash[String, String]
+
+  BINARY_PROPERTY_MAP: Hash[String, String]
+
+  SCRIPT_NAMES: Array[String]
+
+  UNICODE_RULES: Hash[String, UnicodeRule]
+
+end