plurimath-parslet 3.0.0

data/spec/fixtures/examples/nested_errors.rb

@@ -0,0 +1,95 @@
+require 'parslet'
+require 'parslet/convenience'
+
+# This example demonstrates tree error reporting in a real life example.
+# The parser code has been contributed by John Mettraux.
+
+module NestedErrorsExample
+  def self.prettify(str)
+    lines = []
+    lines << " "*3 + " "*4 + "." + " "*4 + "10" + " "*3 + "." + " "*4 + "20"
+    str.lines.each_with_index do |line, index|
+      lines << sprintf("%02d %s", index+1, line.chomp)
+    end
+    lines.join("\n")
+  end
+
+  class Parser < Parslet::Parser
+    # commons
+    rule(:space) { match('[ \t]').repeat(1) }
+    rule(:space?) { space.maybe }
+
+    rule(:newline) { match('[\r\n]') }
+
+    rule(:comment) { str('#') >> match('[^\r\n]').repeat }
+
+    rule(:line_separator) {
+      (space? >> ((comment.maybe >> newline) | str(';')) >> space?).repeat(1)
+    }
+
+    rule(:blank) { line_separator | space }
+    rule(:blank?) { blank.maybe }
+
+    rule(:identifier) { match('[a-zA-Z0-9_]').repeat(1) }
+
+    # res_statement
+    rule(:reference) {
+      (str('@').repeat(1,2) >> identifier).as(:reference)
+    }
+
+    rule(:res_action_or_link) {
+      str('.').as(:dot) >> (identifier >> str('?').maybe ).as(:name) >> str('()')
+    }
+
+    rule(:res_actions) {
+      (
+        reference
+      ).as(:resources) >>
+      (
+        res_action_or_link.as(:res_action)
+      ).repeat(0).as(:res_actions)
+    }
+
+    rule(:res_statement) {
+      res_actions >>
+      (str(':') >> identifier.as(:name)).maybe.as(:res_field)
+    }
+
+    # expression
+    rule(:expression) {
+      res_statement
+    }
+
+    # body
+    rule(:body) {
+      (line_separator >> (block | expression)).repeat(1).as(:body) >>
+      line_separator
+    }
+
+    # blocks
+    rule(:begin_block) {
+      (str('concurrent').as(:type) >> space).maybe.as(:pre) >>
+      str('begin').as(:begin) >>
+      body >>
+      str('end')
+    }
+
+    rule(:define_block) {
+      str('define').as(:define) >> space >>
+      identifier.as(:name) >> str('()') >>
+      body >>
+      str('end')
+    }
+
+    rule(:block) {
+      define_block | begin_block
+    }
+
+    # root
+    rule(:radix) {
+      line_separator.maybe >> block >> line_separator.maybe
+    }
+
+    root(:radix)
+  end
+end

data/spec/fixtures/examples/optimized_erb.rb

@@ -0,0 +1,105 @@
+require 'parslet'
+
+# This example shows how to optimize an ERB like parser using parslet.
+# Please also look at the more naive 'erb.rb' for comparison.
+
+module OptimizedErbExample
+  class ErbParser < Parslet::Parser
+    rule(:ruby) { (str('%>').absent? >> any).repeat.as(:ruby) }
+
+    rule(:expression) { (str('=') >> ruby).as(:expression) }
+    rule(:comment) { (str('#') >> ruby).as(:comment) }
+    rule(:code) { ruby.as(:code) }
+    rule(:erb) { expression | comment | code }
+
+    rule(:erb_with_tags) { str('<%') >> erb >> str('%>') }
+    rule(:text) { (str('<%').absent? >> any).repeat(1) }
+
+    rule(:text_with_ruby) { (text.as(:text) | erb_with_tags).repeat.as(:text) }
+    root(:text_with_ruby)
+  end
+
+  def self.parse_erb_content(content)
+    parser = ErbParser.new
+    parser.parse(content)
+  end
+
+  def self.parse_big_erb_file
+    content = <<~ERB_CONTENT
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+      <%= erb tag %>
+
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+    ERB_CONTENT
+    parse_erb_content(content)
+  end
+end

data/spec/fixtures/examples/parens.rb

@@ -0,0 +1,25 @@
+# A small example that demonstrates the power of tree pattern matching. Also
+# uses '.as(:name)' to construct a tree that can reliably be matched
+# afterwards.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+
+module LISP # as in 'lots of insipid and stupid parenthesis'
+  class Parser < Parslet::Parser
+    rule(:balanced) {
+      str('(').as(:l) >> balanced.maybe.as(:m) >> str(')').as(:r)
+    }
+
+    root(:balanced)
+  end
+
+  class Transform < Parslet::Transform
+    rule(:l => '(', :m => simple(:x), :r => ')') {
+      # innermost :m will contain nil
+      x.nil? ? 1 : x+1
+    }
+  end
+end

data/spec/fixtures/examples/prec_calc.rb

@@ -0,0 +1,71 @@
+
+# A demonstration of the new precedence climbing infix expression parser. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'rspec'
+require 'parslet'
+require 'parslet/rig/rspec'
+require 'parslet/convenience'
+
+class InfixExpressionParser < Parslet::Parser
+  root :variable_assignment_list
+
+  rule(:space) { match[' '] }
+
+  def cts atom
+    atom >> space.repeat
+  end
+  def infix *args
+    Infix.new(*args)
+  end
+
+  # This is the heart of the infix expression parser: real simple definitions
+  # for all the pieces we need. 
+  rule(:mul_op) { cts match['*/'] }
+  rule(:add_op) { cts match['+-'] }
+  rule(:digit) { match['0-9'] }
+  rule(:integer) { cts digit.repeat(1).as(:int) }
+
+  rule(:expression) { infix_expression(integer, 
+    [mul_op, 2, :left], 
+    [add_op, 1, :right]) }
+
+  # And now adding variable assignments to that, just to a) demonstrate this
+  # embedded in a bigger parser, and b) make the example interesting. 
+  rule(:variable_assignment_list) { 
+    variable_assignment.repeat(1) }
+  rule(:variable_assignment) {
+    identifier.as(:ident) >> equal_sign >> expression.as(:exp) >> eol }
+  rule(:identifier) {
+    cts (match['a-z'] >> match['a-zA-Z0-9'].repeat) }
+  rule(:equal_sign) {
+    cts str('=') }
+  rule(:eol) {
+    cts(str("\n")) | any.absent? }
+end
+
+class InfixInterpreter < Parslet::Transform
+  rule(int: simple(:int)) { Integer(int) }
+  rule(ident: simple(:ident), exp: simple(:result)) { |d| 
+    d[:doc][d[:ident].to_s.strip.to_sym] = d[:result] }
+
+  rule(l: simple(:l), o: /^\*/, r: simple(:r)) { l * r }
+  rule(l: simple(:l), o: /^\+/, r: simple(:r)) { l + r }
+end
+
+input = <<ASSIGNMENTS
+a = 1
+b = 2
+c = 3 * 25
+d = 100 + 3*4
+ASSIGNMENTS
+
+puts input
+
+int_tree = InfixExpressionParser.new.parse_with_debug(input)
+bindings = {}
+result   = InfixInterpreter.new.apply(int_tree, doc: bindings)
+
+pp bindings

data/spec/fixtures/examples/readme.rb

@@ -0,0 +1,59 @@
+require 'parslet'
+
+module ReadmeExample
+  include Parslet
+
+  # Basic parslet examples from the readme
+  class SimpleStringParser < Parslet::Parser
+    root :simple_string
+
+    rule(:simple_string) { quote >> content >> quote }
+    rule(:quote) { str('"') }
+    rule(:content) { (quote.absent? >> any).repeat }
+  end
+
+  class SmalltalkParser < Parslet::Parser
+    root :smalltalk
+
+    rule(:smalltalk) { statements }
+    rule(:statements) {
+      # Simple implementation for demo purposes
+      str('smalltalk')
+    }
+  end
+
+  # Demonstrate basic parslet functionality
+  def self.demo_basic_parsing
+    # String parsing
+    foo_parser = Parslet.str('foo')
+    foo_result = foo_parser.parse('foo')
+
+    # Character set matching
+    abc_parser = Parslet.match('[abc]')
+    a_result = abc_parser.parse('a')
+    b_result = abc_parser.parse('b')
+    c_result = abc_parser.parse('c')
+
+    # Annotation
+    annotated_parser = Parslet.str('foo').as(:important_bit)
+    annotated_result = annotated_parser.parse('foo')
+
+    {
+      foo: foo_result,
+      a: a_result,
+      b: b_result,
+      c: c_result,
+      annotated: annotated_result
+    }
+  end
+
+  def self.demo_simple_string
+    quote = Parslet.str('"')
+    simple_string = quote >> (quote.absent? >> Parslet.any).repeat >> quote
+    simple_string.parse('"Simple Simple Simple"')
+  end
+
+  def self.demo_smalltalk
+    SmalltalkParser.new.parse('smalltalk')
+  end
+end

data/spec/fixtures/examples/scopes.rb

@@ -0,0 +1,43 @@
+require 'parslet'
+
+# Demonstrates scope handling in parslet - how captures can be scoped
+# and how dynamic parsing can access captured values.
+
+module ScopesExample
+  def self.create_parser
+    Parslet.str('a').capture(:a) >> Parslet.scope { Parslet.str('b').capture(:a) } >>
+      Parslet.dynamic { |s,c| Parslet.str(c.captures[:a]) }
+  end
+
+  def self.parse_scoped_input(input = 'aba')
+    parser = create_parser
+    parser.parse(input)
+  end
+
+  def self.demonstrate_scope_success
+    parse_scoped_input('aba')
+  end
+
+  def self.demonstrate_scope_failure
+    begin
+      parse_scoped_input('abc')
+    rescue Parslet::ParseFailed => e
+      e
+    end
+  end
+
+  # Simpler nested scope example that actually works
+  def self.create_nested_scope_parser
+    Parslet.str('x').capture(:outer) >>
+      Parslet.scope {
+        Parslet.str('y').capture(:outer) >>
+        Parslet.dynamic { |s,c| Parslet.str(c.captures[:outer]) }
+      } >>
+      Parslet.dynamic { |s,c| Parslet.str(c.captures[:outer]) }
+  end
+
+  def self.parse_nested_scoped_input(input = 'xyyx')
+    parser = create_nested_scope_parser
+    parser.parse(input)
+  end
+end

data/spec/fixtures/examples/seasons.rb

@@ -0,0 +1,40 @@
+require 'parslet'
+
+module SeasonsExample
+  class Spring < Parslet::Transform
+    rule(:stem => sequence(:branches)) {
+      {:stem => (branches + [{:branch => :leaf}])}
+    }
+  end
+
+  class Summer < Parslet::Transform
+    rule(:stem => subtree(:branches)) {
+      new_branches = branches.map { |b| {:branch => [:leaf, :flower]} }
+      {:stem => new_branches}
+    }
+  end
+
+  class Fall < Parslet::Transform
+    rule(:branch => sequence(:x)) {
+      x.each { |e| puts "Fruit!" if e==:flower }
+      x.each { |e| puts "Falling Leaves!" if e==:leaf }
+      {:branch => []}
+    }
+  end
+
+  class Winter < Parslet::Transform
+    rule(:stem => subtree(:x)) {
+      {:stem => []}
+    }
+  end
+
+  def self.do_seasons(tree)
+    [Spring, Summer, Fall, Winter].each do |season|
+      p "And when #{season} comes"
+      tree = season.new.apply(tree)
+      pp tree
+      puts
+    end
+    tree
+  end
+end

data/spec/fixtures/examples/sentence.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+# A small example contributed by John Mettraux (jmettraux) that demonstrates
+# working with Unicode. This only works on Ruby 1.9.
+
+require 'parslet'
+
+module SentenceExample
+  class MyParser < Parslet::Parser
+    rule(:sentence) { (match('[^。]').repeat(1) >> str("。")).as(:sentence) }
+    rule(:sentences) { sentence.repeat }
+    root(:sentences)
+  end
+
+  class Transformer < Parslet::Transform
+    rule(:sentence => simple(:sen)) { sen.to_s }
+  end
+end

data/spec/fixtures/examples/simple_xml.rb

@@ -0,0 +1,51 @@
+# A simple xml parser. It is simple in the respect as that it doesn't address
+# any of the complexities of XML. This is ruby 1.9.
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parslet'
+
+class XML < Parslet::Parser
+  root :document
+
+  rule(:document) {
+    tag(close: false).as(:o) >> document.as(:i) >> tag(close: true).as(:c) |
+    text
+  }
+
+  # Perhaps we could have some syntax sugar to make this more easy?
+  #
+  def tag(opts={})
+    close = opts[:close] || false
+
+    parslet = str('<')
+    parslet = parslet >> str('/') if close
+    parslet = parslet >> (str('>').absent? >> match("[a-zA-Z]")).repeat(1).as(:name)
+    parslet = parslet >> str('>')
+
+    parslet
+  end
+
+  rule(:text) {
+    match('[^<>]').repeat(0)
+  }
+end
+
+def check(xml)
+  r = XML.new.parse(xml)
+
+  # We'll validate the tree by reducing valid pairs of tags into simply the
+  # string "verified". If the transformation ends on a string, then the
+  # document was 'valid'.
+  #
+  t = Parslet::Transform.new do
+    rule(
+      o: {name: simple(:tag)},
+      c: {name: simple(:tag)},
+      i: simple(:t)
+    ) { 'verified' }
+  end
+
+  t.apply(r)
+end

data/spec/fixtures/examples/string_parser.rb

@@ -0,0 +1,77 @@
+# A more complex parser that illustrates how a compiler might be constructed.
+# The parser recognizes strings and integer literals and constructs almost a
+# useful AST from the file contents. 
+
+require 'pp'
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'parslet'
+
+include Parslet
+
+class LiteralsParser < Parslet::Parser
+  rule :space do
+    (match '[ ]').repeat(1)
+  end
+  
+  rule :literals do
+    (literal >> eol).repeat
+  end
+  
+  rule :literal do
+    (integer | string).as(:literal) >> space.maybe
+  end
+  
+  rule :string do
+    str('"') >> 
+    (
+      (str('\\') >> any) |
+      (str('"').absent? >> any)
+    ).repeat.as(:string) >> 
+    str('"')
+  end
+  
+  rule :integer do
+    match('[0-9]').repeat(1).as(:integer)
+  end
+  
+  rule :eol do
+    line_end.repeat(1)
+  end
+  
+  rule :line_end do
+    crlf >> space.maybe
+  end
+  
+  rule :crlf do
+    match('[\r\n]').repeat(1)
+  end
+
+  root :literals
+end
+
+input_name = File.join(File.dirname(__FILE__), 'simple.lit')
+file = File.read(input_name)
+
+parsetree = LiteralsParser.new.parse(file)
+  
+class Lit < Struct.new(:text)
+  def to_s
+    text.inspect
+  end
+end
+class StringLit < Lit
+end
+class IntLit < Lit
+  def to_s
+    text
+  end
+end
+
+transform = Parslet::Transform.new do
+  rule(:literal => {:integer => simple(:x)}) { IntLit.new(x) }
+  rule(:literal => {:string => simple(:s)}) { StringLit.new(s) }
+end
+  
+ast = transform.apply(parsetree)
+pp ast

data/spec/parslet/atom_results_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Result of a Parslet#parse' do
+  include Parslet; extend Parslet
+
+  describe 'regression' do
+    [
+      # Behaviour with maybe-nil
+      [str('foo').maybe >> str('bar'), 'bar', 'bar'],
+      [str('bar') >> str('foo').maybe, 'bar', 'bar'],
+
+      # These might be hard to understand; look at the result of
+      #   str.maybe >> str
+      # and
+      #   str.maybe >> str first.
+      [(str('f').maybe >> str('b')).repeat, 'bb', 'bb'],
+      [(str('b') >> str('f').maybe).repeat, 'bb', 'bb'],
+
+      [str('a').as(:a) >> (str('b') >> str('c').as(:a)).repeat, 'abc',
+       [{ a: 'a' }, { a: 'c' }]],
+
+      [str('a').as(:a).repeat >> str('b').as(:b).repeat, 'ab', [{ a: 'a' }, { b: 'b' }]],
+
+      # Repetition behaviour / named vs. unnamed
+      [str('f').repeat, '', ''],
+      [str('f').repeat.as(:f), '', { f: [] }],
+
+      # Maybe behaviour / named vs. unnamed
+      [str('f').maybe, '', ''],
+      [str('f').maybe.as(:f), '', { f: nil }],
+    ].each do |parslet, input, result|
+      context parslet.inspect.to_s do
+        it "parses \"#{input}\" into \"#{result}\"" do
+          expect(parslet.parse(input)).to eq(result)
+        end
+      end
+    end
+  end
+end

data/spec/parslet/atoms/alternative_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Alternative do
+  include Parslet
+  
+  describe '| shortcut' do
+    let(:alternative) { str('a') | str('b') }
+    
+    context "when chained with different atoms" do
+      before(:each) { 
+        # Chain something else to the alternative parslet. If it modifies the
+        # parslet atom in place, we'll notice: 
+        
+        alternative | str('d')
+      }
+      let!(:chained) { alternative | str('c') }
+      
+      
+      it "is side-effect free" do
+        chained.should parse('c')
+        chained.should parse('a')
+        chained.should_not parse('d')
+      end 
+    end
+  end
+end