Class: Fast::ExpressionParser

Inherits:
Object
  • Object
show all
Defined in:
lib/fast.rb

Overview

ExpressionParser empowers the AST search in Ruby. All classes inheriting Fast::Find have a grammar shortcut that is processed here.

Examples:

find a simple int node

Fast.expression("int")
# => #<Fast::Find:0x00007ffae39274e0 @token="int">

parens make the expression an array of Fast::Find and children classes

Fast.expression("(int _)")
# => [#<Fast::Find:0x00007ffae3a860e8 @token="int">, #<Fast::Find:0x00007ffae3a86098 @token="_">]

not int token

Fast.expression("!int")
# => #<Fast::Not:0x00007ffae43f35b8 @token=#<Fast::Find:0x00007ffae43f35e0 @token="int">>

int or float token

Fast.expression("{int float}")
# => #<Fast::Any:0x00007ffae43bbf00 @token=[
#      #<Fast::Find:0x00007ffae43bbfa0 @token="int">,
#      #<Fast::Find:0x00007ffae43bbf50 @token="float">
#     #]>

capture something not nil

Fast.expression("$_")
# => #<Fast::Capture:0x00007ffae433a860 @captures=[], @token=#<Fast::Find:0x00007ffae433a888 @token="_">>

capture a hash with keys that all are not string and not symbols

Fast.expression("(hash (pair ([!sym !str] _))")
# => [#<Fast::Find:0x00007ffae3b45010 @token="hash">,
#      [#<Fast::Find:0x00007ffae3b44f70 @token="pair">,
#       [#<Fast::All:0x00007ffae3b44cf0 @token=[
#         #<Fast::Not:0x00007ffae3b44e30 @token=#<Fast::Find:0x00007ffae3b44e80 @token="sym">>,
#         #<Fast::Not:0x00007ffae3b44d40 @token=#<Fast::Find:0x00007ffae3b44d68 @token="str">>]>,
#         #<Fast::Find:0x00007ffae3b44ca0 @token="_">]]]")")

of match using string expression

Fast.match?(Fast.ast("{1 => 1}"),"(hash (pair ([!sym !str] _))") => true")")

Instance Method Summary collapse

Constructor Details

#initialize(expression) ⇒ ExpressionParser

Returns a new instance of ExpressionParser.

Parameters:

  • expression (String) 


471
472
473
474
 
# File 'lib/fast.rb', line 471

def initialize(expression)
  @tokens = expression.scan TOKENIZER
  @nesting = []
end

Instance Method Details

#error_message ⇒ Object 



512
513
514
515
516
517
518
 
# File 'lib/fast.rb', line 512

def error_message
  if @tokens.any?
    "Unconsumed tokens after parsing: #{@tokens.join(' ')}"
  elsif @nesting.any?
    "Unclosed nesting: expected #{@nesting.reverse.join(', ')}"
  end
end

#parse ⇒ Object

rubocop:disable Metrics/CyclomaticComplexity rubocop:disable Metrics/AbcSize rubocop:disable Metrics/MethodLength



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
 
# File 'lib/fast.rb', line 479

def parse
  case (token = next_token)
  when '('
    @nesting << ')'
    parse_until_peek(')')
  when '{'
    @nesting << '}'
    Any.new(parse_until_peek('}'))
  when '['
    @nesting << ']'
    All.new(parse_until_peek(']'))
  when ')', '}', ']'
    raise SyntaxError, "Unexpected token: #{token}"
  when /^"/ then FindString.new(token[1..-2])
  when /^#\w/ then MethodCall.new(token[1..])
  when /^\.\w[\w\d_]+\?/ then InstanceMethodCall.new(token[1..])
  when '$' then Capture.new(parse)
  when '!' then (@tokens.any? && !closing_token?(@tokens.first) ? Not.new(parse) : Find.new(token))
  when '?' then Maybe.new(parse)
  when '^' then Parent.new(parse)
  when '\\' then FindWithCapture.new(parse)
  when /^%\d/ then FindFromArgument.new(token[1..])
  when ';'
    raise SyntaxError, "Semicolons are not allowed in patterns: #{token}"
  when nil then nil
  else Find.new(token)
  end
end

#tokens_left? ⇒ Boolean

Returns:

  • (Boolean) 


508
509
510
 
# File 'lib/fast.rb', line 508

def tokens_left?
  @tokens.any? || @nesting.any?
end