rattler 0.5.0 → 0.6.0

data/lib/rattler/util/parser_cli.rb

@@ -0,0 +1,84 @@
+require 'rattler/util'
+require 'optparse'
+
+module Rattler::Util
+
+  # +ParserCLI+ defines a command line interface for generated parsers.
+  class ParserCLI
+
+    # The supported graph file formats
+    @@graph_formats = %w{jpg png svg pdf ps ps2 eps}
+
+    # Create and run the command line interface for the given parser class
+    #
+    # @param (see #initialize)
+    def self.run(parser_class)
+      self.new(parser_class).run
+    end
+
+    # Create a new command line interface for the given parser class
+    #
+    # @param [Class] parser_class the parser class to run the command line
+    #   interface for
+    def initialize(parser_class)
+      @parser_class = parser_class
+
+      OptionParser.new do |opts|
+
+        opts.banner = "Usage: #{File.basename($0)} [filenames] [options]"
+
+        opts.separator ''
+
+        opts.on '-g', '--graphviz',
+                'Display the parse tree using GraphViz dotty' do |g|
+          @graphviz = {:dot => '|dotty'}
+        end
+
+        @@graph_formats.each do |format|
+          a = 'aefhilmnorsx'.include?(format[0]) ? 'an' : 'a'
+          desc = "#{format.upcase} file"
+          opts.on "--#{format} FILENAME",
+                  "Output the parse tree as #{a} #{desc} using GraphViz" do |f|
+            @graphviz = {format => f}
+          end
+        end
+
+        opts.on '-f', '--file FILENAME',
+                'Output the parse tree as a GraphViz DOT language file' do |file|
+          @graphviz = {:dot => file}
+        end
+
+        opts.on '-d', '--dot',
+                'Output the parse tree in the GraphViz DOT language' do |d|
+          @graphviz = {:dot => nil}
+        end
+
+        opts.separator ''
+
+        opts.on_tail '-h', '--help', 'Show this message' do
+          abort "#{opts}\n"
+        end
+      end.parse!(ARGV)
+    end
+
+    # Run the command line interface
+    def run
+      show_result @parser_class.parse!(ARGF.read)
+    rescue Rattler::Runtime::SyntaxError => e
+      puts e
+    end
+
+    private
+
+    # @private
+    def show_result(result) #:nodoc:
+      if @graphviz
+        GraphViz.digraph(result).output(@graphviz)
+      else
+        require 'pp'
+        pp result
+      end
+    end
+
+  end
+end

data/lib/rattler/util/parser_spec_helper.rb

@@ -1,34 +1,28 @@
-#
-# = rattler/util/parser_spec_helper.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
 require 'rattler/util'
 
 module Rattler::Util
-  #
+
   # +ParserSpecHelper+ defines a fluent interface for writing RSpec examples
   # for parsers.
   #
   # @example
   #
-  #   require 'rattler/grammar/grammar_parser'
+  #   require 'my_awesome_language/my_awesome_parser'
   #   require 'rattler/util/parser_spec_helper'
   #
-  #   describe Rattler::Grammar::GrammarParser do
+  #   describe MyAwesomeLanguage::MyAwesomeParser do
   #     include Rattler::Util::ParserSpecHelper
   #
   #     describe '#match(:var_name)' do
   #       it 'recognizes variable names' do
   #         matching(' fooBar ').as(:var_name).should result_in('fooBar').at(7)
-  #         matching(' FooBar ').as(:var_name).should fail.with_message('variable name expected')
+  #       end
+  #       it 'rejects non-variables' do
+  #         matching(' 42 ').as(:var_name).should fail.with_message('variable name expected')
   #       end
   #     end
   #   end
   #
-  # @author Jason Arhart
-  #
   module ParserSpecHelper
 
     # Return a parse result to be matched using #result_in or #fail
@@ -49,6 +43,8 @@ module Rattler::Util
       Matching.new(parser(source))
     end
 
+    private
+
     def parser(source)
       (self.respond_to?(:parser_class) ? parser_class : described_class).new(source)
     end

data/spec/rattler/compiler/assert_compiler_examples.rb

@@ -0,0 +1,284 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+shared_examples_for 'a compiled parser with an assert' do
+  include CompilerSpecHelper
+  include RuntimeParserSpecHelper
+
+  subject { compiled_parser }
+
+  let(:reference_parser) { combinator_parser grammar }
+
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
+  context 'with a nested match rule' do
+    let(:rules) { [
+      rule(:word) { assert(/\w+/) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').failing.like reference_parser }
+  end
+
+  context 'with a nested eof rule' do
+    let(:rules) { [
+      rule(:foo) { assert(eof) }
+    ] }
+    it { should parse('').succeeding.like reference_parser }
+    it { should parse('foo').from(3).succeeding.like reference_parser }
+    it { should parse('foo').failing.like reference_parser }
+  end
+
+  context 'with a nested "E" symbol rule' do
+    let(:rules) { [
+      rule(:foo) { assert(e) }
+    ] }
+    it { should parse('').succeeding.like reference_parser }
+    it { should parse('foo').succeeding.like reference_parser }
+  end
+
+  context 'with a nested choice rule' do
+    let(:rules) { [
+      rule(:word) { assert(match(/[[:alpha:]]+/) | match(/[[:digit:]]+/)) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').failing.like reference_parser }
+  end
+
+  context 'with a nested sequence rule' do
+    let(:rules) { [
+      rule(:word) { assert(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/)) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').failing.like reference_parser }
+
+    context 'with a semantic action' do
+
+      context 'when the expression has parameters' do
+        let(:rules) { [
+          rule(:a) { assert(match(/\d+/) >> semantic_action('|a| a.to_i * 2')) }
+        ] }
+        it { should parse('451a').succeeding.like reference_parser }
+        it { should parse('    ').failing.like reference_parser }
+      end
+
+      context 'when the expression uses "_"' do
+
+        context 'given a single capture' do
+          let(:rules) { [
+            rule(:a) { assert(match(/\d+/) >> semantic_action('_ * 2')) }
+          ] }
+          it { should parse('451a').succeeding.like reference_parser }
+          it { should parse('    ').failing.like reference_parser }
+        end
+
+        context 'given multiple captures' do
+          let(:rules) { [
+            rule(:a) { assert(
+              (match(/\d+/) & skip(/\s+/) & match(/\d+/)) >> semantic_action('_')
+            ) }
+          ] }
+          it { should parse('23 42').succeeding.like reference_parser }
+          it { should parse('     ').failing.like reference_parser }
+        end
+      end
+
+      context 'when the expression uses labels' do
+        let(:rules) { [
+          rule(:a) { assert(label(:a, /\d+/) >> semantic_action('a.to_i * 2')) }
+        ] }
+        it { should parse('451a').succeeding.like reference_parser }
+        it { should parse('    ').failing.like reference_parser }
+      end
+    end
+  end
+
+  context 'with a nested optional rule' do
+    let(:rules) { [
+      rule(:word) { assert(match(/\w+/).optional) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').succeeding.like reference_parser }
+  end
+
+  context 'with a nested zero-or-more rule' do
+    let(:rules) { [
+      rule(:word) { assert(match(/\w/).zero_or_more) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').succeeding.like reference_parser }
+  end
+
+  context 'with a nested one-or-more rule' do
+    let(:rules) { [
+      rule(:word) { assert(match(/\w/).one_or_more) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').failing.like reference_parser }
+  end
+
+  context 'with a nested repeat rule' do
+    let(:rules) { [
+      rule(:word) { assert(match(/\w/).repeat(2, nil)) }
+    ] }
+    it { should parse('abc123 ').succeeding.like reference_parser }
+    it { should parse('a ').failing.like reference_parser }
+
+    context 'with zero-or-more bounds' do
+      let(:rules) { [
+        rule(:word) { assert(match(/\w/).repeat(0, nil)) }
+      ] }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').succeeding.like reference_parser }
+
+      context 'with an upper bound' do
+        let(:rules) { [
+          rule(:word) { assert(match(/\w/).repeat(0, 2)) }
+        ] }
+        it { should parse('abc123  ').succeeding.like reference_parser }
+        it { should parse('   ').succeeding.like reference_parser }
+      end
+    end
+
+    context 'with one-or-more bounds' do
+      let(:rules) { [
+        rule(:word) { assert(match(/\w/).repeat(1, nil)) }
+      ] }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+
+      context 'with an upper bound' do
+        let(:rules) { [
+          rule(:word) { assert(match(/\w/).repeat(1, 2)) }
+        ] }
+        it { should parse('abc123  ').succeeding.like reference_parser }
+        it { should parse('   ').failing.like reference_parser }
+      end
+    end
+  end
+
+  context 'with a nested list rule' do
+    let(:rules) { [
+      rule(:foo) { assert(match(/\w+/).list(match(/[,;]/), 2, nil)) }
+    ] }
+    it { should parse('foo  ').failing.like reference_parser }
+    it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+
+    context 'with an upper bound' do
+      let(:rules) { [
+        rule(:foo) { assert(match(/\w+/).list(match(/[,;]/), 2, 4)) }
+      ] }
+      it { should parse('foo  ').failing.like reference_parser }
+      it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+    end
+
+    context 'with a non-capturing parser' do
+      let(:rules) { [
+        rule(:foo) { assert(skip(/\w+/).list(match(/[,;]/), 2, nil)) }
+      ] }
+      it { should parse('foo  ').failing.like reference_parser }
+      it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+
+      context 'with an upper bound' do
+        let(:rules) { [
+          rule(:foo) { assert skip(/\w+/).list(match(/[,;]/), 2, 4) }
+        ] }
+        it { should parse('foo  ').failing.like reference_parser }
+        it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+      end
+    end
+  end
+
+  context 'with a nested apply rule' do
+    let(:rules) { [
+      rule(:foo) { match(:word) },
+      rule(:word) { assert(/\w+/) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').failing.like reference_parser }
+  end
+
+  context 'with a nested semantic action' do
+    let(:rules) { [
+      rule(:a) { assert(semantic_action('42')) }
+    ] }
+    it { should parse('anything').succeeding.like reference_parser }
+  end
+
+  context 'with a nested attributed sequence' do
+
+    context 'with a single capture and a semantic action' do
+
+      context 'when the action uses a parameter' do
+        let(:rules) { [
+          rule(:a) { assert(match(/\d+/) >> semantic_action('|a| a.to_i')) }
+        ] }
+        it { should parse('451a').succeeding.like reference_parser }
+        it { should parse('    ').failing.like reference_parser }
+      end
+
+      context 'when the action uses "_"' do
+        let(:rules) { [
+          rule(:a) { assert(match(/\d+/) >> semantic_action('_.to_i')) }
+        ] }
+        it { should parse('451a').succeeding.like reference_parser }
+        it { should parse('    ').failing.like reference_parser }
+      end
+    end
+
+    context 'with multiple captures and a semantic action' do
+
+      context 'when the action uses parameters' do
+        let(:rules) { [
+          rule(:a) { assert(
+            (match(/[a-z]+/) & match(/\d+/)) >> semantic_action('|a,b| b+a')
+          ) }
+        ] }
+        it { should parse('abc123').succeeding.like reference_parser }
+        it { should parse('      ').failing.like reference_parser }
+      end
+
+      context 'when the action uses "_"' do
+        let(:rules) { [
+          rule(:a) { assert(
+            (match(/[a-z]+/) & match(/\d+/)) >> semantic_action('_.reverse')
+          ) }
+        ] }
+        it { should parse('abc123').succeeding.like reference_parser }
+        it { should parse('      ').failing.like reference_parser }
+      end
+    end
+
+    context 'with a single labeled capture and a semantic action' do
+      let(:rules) { [
+        rule(:e) { assert(label(:a, /\d+/) >> semantic_action('a.to_i')) }
+      ] }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with multiple labeled captures and a semantic action' do
+      let(:rules) { [
+        rule(:e) { assert(
+          (label(:a, /[a-z]+/) & label(:b, /\d+/)) >> semantic_action('b + a')
+        ) }
+      ] }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('      ').failing.like reference_parser }
+    end
+  end
+
+  context 'with a nested token rule' do
+    let(:rules) { [
+      rule(:word) { assert(token(/\w+/)) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').failing.like reference_parser }
+  end
+
+  context 'with a nested skip rule' do
+    let(:rules) { [
+      rule(:word) { assert(skip(/\w+/)) }
+    ] }
+    it { should parse('abc123  ').succeeding.like reference_parser }
+    it { should parse('   ').failing.like reference_parser }
+  end
+end

data/spec/rattler/compiler/attributed_sequence_compiler_examples.rb

@@ -0,0 +1,154 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+shared_examples_for 'a compiled parser with an attributed sequence' do
+  include CompilerSpecHelper
+  include RuntimeParserSpecHelper
+
+  subject { compiled_parser }
+
+  let(:reference_parser) { combinator_parser grammar }
+
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
+  context 'with a single capture and a semantic action' do
+
+    context 'when the action uses no parameters' do
+      let(:rules) { [
+        rule(:a) { match(/\d+/) >> semantic_action('42') }
+      ] }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'when the action uses a parameter' do
+      let(:rules) { [
+        rule(:a) { match(/\d+/) >> semantic_action('|a| a.to_i') }
+      ] }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'when the action uses "_"' do
+      let(:rules) { [
+        rule(:a) { match(/\d+/) >> semantic_action('_.to_i') }
+      ] }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+  end
+
+  context 'with a single capture and a node action' do
+    let(:rules) { [
+      rule(:a) { match(/\d+/) >> node_action('Rattler::Runtime::ParseNode') }
+    ] }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+
+    context 'when the action has node attributes' do
+      let(:rules) { [
+        rule(:a) do
+          match(/\d+/) >> node_action('Rattler::Runtime::ParseNode', :node_attrs => {:name => "FOO"})
+        end
+      ] }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+  end
+
+  context 'with a capturing nonterminal and a node action' do
+    let(:rules) { [
+      rule(:a) { match(:b) >> node_action('Rattler::Runtime::ParseNode') },
+      rule(:b) { match(/\d+/) }
+    ] }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+  end
+
+  context 'with a non-capturing nonterminal and a node action' do
+    let(:rules) { [
+      rule(:a) { match(:b) >> node_action('Rattler::Runtime::ParseNode') },
+      rule(:b) { skip(/\d+/) }
+    ] }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+  end
+
+  context 'with multiple captures and a semantic action' do
+
+    context 'when the action uses parameters' do
+      let(:rules) { [
+        rule(:a) {
+          (match(/[a-z]+/) & match(/\d+/)) >> semantic_action('|a,b| b+a')
+        }
+      ] }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('      ').failing.like reference_parser }
+    end
+
+    context 'when the action uses "_"' do
+      let(:rules) { [
+        rule(:a) {
+          (match(/[a-z]+/) & match(/\d+/)) >> semantic_action('_.reverse')
+        }
+      ] }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('      ').failing.like reference_parser }
+    end
+  end
+
+  context 'with multiple captures and a node action' do
+    let(:rules) { [
+      rule(:a) {
+        (match(/[a-z]+/) & match(/\d+/)) >> node_action('Rattler::Runtime::ParseNode')
+      }
+    ] }
+    it { should parse('abc123').succeeding.like reference_parser }
+    it { should parse('      ').failing.like reference_parser }
+  end
+
+  context 'with a single labeled capture and a semantic action' do
+    let(:rules) { [
+      rule(:e) { label(:a, /\d+/) >> semantic_action('a.to_i') }
+    ] }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+  end
+
+  context 'with multiple labeled captures and a semantic action' do
+    let(:rules) { [
+      rule(:e) {
+        (label(:a, /[a-z]+/) & label(:b, /\d+/)) >> semantic_action('b + a')
+      }
+    ] }
+    it { should parse('abc123').succeeding.like reference_parser }
+    it { should parse('      ').failing.like reference_parser }
+  end
+
+  context 'with a single labeled capture and a node action' do
+    let(:rules) { [
+      rule(:e) { label(:a, /\d+/) >> node_action('Rattler::Runtime::ParseNode') }
+    ] }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+
+    context 'when the action has node attributes' do
+      let(:rules) { [
+        rule(:e) {
+          label(:a, /\d+/) >> node_action('Rattler::Runtime::ParseNode', :node_attrs => {:name => "FOO"})
+        }
+      ] }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+  end
+
+  context 'with multiple labeled captures and a node action' do
+    let(:rules) { [
+      rule(:e) {
+        (label(:a, /[a-z]+/) & label(:b, /\d+/)) >> node_action('Rattler::Runtime::ParseNode')
+      }
+    ] }
+    it { should parse('abc123').succeeding.like reference_parser }
+    it { should parse('      ').failing.like reference_parser }
+  end
+end