plurimath-parslet 3.0.0

data/spec/fixtures/examples/deepest_errors.rb

@@ -0,0 +1,99 @@
+# This example demonstrates how to do deepest error reporting, as invented
+# by John Mettraux (issue #64).
+
+require 'parslet'
+require 'parslet/convenience'
+
+def prettify(str)
+  puts " "*3 + " "*4 + "." + " "*4 + "10" + " "*3 + "." + " "*4 + "20"
+  str.lines.each_with_index do |line, index|
+    printf "%02d %s\n",
+      index+1,
+      line.chomp
+  end
+end
+
+class DeepestErrorsParser < 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

data/spec/fixtures/examples/documentation.rb

@@ -0,0 +1,32 @@
+require 'parslet'
+
+# A small example that shows a really small parser and what happens on parser
+# errors. This is used for documentation purposes to demonstrate basic
+# parslet functionality and error handling.
+
+module DocumentationExample
+  class MyParser < Parslet::Parser
+    rule(:a) { str('a').repeat }
+
+    def parse(str)
+      a.parse(str)
+    end
+  end
+
+  def self.parse_a_sequence(input)
+    parser = MyParser.new
+    parser.parse(input)
+  end
+
+  def self.demonstrate_success
+    parse_a_sequence('aaaa')
+  end
+
+  def self.demonstrate_failure
+    begin
+      parse_a_sequence('bbbb')
+    rescue Parslet::ParseFailed => e
+      e
+    end
+  end
+end

data/spec/fixtures/examples/email_parser.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+# Example contributed by Hal Brodigan (postmodern). Thanks!
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'parslet'
+require 'parslet/convenience'
+
+class EmailParser < Parslet::Parser
+  rule(:space) { match('\s').repeat(1) }
+  rule(:space?) { space.maybe }
+  rule(:dash?) { match['_-'].maybe }
+
+  rule(:at) {
+    str('@') |
+    (dash? >> (str('at') | str('AT')) >> dash?)
+  }
+  rule(:dot) {
+    str('.') |
+    (dash? >> (str('dot') | str('DOT')) >> dash?)
+  }
+
+  rule(:word) { match('[a-z0-9]').repeat(1).as(:word) >> space? }
+  rule(:separator) { dot.as(:dot) >> space? | space }
+  rule(:words) { word >> (separator >> word).repeat }
+
+  rule(:email) {
+    (words.as(:username) >> space? >> at >> space? >> words).as(:email)
+  }
+
+  root(:email)
+end
+
+class EmailSanitizer < Parslet::Transform
+  rule(:dot => simple(:dot), :word => simple(:word)) { ".#{word}" }
+  rule(:word => simple(:word)) { word }
+
+  rule(:username => sequence(:username)) { username.join + "@" }
+  rule(:username => simple(:username)) { username.to_s + "@" }
+
+  rule(:email => sequence(:email)) { email.join }
+end

data/spec/fixtures/examples/empty.rb

@@ -0,0 +1,10 @@
+# Basically just demonstrates that you can leave rules empty and get a nice
+# NotImplementedError. A way to quickly spec out your parser rules?
+
+require 'parslet'
+
+module EmptyExample
+  class MyParser < Parslet::Parser
+    rule(:empty) { }
+  end
+end

data/spec/fixtures/examples/erb.rb

@@ -0,0 +1,39 @@
+# Example that demonstrates how a simple erb-like parser could be constructed.
+
+require 'parslet'
+
+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
+
+class ErbTransform < Parslet::Transform
+  def initialize(binding_context = binding)
+    super()
+    @erb_binding = binding_context
+
+    # Define rules with closures that capture the binding
+    rule(:code => { :ruby => simple(:ruby) }) do |dict|
+      eval(dict[:ruby].to_s, @erb_binding)
+      ''
+    end
+
+    rule(:expression => { :ruby => simple(:ruby) }) do |dict|
+      eval(dict[:ruby].to_s, @erb_binding)
+    end
+  end
+
+  rule(:comment => { :ruby => simple(:ruby) }) { '' }
+  rule(:text => simple(:text)) { text }
+  rule(:text => sequence(:texts)) { texts.join }
+end

data/spec/fixtures/examples/ip_address.rb

@@ -0,0 +1,103 @@
+# This example is heavily inspired by citrus' ip.citrus. Have a look at both
+# of these to get some choice!
+
+# The grammars in this file conform to the ABNF given in Appendix A of RFC 3986
+# Uniform Resource Identifier (URI): Generic Syntax.
+#
+# See http://tools.ietf.org/html/rfc3986#appendix-A for more information.
+
+require 'parslet'
+
+module IpAddressExample
+  module IPv4
+    include Parslet
+
+    # A host identified by an IPv4 literal address is represented in
+    # dotted-decimal notation (a sequence of four decimal numbers in the range 0
+    # to 255, separated by "."), as described in [RFC1123] by reference to
+    # [RFC0952].  Note that other forms of dotted notation may be interpreted on
+    # some platforms, as described in Section 7.4, but only the dotted-decimal
+    # form of four octets is allowed by this grammar.
+    rule(:ipv4) {
+      (dec_octet >> str('.') >> dec_octet >> str('.') >>
+        dec_octet >> str('.') >> dec_octet).as(:ipv4)
+    }
+
+    rule(:dec_octet) {
+      str('25') >> match("[0-5]") |
+      str('2') >> match("[0-4]") >> digit |
+      str('1') >> digit >> digit |
+      match('[1-9]') >> digit |
+      digit
+    }
+
+    rule(:digit) {
+      match('[0-9]')
+    }
+  end
+
+  # Must be used in concert with IPv4
+  module IPv6
+    include Parslet
+
+    rule(:colon) { str(':') }
+    rule(:dcolon) { colon >> colon }
+
+    # h16 :
+    def h16r(times)
+      (h16 >> colon).repeat(times, times)
+    end
+
+    # : h16
+    def h16l(times)
+      (colon >> h16).repeat(0,times)
+    end
+
+    # A 128-bit IPv6 address is divided into eight 16-bit pieces. Each piece is
+    # represented numerically in case-insensitive hexadecimal, using one to four
+    # hexadecimal digits (leading zeroes are permitted). The eight encoded
+    # pieces are given most-significant first, separated by colon characters.
+    # Optionally, the least-significant two pieces may instead be represented in
+    # IPv4 address textual format. A sequence of one or more consecutive
+    # zero-valued 16-bit pieces within the address may be elided, omitting all
+    # their digits and leaving exactly two consecutive colons in their place to
+    # mark the elision.
+    rule(:ipv6) {
+      (
+        (
+          h16r(6) |
+          dcolon >> h16r(5) |
+          h16.maybe >> dcolon >> h16r(4) |
+          (h16 >> h16l(1)).maybe >> dcolon >> h16r(3) |
+          (h16 >> h16l(2)).maybe >> dcolon >> h16r(2) |
+          (h16 >> h16l(3)).maybe >> dcolon >> h16r(1) |
+          (h16 >> h16l(4)).maybe >> dcolon
+        ) >> ls32 |
+        (h16 >> h16l(5)).maybe >> dcolon >> h16 |
+        (h16 >> h16l(6)).maybe >> dcolon
+      ).as(:ipv6)
+    }
+
+    rule(:h16) {
+      hexdigit.repeat(1,4)
+    }
+
+    rule(:ls32) {
+      (h16 >> colon >> h16) |
+      ipv4
+    }
+
+    rule(:hexdigit) {
+      digit | match("[a-fA-F]")
+    }
+  end
+
+  class Parser
+    include IPv4
+    include IPv6
+
+    def parse(str)
+      (ipv4 | ipv6).parse(str)
+    end
+  end
+end

data/spec/fixtures/examples/json.rb

@@ -0,0 +1,107 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+#
+# MIT License - (c) 2011 John Mettraux
+#
+
+require 'rubygems'
+require 'parslet' # gem install parslet
+
+
+module MyJson
+
+  class Parser < Parslet::Parser
+
+    rule(:spaces) { match('\s').repeat(1) }
+    rule(:spaces?) { spaces.maybe }
+
+    rule(:comma) { spaces? >> str(',') >> spaces? }
+    rule(:digit) { match('[0-9]') }
+
+    rule(:number) {
+      (
+        str('-').maybe >> (
+          str('0') | (match('[1-9]') >> digit.repeat)
+        ) >> (
+          str('.') >> digit.repeat(1)
+        ).maybe >> (
+          match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+        ).maybe
+      ).as(:number)
+    }
+
+    rule(:string) {
+      str('"') >> (
+        str('\\') >> any | str('"').absent? >> any
+      ).repeat.as(:string) >> str('"')
+    }
+
+    rule(:array) {
+      str('[') >> spaces? >>
+      (value >> (comma >> value).repeat).maybe.as(:array) >>
+      spaces? >> str(']')
+    }
+
+    rule(:object) {
+      str('{') >> spaces? >>
+      (entry >> (comma >> entry).repeat).maybe.as(:object) >>
+      spaces? >> str('}')
+    }
+
+    rule(:value) {
+      string | number |
+      object | array |
+      str('true').as(:true) | str('false').as(:false) |
+      str('null').as(:null)
+    }
+
+    rule(:entry) {
+      (
+         string.as(:key) >> spaces? >>
+         str(':') >> spaces? >>
+         value.as(:val)
+      ).as(:entry)
+    }
+
+    rule(:attribute) { (entry | value).as(:attribute) }
+
+    rule(:top) { spaces? >> value >> spaces? }
+
+    root(:top)
+  end
+
+  class Transformer < Parslet::Transform
+
+    class Entry < Struct.new(:key, :val); end
+
+    rule(:array => subtree(:ar)) {
+      ar.is_a?(Array) ? ar : [ ar ]
+    }
+    rule(:object => subtree(:ob)) {
+      (ob.is_a?(Array) ? ob : [ ob ]).inject({}) { |h, e| h[e.key] = e.val; h }
+    }
+
+    rule(:entry => { :key => simple(:ke), :val => simple(:va) }) {
+      Entry.new(ke, va)
+    }
+
+    rule(:string => simple(:st)) {
+      st.to_s
+    }
+    rule(:number => simple(:nb)) {
+      nb.match(/[eE\.]/) ? Float(nb) : Integer(nb)
+    }
+
+    rule(:null => simple(:nu)) { nil }
+    rule(:true => simple(:tr)) { true }
+    rule(:false => simple(:fa)) { false }
+  end
+
+  def self.parse(s)
+    parser = Parser.new
+    transformer = Transformer.new
+
+    tree = parser.parse(s)
+    transformer.apply(tree)
+  end
+end

data/spec/fixtures/examples/local.rb

@@ -0,0 +1,60 @@
+# An exploration of two ideas:
+#   a) Constructing a whole parser inline, without the artificial class around
+#      it.
+# and:
+#   b) Constructing non-greedy or non-blind parsers by transforming the
+#      grammar.
+
+require 'parslet'
+
+module LocalExample
+  extend Parslet
+
+  def self.this(name, &block)
+    Parslet::Atoms::Entity.new(name, &block)
+  end
+
+  def self.epsilon
+    any.absent?
+  end
+
+  # Traditional repetition will try as long as the pattern can be matched and
+  # then give up. This is greedy and blind.
+  def self.greedy_blind_parser
+    str('a').as(:e) >> this('a') { greedy_blind_parser }.as(:rec) | epsilon
+  end
+
+  # Here's a pattern match that is greedy and non-blind. The first pattern
+  # 'a'* will be tried as many times as possible, while still matching the
+  # end pattern 'aa'.
+  def self.greedy_non_blind_parser
+    str('aa').as(:e2) >> epsilon | str('a').as(:e1) >> this('b') { greedy_non_blind_parser }.as(:rec)
+  end
+
+  # Simple inline parser without class wrapper - fixed to prevent infinite loops
+  # This parser matches exactly 'aa' or 'aaa' or longer sequences ending in 'aa'
+  def self.simple_inline_parser
+    str('aa') | str('aaa') | str('aaaa') | str('aaaaa') | str('aaaaaa')
+  end
+
+  def self.parse_with_greedy_blind(input)
+    greedy_blind_parser.parse(input)
+  end
+
+  def self.parse_with_greedy_non_blind(input)
+    greedy_non_blind_parser.parse(input)
+  end
+
+  def self.parse_with_simple_inline(input)
+    simple_inline_parser.parse(input)
+  end
+
+  def self.demonstrate_local_variables
+    # Demonstrates local variable usage in parser construction
+    pattern_a = str('a')
+    pattern_aa = str('aa')
+    # Use a simple combination that works reliably
+    combined = pattern_aa | pattern_a >> pattern_aa | pattern_a >> pattern_a >> pattern_aa
+    combined
+  end
+end

data/spec/fixtures/examples/mathn.rb

@@ -0,0 +1,47 @@
+# Demonstrates that we have a compatibility fix to mathn's weird idea of 
+# integer mathematics. 
+# This was contributed by Jonathan Hinkle (https://github.com/hynkle). Thanks!
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parslet'
+require 'parslet/convenience'
+include Parslet
+
+def attempt_parse
+  possible_whitespace = match['\s'].repeat
+
+  cephalopod =
+    str('octopus') |
+    str('squid')
+
+  parenthesized_cephalopod =
+    str('(') >>
+    possible_whitespace >>
+    cephalopod >>
+    possible_whitespace >>
+    str(')')
+
+  parser =
+    possible_whitespace >>
+    parenthesized_cephalopod >>
+    possible_whitespace
+
+  # This parse fails, but that is not the point. When mathn is in the current
+  # ruby environment, it modifies integer division in a way that makes 
+  # parslet loop indefinitely.
+  parser.parse %{(\nsqeed)\n}
+rescue Parslet::ParseFailed
+end
+
+attempt_parse 
+puts 'it terminates before we require mathn'
+
+puts "requiring mathn now"
+# mathn was deprecated as of Ruby 2.5
+if RUBY_VERSION.gsub(/[^\d]/, '').to_i < 250
+  require 'mathn'
+end
+puts "and trying again (will hang without the fix)"
+attempt_parse # but it doesn't terminate after requiring mathn
+puts "okay!"

data/spec/fixtures/examples/minilisp.rb

@@ -0,0 +1,75 @@
+# Reproduces [1] using parslet.
+# [1] http://thingsaaronmade.com/blog/a-quick-intro-to-writing-a-parser-using-treetop.html
+
+require 'pp'
+require 'parslet'
+require 'parslet/export'
+require 'parslet/convenience'
+
+module MiniLisp
+  class Parser < Parslet::Parser
+    root :expression
+    rule(:expression) {
+      space? >> str('(') >> space? >> body >> str(')') >> space?
+    }
+
+    rule(:body) {
+      (expression | identifier | float | integer | string).repeat.as(:exp)
+    }
+
+    rule(:space) {
+      match('\s').repeat(1)
+    }
+    rule(:space?) {
+      space.maybe
+    }
+
+    rule(:identifier) {
+      (match('[a-zA-Z=*]') >> match('[a-zA-Z=*_]').repeat).as(:identifier) >> space?
+    }
+
+    rule(:float) {
+      (
+        integer >> (
+          str('.') >> match('[0-9]').repeat(1) |
+          str('e') >> match('[0-9]').repeat(1)
+        ).as(:e)
+      ).as(:float) >> space?
+    }
+
+    rule(:integer) {
+      ((str('+') | str('-')).maybe >> match("[0-9]").repeat(1)).as(:integer) >> space?
+    }
+
+    rule(:string) {
+      str('"') >> (
+        str('\\') >> any |
+        str('"').absent? >> any
+      ).repeat.as(:string) >> str('"') >> space?
+    }
+  end
+
+  class Transform
+    include Parslet
+
+    attr_reader :t
+    def initialize
+      @t = Parslet::Transform.new
+
+      # To understand these, take a look at what comes out of the parser.
+      t.rule(:identifier => simple(:ident)) { ident.to_sym }
+
+      t.rule(:string => simple(:str))       { str }
+
+      t.rule(:integer => simple(:int))      { Integer(int) }
+
+      t.rule(:float=>{:integer=> simple(:a), :e=> simple(:b)}) { Float(a + b) }
+
+      t.rule(:exp => subtree(:exp))         { exp }
+    end
+
+    def do(tree)
+      t.apply(tree)
+    end
+  end
+end

data/spec/fixtures/examples/modularity.rb

@@ -0,0 +1,60 @@
+require 'parslet'
+
+# Demonstrates modular parsers, split out over many classes. Please look at
+# ip_address.rb as well.
+
+module ModularityExample
+  module ALanguage
+    include Parslet
+
+    # Parslet rules are really a special kind of method. Mix them into your
+    # classes!
+    rule(:a_language) { str('aaa') }
+  end
+
+  # Parslet parsers are parslet atoms as well. Create an instance and chain them
+  # to your other rules.
+  #
+  class BLanguage < Parslet::Parser
+    root :blang
+
+    rule(:blang) { str('bbb') }
+  end
+
+  # Parslet atoms are really Ruby values, pass them around.
+  def self.c_language
+    Parslet.str('ccc')
+  end
+
+  class Language < Parslet::Parser
+    def initialize(c_language)
+      @c_language = c_language
+      super()
+    end
+
+    root :root
+
+    include ALanguage
+
+    rule(:root) { str('a(') >> a_language >> str(')') >> space |
+                  str('b(') >> BLanguage.new >> str(')') >> space |
+                  str('c(') >> @c_language >> str(')') >> space }
+    rule(:space) { str(' ').maybe }
+  end
+
+  def self.parse_a_language(input = 'a(aaa)')
+    Language.new(c_language).parse(input)
+  end
+
+  def self.parse_b_language(input = 'b(bbb)')
+    Language.new(c_language).parse(input)
+  end
+
+  def self.parse_c_language(input = 'c(ccc)')
+    Language.new(c_language).parse(input)
+  end
+
+  def self.create_parser
+    Language.new(c_language)
+  end
+end