parslet 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d212114155ea2fce120ce17157dcd10a9bb81ebf
-  data.tar.gz: 07ad0296a6bea037a87594ffc565429b39e6258b
+  metadata.gz: 546221c33c4829eb1bede8a241b40418197462de
+  data.tar.gz: d440cbbac367cf7909bdeeb764b431bc3a32bdf7
 SHA512:
-  metadata.gz: 704d66fde31caf3741fa202d2ac56eaf410ec3ed0cf9050bc834af92a115d847a14e72d61cd97b44c60ba8bc1e50bf792cfadff3257e2b789a7bc9550d0b944a
-  data.tar.gz: 6ae7e679bfe78d0de4f6c66f4d096f2985b23ece311d5705deb5fe9098ce516ba4d6a7ecb2df7f34d942c7c2370dac3b075d0a6c168e887ac1bdbbdc020a21b2
+  metadata.gz: adae2aa91f57458cf679d60c3aefd5545a02f99895745cfc61e05290e86cae69adc1b38c121756e96beb4c6ffb4bce375af04e39050ecfe59154ecd3e187a76a
+  data.tar.gz: f8eeac537a6b4dcc958efeb1355d4ad6040e88e91efa2e0397706803ba58c42f69b970720b62cae7f29ff550f50e652c984853af41cab31da7a6ebb4cccbc4ae

data/README

@@ -70,4 +70,4 @@ STATUS
 
 Production worthy.
 
-(c) 2010-2014 Kaspar Schiess
+(c) 2010-2016 Kaspar Schiess

data/lib/parslet/context.rb

@@ -21,7 +21,7 @@ class Parslet::Context < BlankSlate
   include Parslet
   
   def meta_def(name, &body)
-    metaclass = class <<self; self; end
+    metaclass = class << self; self; end
 
     metaclass.send(:define_method, name, &body)
   end

data/lib/parslet/parser.rb

@@ -30,7 +30,7 @@
 class Parslet::Parser < Parslet::Atoms::Base
   include Parslet
 
-  class <<self # class methods
+  class << self # class methods
     # Define the parsers #root function. This is the place where you start 
     # parsing; if you have a rule for 'file' that describes what should be 
     # in a file, this would be your root declaration: 

data/parslet.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = 'parslet'
+  s.version = '1.7.1'
+
+  s.authors = ['Kaspar Schiess']
+  s.email = 'kaspar.schiess@absurd.li'
+  s.extra_rdoc_files = ['README']
+  s.files = %w(HISTORY.txt LICENSE Rakefile README parslet.gemspec) + Dir.glob("{lib,spec,example}/**/*")
+  s.homepage = 'http://kschiess.github.io/parslet'
+  s.license = 'MIT'
+  s.rdoc_options = ['--main', 'README']
+  s.require_paths = ['lib']
+  s.summary = 'Parser construction library with great error reporting in Ruby.'  
+  
+  s.add_dependency 'blankslate', '>= 2.0', '<= 4.0'
+end

data/spec/acceptance/examples_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'open3'
+
+describe "Regression on" do
+  Dir["example/*.rb"].each do |example|
+    context example do
+      # Generates a product path for a given example file. 
+      def product_path(str, ext)
+        str.
+          gsub('.rb', ".#{ext}").
+          gsub('example/','example/output/')
+      end
+      
+      it "runs successfully" do
+        stdin, stdout, stderr = Open3.popen3("ruby #{example}")
+        
+        handle_map = {
+          stdout => :out, 
+          stderr => :err
+        }
+        expectation_found = handle_map.any? do |io, ext|
+          name = product_path(example, ext)
+          
+          if File.exists?(name)
+            io.read.strip.should == File.read(name).strip
+            true
+          end
+        end
+        
+        unless expectation_found
+          fail "Example doesn't have either an .err or an .out file. "+
+            "Please create in examples/output!"
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/infix_parser_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe 'Infix expression parsing' do
+  class InfixExpressionParser < Parslet::Parser
+    rule(:space) { match['\s'] }
+
+    def cts atom
+      atom >> space.repeat
+    end
+    def infix *args
+      Infix.new(*args)
+    end
+
+    rule(:mul_op) { match['*/'] >> str(' ').maybe }
+    rule(:add_op) { match['+-'] >> str(' ').maybe }
+    rule(:digit) { match['0-9'] }
+    rule(:integer) { cts digit.repeat(1) }
+
+    rule(:expression) { infix_expression(integer, 
+      [mul_op, 2, :left], 
+      [add_op, 1, :right]) }
+  end
+
+  let(:p) { InfixExpressionParser.new }
+  describe '#integer' do
+    let(:i) { p.integer }
+    it "parses integers" do
+      i.should parse('1')
+      i.should parse('123')
+    end 
+    it "consumes trailing white space" do
+      i.should parse('1   ')
+      i.should parse('134   ')
+    end 
+    it "doesn't parse floats" do
+      i.should_not parse('1.3')
+    end 
+  end
+  describe '#multiplication' do
+    let(:m) { p.expression }
+    it "parses simple multiplication" do
+      m.should parse('1*2').as(l: '1', o: '*', r: '2')
+    end
+    it "parses simple multiplication with spaces" do
+      m.should parse('1 * 2').as(l: '1 ', o: '* ', r: '2')
+    end
+    it "parses division" do
+      m.should parse('1/2')
+    end 
+  end
+  describe '#addition' do
+    let(:a) { p.expression }
+    
+    it "parses simple addition" do
+      a.should parse('1+2')
+    end 
+    it "parses complex addition" do
+      a.should parse('1+2+3-4')
+    end
+    it "parses a single element" do
+      a.should parse('1')
+    end
+  end
+
+  describe 'mixed operations' do
+    let(:mo) { p.expression }
+
+    describe 'inspection' do
+      it 'produces useful expressions' do
+        p.expression.parslet.inspect.should == 
+          "infix_expression(INTEGER, [MUL_OP, ADD_OP])"
+      end
+    end
+    describe 'right associativity' do
+      it 'produces trees that lean right' do
+        mo.should parse('1+2+3').as(
+          l: '1', o: '+', r: {l: '2', o: '+', r: '3'})
+      end      
+    end
+    describe 'left associativity' do
+      it 'produces trees that lean left' do
+        mo.should parse('1*2*3').as(
+          l: {l:'1', o:'*', r:'2'}, o:'*', r:'3')
+      end      
+    end
+    describe 'error handling' do
+      describe 'incomplete expression' do
+        it 'produces the right error' do
+          cause = catch_failed_parse {
+            mo.parse('1+') }
+
+          cause.ascii_tree.to_s.should == <<-ERROR
+INTEGER was expected at line 1 char 3.
+`- Failed to match sequence (DIGIT{1, } SPACE{0, }) at line 1 char 3.
+   `- Expected at least 1 of DIGIT at line 1 char 3.
+      `- Premature end of input at line 1 char 3.
+          ERROR
+        end
+      end
+      describe 'invalid operator' do
+        it 'produces the right error' do
+          cause = catch_failed_parse {
+            mo.parse('1%') }
+
+          cause.ascii_tree.to_s.should == <<-ERROR
+Don't know what to do with "%" at line 1 char 2.
+          ERROR
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/regression_spec.rb

@@ -0,0 +1,314 @@
+# Encoding: UTF-8
+
+require 'spec_helper'
+
+require 'parslet'
+
+describe "Regressions from real examples" do
+  # This parser piece produces on the left a subtree that is keyed (a hash)
+  # and on the right a subtree that is a repetition of such subtrees. I've
+  # for now decided that these would merge into the repetition such that the
+  # return value is an array. This avoids maybe loosing keys/values in a 
+  # hash merge. 
+  #
+  class ArgumentListParser
+    include Parslet
+
+    rule :argument_list do
+      expression.as(:argument) >> 
+        (comma >> expression.as(:argument)).repeat
+    end
+    rule :expression do
+      string
+    end
+    rule :string do
+      str('"') >> 
+      (
+        str('\\') >> any |
+        str('"').absent? >> any
+      ).repeat.as(:string) >>
+      str('"') >> space?
+    end
+    rule :comma do
+      str(',') >> space?
+    end
+    rule :space? do
+      space.maybe
+    end
+    rule :space do
+      match("[ \t]").repeat(1)
+    end
+    
+    def parse(str)
+      argument_list.parse(str)
+    end
+  end
+  describe ArgumentListParser do
+    let(:instance) { ArgumentListParser.new }
+    it "should have method expression" do
+      instance.should respond_to(:expression)
+    end 
+    it 'should parse "arg1", "arg2"' do
+      result = ArgumentListParser.new.parse('"arg1", "arg2"')
+      
+      result.size.should == 2
+      result.each do |r|
+        r[:argument]
+      end
+    end
+    it 'should parse "arg1", "arg2", "arg3"' do
+      result = ArgumentListParser.new.parse('"arg1", "arg2", "arg3"')
+      
+      result.size.should == 3
+      result.each do |r|
+        r[:argument]
+      end
+    end
+  end
+
+  class ParensParser < Parslet::Parser
+    rule(:balanced) {
+      str('(').as(:l) >> balanced.maybe.as(:m) >> str(')').as(:r)
+    }
+  
+    root(:balanced)
+  end
+  describe ParensParser do
+    let(:instance) { ParensParser.new }
+    
+    context "statefulness: trying several expressions in sequence" do
+      it "should not be stateful" do
+        # NOTE: Since you've come here to read this, I'll explain why
+        # this is broken and not fixed: You're looking at the tuning branch, 
+        # which rewrites a bunch of stuff - so I have failing tests to 
+        # remind me of what is left to be done. And to remind you not to 
+        # trust this code. 
+        instance.parse('(())')
+        lambda {
+          instance.parse('((()))')
+          instance.parse('(((())))')
+        }.should_not raise_error
+      end 
+    end
+    context "expression '(())'" do
+      let(:result) { instance.parse('(())') }
+
+      it "should yield a doubly nested hash" do
+        result.should be_a(Hash)
+        result.should have_key(:m)
+        result[:m].should be_a(Hash)   # This was an array earlier
+      end 
+      context "inner hash" do
+        let(:inner) { result[:m] }
+        
+        it "should have nil as :m" do
+          inner[:m].should be_nil
+        end 
+      end
+    end
+  end
+
+  class ALanguage < Parslet::Parser
+    root(:expressions)
+
+    rule(:expressions) { (line >> eol).repeat(1) | line }
+    rule(:line) { space? >> an_expression.as(:exp).repeat }
+    rule(:an_expression) { str('a').as(:a) >> space? }
+
+    rule(:eol) { space? >> match["\n\r"].repeat(1) >> space? }
+
+    rule(:space?) { space.repeat }
+    rule(:space) { multiline_comment.as(:multi) | line_comment.as(:line) | str(' ') }
+
+    rule(:line_comment) { str('//') >> (match["\n\r"].absent? >> any).repeat }
+    rule(:multiline_comment) { str('/*') >> (str('*/').absent? >> any).repeat >> str('*/') }
+  end
+  describe ALanguage do
+    def remove_indent(s)
+      s.to_s.lines.map { |l| l.chomp.strip }.join("\n")
+    end
+    
+    it "should count lines correctly" do
+      cause = catch_failed_parse {
+        subject.parse('a
+          a a a 
+          aaa // ff
+          /* 
+          a
+          */
+          b
+        ')
+      }
+
+      remove_indent(cause.ascii_tree).should == remove_indent(%q(
+      Expected one of [(LINE EOL){1, }, LINE] at line 1 char 1.
+      |- Extra input after last repetition at line 7 char 11.
+      |  `- Failed to match sequence (LINE EOL) at line 7 char 11.
+      |     `- Failed to match sequence (SPACE? [\n\r]{1, } SPACE?) at line 7 char 11.
+      |        `- Expected at least 1 of [\n\r] at line 7 char 11.
+      |           `- Failed to match [\n\r] at line 7 char 11.
+      `- Don't know what to do with "\n         " at line 1 char 2.).strip)
+    end 
+  end
+
+  class BLanguage < Parslet::Parser
+    root :expression
+    rule(:expression) { b.as(:one) >> b.as(:two) }
+    rule(:b) { str('b') }
+  end
+  describe BLanguage do
+    it "should parse 'bb'" do
+      subject.should parse('bb').as(:one => 'b', :two => 'b')
+    end 
+    it "should transform with binding constraint" do
+      transform = Parslet::Transform.new do |t|
+        t.rule(:one => simple(:b), :two => simple(:b)) { :ok }
+      end
+      transform.apply(subject.parse('bb')).should == :ok
+    end 
+  end
+
+  class UnicodeLanguage < Parslet::Parser
+    root :gobble
+    rule(:gobble) { any.repeat }
+  end
+  describe UnicodeLanguage do
+    it "should parse UTF-8 strings" do
+      subject.should parse('éèäöü').as('éèäöü')
+      subject.should parse('RubyKaigi2009のテーマは、「変わる／変える」です。 前回の').as('RubyKaigi2009のテーマは、「変わる／変える」です。 前回の')
+    end 
+  end
+  
+  class UnicodeSentenceLanguage < Parslet::Parser
+    rule(:sentence) { (match('[^。]').repeat(1) >> str("。")).as(:sentence) }
+    rule(:sentences) { sentence.repeat }
+    root(:sentences)
+  end
+  describe UnicodeSentenceLanguage do
+    let(:string) {
+      "RubyKaigi2009のテーマは、「変わる／変える」です。 前回の" +
+      "RubyKaigi2008のテーマであった「多様性」の言葉の通り、 " +
+      "2008年はRubyそのものに関しても、またRubyの活躍する舞台に関しても、 " +
+      "ますます多様化が進みつつあります。RubyKaigi2008は、そのような " +
+      "Rubyの生態系をあらためて認識する場となりました。 しかし、" +
+      "こうした多様化が進む中、異なる者同士が単純に距離を 置いたままでは、" +
+      "その違いを認識したところであまり意味がありません。 異なる実装、" +
+      "異なる思想、異なる背景といった、様々な多様性を理解しつつ、 " +
+      "すり合わせるべきものをすり合わせ、変えていくべきところを " +
+      "変えていくことが、豊かな未来へとつながる道に違いありません。"
+    }
+    
+    it "should parse sentences" do
+      subject.should parse(string)
+    end 
+  end
+
+  class TwoCharLanguage < Parslet::Parser
+    root :twochar
+    rule(:twochar) { any >> str('2') }
+  end
+  describe TwoCharLanguage do
+    def di(s)
+      s.strip.to_s.lines.map { |l| l.chomp.strip }.join("\n")
+    end
+
+    it "should raise an error" do
+      error = catch_failed_parse {
+        subject.parse('123') }
+      di(error.ascii_tree).should == di(%q(
+        Failed to match sequence (. '2') at line 1 char 2.
+        `- Don't know what to do with "3" at line 1 char 3.
+      ))
+    end 
+  end
+
+  # Issue #68: Extra input reporting, written by jmettraux
+  class RepetitionParser < Parslet::Parser
+    rule(:nl)      { match('[\s]').repeat(1) }
+    rule(:nl?)     { nl.maybe }
+    rule(:sp)      { str(' ').repeat(1) }
+    rule(:sp?)     { str(' ').repeat(0) }
+    rule(:line)    { sp >> str('line') }
+    rule(:body)    { ((line | block) >> nl).repeat(0) }
+    rule(:block)   { sp? >> str('begin') >> sp >> match('[a-z]') >> nl >>
+                     body >> sp? >> str('end') }
+    rule(:blocks)  { nl? >> block >> (nl >> block).repeat(0) >> nl? }
+
+    root(:blocks)
+  end
+  describe RepetitionParser do
+    def di(s)
+      s.strip.to_s.lines.map { |l| l.chomp.strip }.join("\n")
+    end
+
+    it 'parses a block' do
+      subject.parse(%q{
+        begin a
+        end
+      })
+    end
+    it 'parses nested blocks' do
+      subject.parse(%q{
+        begin a
+          begin b
+          end
+        end
+      })
+    end
+    it 'parses successive blocks' do
+      subject.parse(%q{
+        begin a
+        end
+        begin b
+        end
+      })
+    end
+    it 'fails gracefully on a missing end' do
+      error = catch_failed_parse {
+        subject.parse(%q{
+          begin a
+            begin b
+          end
+        }) }
+      
+      di(error.ascii_tree).should == di(%q(
+        Failed to match sequence (NL? BLOCK (NL BLOCK){0, } NL?) at line 2 char 11.
+        `- Failed to match sequence (SP? 'begin' SP [a-z] NL BODY SP? 'end') at line 5 char 9.
+           `- Premature end of input at line 5 char 9.
+        ))
+    end
+    it 'fails gracefully on a missing end (2)' do
+      error = catch_failed_parse {
+        subject.parse(%q{
+          begin a
+          end
+          begin b
+            begin c
+          end
+        }) }
+
+      di(error.ascii_tree).should == di(%q(
+        Failed to match sequence (NL? BLOCK (NL BLOCK){0, } NL?) at line 3 char 14.
+        `- Don't know what to do with "begin b\n  " at line 4 char 11.
+        ))
+    end
+    it 'fails gracefully on a missing end (deepest reporter)' do
+      error = catch_failed_parse {
+        subject.parse(%q{
+            begin a
+            end
+            begin b
+              begin c
+                li
+              end
+            end
+          },
+          :reporter => Parslet::ErrorReporter::Deepest.new) }
+
+      di(error.ascii_tree).should == di(%q(
+        Failed to match sequence (NL? BLOCK (NL BLOCK){0, } NL?) at line 3 char 16.
+        `- Expected "end", but got "li\n" at line 6 char 17.
+        ))
+    end
+  end
+end