predicator 1.2.1 → 2.0.0

data/lib/predicator/parser.rb

@@ -1,442 +1,221 @@
-#
-# DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.14
-# from Racc grammer file "".
-#
+# frozen_string_literal: true
+
+require_relative "values"
+require_relative "errors"
+require_relative "float_text"
+require_relative "duration_text"
+require_relative "lexer"
+require_relative "ast"
+require_relative "parser/token_text"
+require_relative "parser/operators"
+require_relative "parser/postfix"
+require_relative "parser/primaries"
+require_relative "parser/durations"
+require_relative "parser/statements"
 
-require 'racc/parser.rb'
-
-require "predicator/lexer.rex"
-require "predicator/visitors"
-require "predicator/ast"
 module Predicator
-  class Parser < Racc::Parser
-
-    def initialize
-      @lexer = Lexer.new
-    end
-
-    def parse string
-      @lexer.parse string
-      do_parse
-    end
-
-    def next_token
-      @lexer.next_token
-    end
-
-    def on_error type, val, values
-      super
-    rescue Racc::ParseError
-      trace = values.each_with_index.map{|l, i| "#{' ' * i}#{l}"}
-      raise ParseError, "\nparse error on value #{val.inspect}\n#{trace.join("\n")}"
+  # The compiler's second stage: the token stream the {Lexer} answers in,
+  # the reference's syntax tree ({Ast}) out, or the one refusal that stopped
+  # it. It is a recursive descent over the reference's grammar, with its
+  # precedence, lowest first:
+  #
+  #     program        -> statement ( ";" statement )* ";"?
+  #     statement      -> if | while | location "=" expression | expression
+  #     expression     -> logical_or
+  #     logical_or     -> logical_and ( ( "OR" | "||" ) logical_and )*
+  #     logical_and    -> logical_not ( ( "AND" | "&&" ) logical_not )*
+  #     logical_not    -> ( "NOT" | "!" ) logical_not | comparison
+  #     comparison     -> addition ( comparison_op | "in" | "contains" ) addition )?
+  #     addition       -> multiplication ( ( "+" | "-" ) multiplication )*
+  #     multiplication -> unary ( ( "*" | "/" | "%" ) unary )*
+  #     unary          -> ( "-" | "!" ) unary | postfix
+  #     postfix        -> primary ( "[" expression "]" | "." name | "::" type )*
+  #
+  # The binary operators associate to the left; a comparison takes one
+  # operator at most, so a second is a token after a finished expression.
+  # A statement ending in a closing brace needs no separator before the
+  # next; a program holds one statement at least.
+  #
+  # A refusal is a {Lexer::Refusal}: a {Predicator::ParseError} carrying the
+  # reference's message, the position and span of the token it names, and a
+  # reason, which is this package's token for the refusal. Nothing raises.
+  #
+  # One refusal is not the reference's, which follows a source as deep as it
+  # nests: a source that nests more than {DEPTH_LIMIT} levels is refused
+  # with the reason `nesting_depth_exceeded`, at the token the descent
+  # stopped on, rather than left to exhaust the stack. A level is counted
+  # each time the descent re-enters the whole expression (inside a
+  # parenthesis, a list, an object, an index, a call's arguments, a
+  # statement's condition or value), for each prefix operator, a relative
+  # date's operand, a block's statements, an `else if` and a statement's
+  # assignment probe; a chain of left-associative operators or of postfix
+  # steps is read in a loop and costs none. Where the stack a parse runs on
+  # is too small to reach the limit, as a Fiber's default stack is, the
+  # source is refused under the same reason at the token the stack ran out
+  # on, with a message saying so, rather than raising.
+  #
+  # The module holds no state; each call parses with its own {Descent}. It
+  # is private to the package.
+  module Parser
+    # How many levels a source may nest, the whole expression counting as
+    # the first. A source at exactly this depth parses. It is above the 300
+    # parentheses the reference's compile transcript compiles, and below
+    # the depth the costliest nesting reaches on a thread's default stack.
+    DEPTH_LIMIT = 400
+
+    # The seven scalar type names a cast may name, in the reference's order.
+    CAST_TYPE_NAMES = %w[integer float string boolean date datetime duration].freeze
+
+    # The tag a refusal is thrown with, to the catch around a parse or a
+    # probe.
+    REFUSED = :refused
+
+    # Parses one expression.
+    #
+    # @param tokens [Array<Lexer::Token>] a stream the lexer answered, which
+    #   ends in its `:eof` token
+    # @return [Object, Lexer::Refusal] the expression's {Ast} node, or the
+    #   refusal
+    def self.parse(tokens) = Descent.new(tokens).whole_expression
+
+    # Parses a program: one or more statements.
+    #
+    # @param tokens [Array<Lexer::Token>] a stream the lexer answered, which
+    #   ends in its `:eof` token
+    # @return [Ast::Program, Lexer::Refusal] the program, or the refusal
+    def self.parse_program(tokens) = Descent.new(tokens).whole_program
+
+    # One parse of one token stream: the tokens, the cursor and how many
+    # productions are open. A refusal is thrown to the catch around the
+    # whole parse (or around the assignment probe that discards it) and is
+    # never seen outside this class.
+    class Descent
+      include TokenText
+      include Operators
+      include Postfix
+      include Primaries
+      include Durations
+      include Statements
+
+      def initialize(tokens)
+        @tokens = tokens
+        @index = 0
+        @depth = 0
+      end
+
+      # @return [Object, Lexer::Refusal]
+      def whole_expression
+        guarded do
+          node = expression
+          trailing = peek
+          refuse("trailing_token", "Unexpected token #{describe(trailing)} after expression", trailing) unless at?(:eof)
+          node
+        end
+      end
+
+      # @return [Ast::Program, Lexer::Refusal]
+      def whole_program
+        guarded do
+          start = start_of(peek)
+          statements = statement_sequence(:eof)
+          after_statement(peek) unless at?(:eof)
+          Ast::Program.new(statements:, position: start,
+                           span: between(statements.first.span.start, statements.last.span.end))
+        end
+      end
+
+      private
+
+      # The parse in the block, or the refusal it threw; a stack exhausted
+      # short of the depth limit is refused where it ran out.
+      def guarded(&)
+        catch(REFUSED, &)
+      rescue SystemStackError
+        catch(REFUSED) do
+          refuse("nesting_depth_exceeded", "Expression nests deeper than the stack this parse runs on can follow, " \
+                                           "short of the depth limit of #{DEPTH_LIMIT} levels", peek)
+        end
+      end
+
+      def peek = @tokens[@index]
+
+      def previous = @tokens[@index - 1]
+
+      def at?(type) = peek.type == type
+
+      def advance
+        token = peek
+        @index += 1
+        token
+      end
+
+      # The token, consumed, when it is of the type given; the refusal
+      # naming it otherwise.
+      def expect(type, reason, message)
+        refuse(reason, "#{message} #{describe(peek)}", peek) unless at?(type)
+        advance
+      end
+
+      # Reads one production one level deeper, or refuses at the token the
+      # descent stopped on when the source is already at the limit.
+      def descend
+        enter
+        yield
+      ensure
+        @depth -= 1
+      end
+
+      # The whole expression, one level deeper. It is the production read most
+      # often, so it counts its own level rather than through a block.
+      def expression
+        enter
+        logical_or
+      ensure
+        @depth -= 1
+      end
+
+      # Counts one more open production; the ensure of whoever called it counts
+      # it back, the refusal included.
+      def enter
+        @depth += 1
+        return if @depth <= DEPTH_LIMIT
+
+        refuse("nesting_depth_exceeded", "Expression nests past the depth limit of #{DEPTH_LIMIT} levels, " \
+                                         "the whole expression counting as the first", peek)
+      end
+
+      # Throws the refusal: its position is its span's start.
+      def refuse(reason, message, token, span = span_of(token))
+        error = ParseError.new(reason:, message:, position: span.start)
+        throw REFUSED, Lexer::Refusal.new(error:, span:)
+      end
+
+      def start_of(token) = Position.new(line: token.line, column: token.column)
+
+      # One past the token's last character; a string token, which may hold
+      # a line feed, carries its own.
+      def end_of(token) = token.end_position || Position.new(line: token.line, column: token.column + token.length)
+
+      def span_of(token) = Lexer::Span.new(start: start_of(token), end: end_of(token))
+
+      # A node's own token, as its position and its span.
+      def leaf(token) = { position: start_of(token), span: span_of(token) }
+
+      # From an opening token to past its closing one.
+      def delimited(open, close) = { position: start_of(open), span: between(start_of(open), end_of(close)) }
+
+      # From a node's start to past a token.
+      def reaching(node, token) = between(node.span.start, end_of(token))
+
+      # From a prefix token to its operand's end.
+      def prefixed(token, operand) = { position: start_of(token), span: between(start_of(token), operand.span.end) }
+
+      # An infix node: at its operator, over its operands.
+      def infix(token, left, right) = { position: start_of(token), span: between(left.span.start, right.span.end) }
+
+      def between(start, finish) = Lexer::Span.new(start:, end: finish)
     end
-
-##### State transition tables begin ###
-
-racc_action_table = [
-     6,     7,    10,     6,     7,    10,     9,    15,    31,     9,
-     6,     7,    10,     6,     7,    10,     9,    16,    17,     9,
-    16,    17,    14,    16,    17,    14,    52,     6,     7,    10,
-    25,    28,    14,     9,    53,    14,    20,    21,    22,    23,
-    24,    18,    19,    37,    57,    38,    39,    41,    38,    14,
-    26,    27,    16,    17,    37,    38,    56,    39,    41,    37,
-    38,    60,    39,    41,    37,    38,    70,    39,    41,    72,
-    71,    16,    17,    73,    58,    59,    37,    38,    39,    41,
-    61,    52,    37,    37,    38 ]
-
-racc_action_check = [
-     0,     0,     0,     9,     9,     9,     0,     1,    15,     9,
-    10,    10,    10,    16,    16,    16,    10,    29,    29,    16,
-     1,     1,     0,    32,    32,     9,    24,    17,    17,    17,
-     8,     8,    10,    17,    25,    16,     8,     8,     8,     8,
-     8,     8,     8,    23,    30,    26,    23,    23,    27,    17,
-     8,     8,    30,    30,    20,    20,    28,    20,    20,    21,
-    21,    48,    21,    21,    22,    22,    62,    22,    22,    64,
-    62,    33,    33,    64,    40,    40,    52,    52,    61,    61,
-    49,    53,    60,    71,    73 ]
-
-racc_action_pointer = [
-    -2,     7,   nil,   nil,   nil,   nil,   nil,   nil,    21,     1,
-     8,   nil,   nil,   nil,   nil,     8,    11,    25,   nil,   nil,
-    32,    37,    42,    21,    20,    15,    22,    25,    32,     4,
-    39,   nil,    10,    58,   nil,   nil,   nil,   nil,   nil,   nil,
-    47,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    48,    67,
-   nil,   nil,    54,    75,   nil,   nil,   nil,   nil,   nil,   nil,
-    60,    53,    59,   nil,    62,   nil,   nil,   nil,   nil,   nil,
-   nil,    61,   nil,    61,   nil,   nil ]
-
-racc_action_default = [
-   -48,   -48,    -1,    -2,    -3,    -4,    -5,    -6,    -7,   -48,
-   -48,   -14,   -15,   -16,   -46,   -48,   -48,   -48,   -11,   -12,
-   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,    -8,
-   -48,    76,    -9,   -10,   -17,   -23,   -30,   -40,   -41,   -42,
-   -48,   -45,   -18,   -24,   -31,   -19,   -25,   -32,   -48,   -48,
-   -21,   -26,   -48,   -48,   -28,   -29,   -47,   -13,   -43,   -44,
-   -48,   -48,   -48,   -35,   -48,   -38,   -22,   -27,   -20,   -33,
-   -34,   -48,   -37,   -48,   -36,   -39 ]
-
-racc_goto_table = [
-    35,    43,    46,    62,    50,    51,    54,    55,    34,    42,
-    45,    48,     1,    36,    44,    47,    49,    64,   nil,   nil,
-   nil,    29,    30,   nil,   nil,   nil,   nil,   nil,    32,    33,
-   nil,   nil,    65,    66,    67,   nil,   nil,   nil,   nil,   nil,
-    63,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    68,   nil,
-   nil,   nil,   nil,    75,    69,   nil,   nil,   nil,   nil,    74 ]
-
-racc_goto_check = [
-    12,    12,    12,    15,    11,    13,    12,    12,    10,    10,
-    10,    10,     1,    14,    14,    14,    14,    16,   nil,   nil,
-   nil,     1,     1,   nil,   nil,   nil,   nil,   nil,     1,     1,
-   nil,   nil,    12,    11,    13,   nil,   nil,   nil,   nil,   nil,
-    10,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,   nil,
-   nil,   nil,   nil,    12,    14,   nil,   nil,   nil,   nil,    10 ]
-
-racc_goto_pointer = [
-   nil,    12,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   -12,   -20,   -20,   -19,    -7,   -49,   -35,   nil ]
-
-racc_goto_default = [
-   nil,   nil,     2,     3,     4,     5,     8,    11,    12,    13,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,    40 ]
-
-racc_reduce_table = [
-  0, 0, :racc_error,
-  1, 32, :_reduce_none,
-  1, 32, :_reduce_none,
-  1, 32, :_reduce_none,
-  1, 32, :_reduce_none,
-  1, 33, :_reduce_5,
-  1, 33, :_reduce_6,
-  1, 33, :_reduce_7,
-  2, 34, :_reduce_8,
-  3, 34, :_reduce_9,
-  3, 34, :_reduce_10,
-  2, 34, :_reduce_11,
-  2, 34, :_reduce_12,
-  3, 35, :_reduce_13,
-  1, 36, :_reduce_none,
-  1, 36, :_reduce_none,
-  1, 36, :_reduce_none,
-  3, 38, :_reduce_17,
-  3, 38, :_reduce_18,
-  3, 38, :_reduce_19,
-  5, 38, :_reduce_20,
-  3, 38, :_reduce_21,
-  4, 38, :_reduce_22,
-  3, 39, :_reduce_23,
-  3, 39, :_reduce_24,
-  3, 39, :_reduce_25,
-  3, 39, :_reduce_26,
-  4, 39, :_reduce_27,
-  3, 39, :_reduce_28,
-  3, 39, :_reduce_29,
-  3, 40, :_reduce_30,
-  3, 40, :_reduce_31,
-  3, 40, :_reduce_32,
-  5, 40, :_reduce_33,
-  3, 42, :_reduce_34,
-  1, 46, :_reduce_none,
-  3, 46, :_reduce_36,
-  3, 44, :_reduce_37,
-  1, 47, :_reduce_none,
-  3, 47, :_reduce_39,
-  1, 41, :_reduce_40,
-  1, 43, :_reduce_41,
-  1, 45, :_reduce_42,
-  2, 45, :_reduce_43,
-  2, 45, :_reduce_44,
-  1, 48, :_reduce_45,
-  1, 37, :_reduce_46,
-  3, 37, :_reduce_47 ]
-
-racc_reduce_n = 48
-
-racc_shift_n = 76
-
-racc_token_table = {
-  false => 0,
-  :error => 1,
-  :TRUE => 2,
-  :FALSE => 3,
-  :LPAREN => 4,
-  :RPAREN => 5,
-  :LBRACKET => 6,
-  :RBRACKET => 7,
-  :BANG => 8,
-  :NOT => 9,
-  :DOT => 10,
-  :COMMA => 11,
-  :AT => 12,
-  :AND => 13,
-  :OR => 14,
-  :EQ => 15,
-  :GT => 16,
-  :LT => 17,
-  :BETWEEN => 18,
-  :IN => 19,
-  :PRESENT => 20,
-  :BLANK => 21,
-  :INTEGER => 22,
-  :STRING => 23,
-  :IDENTIFIER => 24,
-  :DATE => 25,
-  :DURATION => 26,
-  :AGO => 27,
-  :FROMNOW => 28,
-  :STARTSWITH => 29,
-  :ENDSWITH => 30 }
-
-racc_nt_base = 31
-
-racc_use_result_var = false
-
-Racc_arg = [
-  racc_action_table,
-  racc_action_check,
-  racc_action_default,
-  racc_action_pointer,
-  racc_goto_table,
-  racc_goto_check,
-  racc_goto_default,
-  racc_goto_pointer,
-  racc_nt_base,
-  racc_reduce_table,
-  racc_token_table,
-  racc_shift_n,
-  racc_reduce_n,
-  racc_use_result_var ]
-
-Racc_token_to_s_table = [
-  "$end",
-  "error",
-  "TRUE",
-  "FALSE",
-  "LPAREN",
-  "RPAREN",
-  "LBRACKET",
-  "RBRACKET",
-  "BANG",
-  "NOT",
-  "DOT",
-  "COMMA",
-  "AT",
-  "AND",
-  "OR",
-  "EQ",
-  "GT",
-  "LT",
-  "BETWEEN",
-  "IN",
-  "PRESENT",
-  "BLANK",
-  "INTEGER",
-  "STRING",
-  "IDENTIFIER",
-  "DATE",
-  "DURATION",
-  "AGO",
-  "FROMNOW",
-  "STARTSWITH",
-  "ENDSWITH",
-  "$start",
-  "predicate",
-  "boolean_predicate",
-  "logical_predicate",
-  "group_predicate",
-  "comparison_predicate",
-  "variable",
-  "integer_comparison_predicate",
-  "string_comparison_predicate",
-  "date_comparison_predicate",
-  "integer",
-  "integer_array",
-  "string",
-  "string_array",
-  "date",
-  "integer_array_contents",
-  "string_array_contents",
-  "duration" ]
-
-Racc_debug_parser = false
-
-##### State transition tables end #####
-
-# reduce 0 omitted
-
-# reduce 1 omitted
-
-# reduce 2 omitted
-
-# reduce 3 omitted
-
-# reduce 4 omitted
-
-def _reduce_5(val, _values)
- AST::True.new true 
-end
-
-def _reduce_6(val, _values)
- AST::False.new false 
-end
-
-def _reduce_7(val, _values)
- AST::BooleanVariable.new val.first 
-end
-
-def _reduce_8(val, _values)
- AST::Not.new val.last 
-end
-
-def _reduce_9(val, _values)
- AST::And.new val.first, val.last 
-end
-
-def _reduce_10(val, _values)
- AST::Or.new val.first, val.last 
-end
-
-def _reduce_11(val, _values)
- AST::Present.new val.first 
-end
-
-def _reduce_12(val, _values)
- AST::Blank.new val.first 
-end
-
-def _reduce_13(val, _values)
- AST::Group.new val[1] 
-end
-
-# reduce 14 omitted
-
-# reduce 15 omitted
-
-# reduce 16 omitted
-
-def _reduce_17(val, _values)
- AST::IntegerEqual.new val.first, val.last 
-end
-
-def _reduce_18(val, _values)
- AST::IntegerGreaterThan.new val.first, val.last 
-end
-
-def _reduce_19(val, _values)
- AST::IntegerLessThan.new val.first, val.last 
+    private_constant :Descent
+  end
+  private_constant :Parser
 end
-
-def _reduce_20(val, _values)
- AST::IntegerBetween.new val.first, val[2], val.last 
-end
-
-def _reduce_21(val, _values)
- AST::IntegerIn.new val.first, val.last 
-end
-
-def _reduce_22(val, _values)
- AST::IntegerNotIn.new val.first, val.last 
-end
-
-def _reduce_23(val, _values)
- AST::StringEqual.new val.first, val.last 
-end
-
-def _reduce_24(val, _values)
- AST::StringGreaterThan.new val.first, val.last 
-end
-
-def _reduce_25(val, _values)
- AST::StringLessThan.new val.first, val.last 
-end
-
-def _reduce_26(val, _values)
- AST::StringIn.new val.first, val.last 
-end
-
-def _reduce_27(val, _values)
- AST::StringNotIn.new val.first, val.last 
-end
-
-def _reduce_28(val, _values)
- AST::StringStartsWith.new val.first, val.last 
-end
-
-def _reduce_29(val, _values)
- AST::StringEndsWith.new val.first, val.last 
-end
-
-def _reduce_30(val, _values)
- AST::DateEqual.new val.first, val.last 
-end
-
-def _reduce_31(val, _values)
- AST::DateGreaterThan.new val.first, val.last 
-end
-
-def _reduce_32(val, _values)
- AST::DateLessThan.new val.first, val.last 
-end
-
-def _reduce_33(val, _values)
- AST::DateBetween.new val.first, val[2], val.last 
-end
-
-def _reduce_34(val, _values)
- AST::IntegerArray.new val[1] 
-end
-
-# reduce 35 omitted
-
-def _reduce_36(val, _values)
- [val.first, val.last].flatten 
-end
-
-def _reduce_37(val, _values)
- AST::StringArray.new val[1] 
-end
-
-# reduce 38 omitted
-
-def _reduce_39(val, _values)
- [val.first, val.last].flatten 
-end
-
-def _reduce_40(val, _values)
- AST::Integer.new val.first.to_i 
-end
-
-def _reduce_41(val, _values)
- AST::String.new val.first 
-end
-
-def _reduce_42(val, _values)
- AST::Date.new val.first 
-end
-
-def _reduce_43(val, _values)
- AST::DateAgo.new val.first 
-end
-
-def _reduce_44(val, _values)
- AST::DateFromNow.new val.first 
-end
-
-def _reduce_45(val, _values)
- AST::Duration.new val.first 
-end
-
-def _reduce_46(val, _values)
- AST::Variable.new val.first 
-end
-
-def _reduce_47(val, _values)
- AST::Variable.new [val.first, val.last].flatten.join(".") 
-end
-
-def _reduce_none(val, _values)
-  val[0]
-end
-
-  end   # class Parser
-  end   # module Predicator

data/lib/predicator/result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Predicator
+  # What a call answers: a value, or an error value saying why there is none.
+  # Results are values, never raised; each entry point's raising variant
+  # raises {Predicator::Error} carrying the same error instead.
+  #
+  # A successful result's value may itself be nil (predicator's null), so
+  # {#ok?} is read from the error, not from the value.
+  #
+  # @!attribute [r] value
+  #   @return [Object] the answer; nil when the result failed
+  # @!attribute [r] error
+  #   @return [Object, nil] the error value; nil when the result succeeded
+  Result = Data.define(:value, :error) do
+    # @raise [ArgumentError] when it carries both a value and an error
+    def initialize(value:, error:)
+      raise ArgumentError, "a result carries a value or an error, not both" unless value.nil? || error.nil?
+
+      super
+    end
+
+    # @return [Boolean] whether the call succeeded
+    def ok? = error.nil?
+  end
+
+  # The two ways the package builds a {Result}. Private to the package: a
+  # host reads results and does not need to make them (Result.new and
+  # Result[] stay public, as Data defines them).
+  module Results
+    module_function
+
+    # A successful result.
+    def ok(value) = Result.new(value:, error: nil)
+
+    # A failed result.
+    #
+    # @raise [ArgumentError] when error is nil
+    def failure(error)
+      raise ArgumentError, "a failed result carries an error" if error.nil?
+
+      Result.new(value: nil, error:)
+    end
+  end
+  private_constant :Results
+end