citrus 1.0.0

data/lib/citrus/debug.rb

@@ -0,0 +1,37 @@
+require 'citrus'
+require 'builder'
+
+module Citrus
+  class Match
+    # Creates a Builder::XmlMarkup object from this match. Useful when
+    # inspecting a nested match. The +xml+ argument may be a Hash of
+    # Builder::XmlMarkup options.
+    def to_markup(xml={})
+      if xml.is_a?(Hash)
+        opt = { :indent => 2 }.merge(xml)
+        xml = Builder::XmlMarkup.new(opt)
+        xml.instruct!
+      end
+
+      if matches.empty?
+        xml.match("name" => name, "text" => text, "offset" => offset)
+      else
+        xml.match("name" => name, "text" => text, "offset" => offset) do
+          matches.each {|m| m.to_markup(xml) }
+        end
+      end
+
+      xml
+    end
+
+    # Returns the target of #to_markup which is an XML string unless another
+    # target is specified in +opt+.
+    def to_xml(opt={})
+      to_markup(opt).target!
+    end
+
+    def inspect # :nodoc:
+      to_xml
+    end
+  end
+end

data/lib/citrus/peg.rb

@@ -0,0 +1,375 @@
+require 'citrus'
+
+module Citrus
+  # A grammar for Citrus-flavored parsing expression grammars. This module is
+  # used in Citrus#eval to parse and evaluate Citrus PEG's and serves as a prime
+  # example of how to create a complex grammar complete with semantic
+  # interpretation in pure Ruby.
+  module PEG
+    include Grammar
+
+    ## Hierarchical syntax
+
+    rule :file do
+      all(:space, zero_or_more(any(:require, :grammar))) {
+        def requires
+          find(:require)
+        end
+
+        def grammars
+          find(:grammar)
+        end
+
+        def value
+          requires.each {|r| require r.value }
+          grammars.map {|g| g.value }
+        end
+      }
+    end
+
+    rule :grammar do
+      all(:grammar_keyword, :module_name, :grammar_body, :end_keyword) {
+        def includes
+          find(:include)
+        end
+
+        def modules
+          includes.map {|inc| eval(inc.value, TOPLEVEL_BINDING) }
+        end
+
+        def root
+          find(:root).last
+        end
+
+        def rules
+          find(:rule)
+        end
+
+        def value
+          code = '%s = Citrus::Grammar.new' % module_name.value
+          grammar = eval(code, TOPLEVEL_BINDING)
+          modules.each {|mod| grammar.include(mod) }
+          grammar.root(root.value) if root
+          rules.each {|rule| grammar.rule(rule.rule_name.value, rule.value) }
+          grammar
+        end
+      }
+    end
+
+    rule :grammar_body do
+      zero_or_more(any(:include, :root, :rule))
+    end
+
+    rule :rule do
+      all(:rule_keyword, :rule_name, :rule_body, :end_keyword) {
+        def value
+          rule_body.value
+        end
+      }
+    end
+
+    rule :rule_body do
+      all(:sequence, :choice) {
+        def choices
+          @choices ||= [ sequence ] + choice.sequences
+        end
+
+        def values
+          choices.map {|s| s.value }
+        end
+
+        def value
+          choices.length > 1 ? Choice.new(values) : values[0]
+        end
+      }
+    end
+
+    rule :choice do
+      zero_or_more([ :bar, :sequence ]) {
+        def sequences
+          matches.map {|m| m.matches[1] }
+        end
+      }
+    end
+
+    rule :sequence do
+      zero_or_more(:prefix) {
+        def values
+          matches.map {|m| m.value }
+        end
+
+        def value
+          matches.length > 1 ? Sequence.new(values) : values[0]
+        end
+      }
+    end
+
+    rule :prefix do
+      all(zero_or_one(:qualifier), :appendix) {
+        def value
+          rule = appendix.value
+          qualifier = matches[0].first
+          rule = qualifier.wrap(rule) if qualifier
+          rule
+        end
+      }
+    end
+
+    rule :appendix do
+      all(:suffix, zero_or_one(:extension)) {
+        def value
+          rule = suffix.value
+          extension = matches[1].first
+          rule = extension.wrap(rule) if extension
+          rule
+        end
+      }
+    end
+
+    rule :suffix do
+      all(:primary, zero_or_one(:quantifier)) {
+        def value
+          rule = primary.value
+          quantifier = matches[1].first
+          rule = quantifier.wrap(rule) if quantifier
+          rule
+        end
+      }
+    end
+
+    rule :primary do
+      any(:super, :alias, :rule_body_paren, :terminal) {
+        def value
+          first.value
+        end
+      }
+    end
+
+    rule :rule_body_paren do
+      all(:lparen, :rule_body, :rparen) {
+        def value
+          rule_body.value
+        end
+      }
+    end
+
+    ## Lexical syntax
+
+    rule :require do
+      all(:require_keyword, :quoted_string) {
+        def value
+          quoted_string.value
+        end
+      }
+    end
+
+    rule :include do
+      all(:include_keyword, :module_name) {
+        def value
+          module_name.value
+        end
+      }
+    end
+
+    rule :root do
+      all(:root_keyword, :rule_name) {
+        def value
+          rule_name.value
+        end
+      }
+    end
+
+    rule :rule_name do
+      all(/[a-z][a-zA-Z0-9_]*/, :space) {
+        def value
+          first.text
+        end
+      }
+    end
+
+    rule :super do
+      all('super', :space) {
+        def value
+          Super.new
+        end
+      }
+    end
+
+    rule :alias do
+      all(notp(:end_keyword), :rule_name) {
+        def value
+          Alias.new(rule_name.value)
+        end
+      }
+    end
+
+    rule :terminal do
+      any(:quoted_string, :character_class, :anything_symbol, :regular_expression) {
+        def value
+          Rule.create(first.value)
+        end
+      }
+    end
+
+    rule :quoted_string do
+      all(/(["'])(?:\\?.)*?\1/, :space) {
+        def value
+          eval(first.text)
+        end
+      }
+    end
+
+    rule :character_class do
+      all(/\[(?:\\?.)*?\]/, :space) {
+        def value
+          Regexp.new(first.text)
+        end
+      }
+    end
+
+    rule :anything_symbol do
+      all('.', :space) {
+        def value
+          /./m # The dot matches newlines
+        end
+      }
+    end
+
+    rule :regular_expression do
+      all(/\/(?:\\?.)*?\/[imxouesn]*/, :space) {
+        def value
+          eval(first.text)
+        end
+      }
+    end
+
+    rule :qualifier do
+      any(:and, :not, :label) {
+        def wrap(rule)
+          first.wrap(rule)
+        end
+      }
+    end
+
+    rule :and do
+      all('&', :space) {
+        def wrap(rule)
+          AndPredicate.new(rule)
+        end
+      }
+    end
+
+    rule :not do
+      all('!', :space) {
+        def wrap(rule)
+          NotPredicate.new(rule)
+        end
+      }
+    end
+
+    rule :label do
+      all(/[a-zA-Z0-9_]+/, :space, ':', :space) {
+        def wrap(rule)
+          Label.new(value, rule)
+        end
+
+        def value
+          first.text
+        end
+      }
+    end
+
+    rule :extension do
+      any(:tag, :block) {
+        def wrap(rule)
+          rule.ext = first.value
+          rule
+        end
+      }
+    end
+
+    rule :tag do
+      all(:lt, :module_name, :gt) {
+        def value
+          eval(module_name.value, TOPLEVEL_BINDING)
+        end
+      }
+    end
+
+    rule :block do
+      all(:lcurly, zero_or_more(any(:block, /[^{}]+/)), :rcurly) {
+        def value
+          eval('Proc.new ' + text)
+        end
+      }
+    end
+
+    rule :quantifier do
+      any(:question, :plus, :repeat) {
+        def min; first.min end
+        def max; first.max end
+
+        def wrap(rule)
+          Repeat.new(min, max, rule)
+        end
+      }
+    end
+
+    rule :question do
+      all('?', :space) {
+        def min; 0 end
+        def max; 1 end
+      }
+    end
+
+    rule :plus do
+      all('+', :space) {
+        def min; 1 end
+        def max; Infinity end
+      }
+    end
+
+    rule :repeat do
+      all(/[0-9]*/, '*', /[0-9]*/, :space) {
+        def min
+          matches[0] == '' ? 0 : matches[0].text.to_i
+        end
+
+        def max
+          matches[2] == '' ? Infinity : matches[2].text.to_i
+        end
+      }
+    end
+
+    rule :module_name do
+      all(one_or_more([ zero_or_one('::'), :constant ]), :space) {
+        def value
+          first.text
+        end
+      }
+    end
+
+    rule :constant do
+      /[A-Z][a-zA-Z0-9_]*/
+    end
+
+    rule :require_keyword,  [ 'require', :space ]
+    rule :include_keyword,  [ 'include', :space ]
+    rule :grammar_keyword,  [ 'grammar', :space ]
+    rule :super_keyword,    [ 'super', :space ]
+    rule :root_keyword,     [ 'root', :space ]
+    rule :rule_keyword,     [ 'rule', :space ]
+    rule :end_keyword,      [ 'end', :space ]
+    rule :lparen,           [ '(', :space ]
+    rule :rparen,           [ ')', :space ]
+    rule :lcurly,           [ '{', :space ]
+    rule :rcurly,           [ '}', :space ]
+    rule :bar,              [ '|', :space ]
+    rule :lt,               [ '<', :space ]
+    rule :gt,               [ '>', :space ]
+
+    rule :white,            /[ \t\n\r]/
+    rule :comment,          /#.*/
+    rule :space,            zero_or_more(any(:white, :comment))
+  end
+end

data/lib/citrus/sugar.rb

@@ -0,0 +1,25 @@
+require 'citrus'
+
+module Citrus
+  module GrammarMethods
+    # Permits creation of aliases within rule definitions in Ruby grammars using
+    # the bare name of another rule instead of a Symbol, e.g.:
+    #
+    #     rule :value do
+    #       any(:alpha, :num)
+    #     end
+    #
+    # can now be written as
+    #
+    #     rule value do
+    #       any(alpha, num)
+    #     end
+    #
+    # The only caveat is that since this hack uses +method_missing+ you must
+    # still use symbols for rules that have the same name as any of the methods
+    # in GrammarMethods (root, rule, rules, etc.)
+    def method_missing(sym, *args)
+      sym
+    end
+  end
+end

data/test/alias_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/helper'
+Citrus.load(File.dirname(__FILE__) + '/_files/alias')
+
+class AliasTest < Test::Unit::TestCase
+
+  def test_terminal?
+    rule = Alias.new
+    assert_equal(false, rule.terminal?)
+  end
+
+  def test_match
+    grammar = Grammar.new {
+      rule :a, :b
+      rule :b, 'b'
+    }
+
+    match = grammar.parse('b')
+    assert(match)
+    assert('b', match.text)
+    assert(1, match.length)
+  end
+
+  def test_match_renamed
+    grammar = Grammar.new {
+      rule :a, ext(:b) {
+        def value
+          'a' + text
+        end
+      }
+      rule :b, 'b'
+    }
+
+    match = grammar.parse('b')
+    assert(match)
+    assert('ab', match.value)
+
+    assert_raise RuntimeError do
+      match.b
+    end
+  end
+
+  def test_peg
+    match = AliasOne.parse('a')
+    assert(match)
+  end
+
+  def test_included
+    grammar1 = Grammar.new {
+      rule :a, 'a'
+    }
+
+    grammar2 = Grammar.new {
+      include grammar1
+      rule :b, :a
+    }
+
+    match = grammar2.parse('a')
+    assert(match)
+  end
+
+  def test_to_s
+    rule = Alias.new(:alpha)
+    assert_equal('alpha', rule.to_s)
+  end
+
+end