ghostwheel 0.0.1

data/test/dsl/tc_build_parser.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require "ghost_wheel"
+
+class TestRubyDSL < Test::Unit::TestCase
+  def test_build_parser
+    # with instance_eval()
+    parser = GhostWheel.build_parser do
+      parser(:test_rule, "one")
+    end
+    assert_instance_of(GhostWheel::Parser, parser)
+    assert_instance_of(GhostWheel::Expression::Rule, parser[:test_rule])
+    
+    assert_respond_to(parser, :parse_test_rule)
+    assert_respond_to(parser, :parse)
+
+    # without instance_eval()
+    parser = GhostWheel.build_parser do |b|
+      b.parser(:test_rule, "one")
+    end
+    assert_instance_of(GhostWheel::Parser, parser)
+    assert_instance_of(GhostWheel::Expression::Rule, parser[:test_rule])
+    
+    assert_respond_to(parser, :parse_test_rule)
+    assert_respond_to(parser, :parse)
+  end
+end

data/test/dsl/tc_ghost_wheel_dsl.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require File.join(File.dirname(__FILE__), %w[.. helpers ghost_wheel_namespace])
+
+class TestGhostWheelDSL < Test::Unit::TestCase
+  include GhostWheelNamespace
+  
+  def test_rule_definition
+    build "word = 'word'"
+    assert_instance_of(Rule, @parser[:word])
+    assert_equal(Rule.new(Literal.new('word')), @parser[:word])
+  end
+  
+  def test_parser_definition
+    build "word := 'word'"
+    assert_instance_of(Rule, @parser[:word])
+    assert_equal(Rule.new(Literal.new('word')), @parser[:word])
+    assert_respond_to(@parser, :parse_word)
+  end
+  
+  def test_literal_single_quoted_string
+    build "str = 'string'"
+    assert_equal(Literal.new("string"), @parser[:str].expression)
+
+    build "str = '\\'escaped\\' string'"
+    assert_equal(Literal.new("'escaped' string"), @parser[:str].expression)
+
+    build "str = '\\'tricky\\\\\\' string'"
+    assert_equal(Literal.new("'tricky\\' string"), @parser[:str].expression)
+  end
+  
+  def test_literal_double_quoted_string
+    build 'str = "string"'
+    assert_equal(Literal.new("string"), @parser[:str].expression)
+
+    build 'str = "\"escaped\" string"'
+    assert_equal(Literal.new(%Q{"escaped" string}), @parser[:str].expression)
+    
+    build 'str = "\"tricky\\\\\" string"'
+    assert_equal(Literal.new(%Q{"tricky\\" string}), @parser[:str].expression)
+
+    build 'str = "\t"'
+    assert_equal(Literal.new("\t"), @parser[:str].expression)
+  end
+  
+  def test_literal_regexp
+    build "re = /regexp/"
+    assert_equal(Literal.new(/regexp/), @parser[:re].expression)
+
+    build "re = /\\/escaped\\/ regexp/"
+    assert_equal(Literal.new(%r{/escaped/ regexp}), @parser[:re].expression)
+
+    build "re = /\\/tricky\\\\\\/ regexp/"
+    assert_equal(Literal.new(%r{/tricky\\/ regexp}), @parser[:re].expression)
+
+    build "re = /\\t/"
+    assert_equal(Literal.new(/\t/), @parser[:re].expression)
+  end
+  
+  def test_reference
+    build "ref = another"
+    assert_instance_of(Rule, @parser[:another])
+    assert_equal(Rule.new(Rule.new), @parser[:ref])
+  end
+  
+  def test_sequence
+    build "seq = 'a' 'b'"
+    assert_equal( Sequence.new(Literal.new("a"), Literal.new("b")),
+                  @parser[:seq].expression )
+  end
+  
+  def test_transformation
+    build "trans := 'a' { ast * 2 }"
+    assert_instance_of(Transform, @parser[:trans].expression)
+    assert_equal(Literal.new("a"), @parser[:trans].expression.expression)
+    assert_equal("aa", @parser.parse_trans("a"))
+  end
+  
+  def test_alternation
+    build "alt = 'a' | 'b'"
+    assert_equal( Alternation.new(Literal.new("a"), Literal.new("b")),
+                  @parser[:alt].expression )
+  end
+  
+  def test_modifiers
+    build "opt = 'a'?"
+    assert_equal(Optional.new(Literal.new("a")), @parser[:opt].expression)
+    
+    build "rep = 'a'*"
+    assert_equal(Repetition.new(Literal.new("a")), @parser[:rep].expression)
+    
+    build "rep = 'a'+"
+    assert_equal(Repetition.new(Literal.new("a"), 1), @parser[:rep].expression)
+  end
+  
+  def test_eof
+    build "eof = EOF"
+    assert_equal(EndOfFile.instance, @parser[:eof].expression)
+  end
+  
+  def test_precedence
+    build "prec = 'a' 'b'? 'c'"
+    assert_equal( Sequence.new( Literal.new("a"),
+                                Optional.new(Literal.new("b")),
+                                Literal.new("c") ),
+                  @parser[:prec].expression )
+
+    build "prec = 'a' 'b' | 'c'"
+    assert_equal( Alternation.new( Sequence.new( Literal.new("a"),
+                                                 Literal.new("b") ),
+                                   Literal.new("c") ),
+                  @parser[:prec].expression )
+
+    build "prec := 'a' 'b' { ast * 2 } | 'c' { ast * 3 }"
+    assert_instance_of(Alternation, @parser[:prec].expression)
+    left, right = @parser[:prec].expression.expressions
+    assert_instance_of(Transform, left)
+    assert_equal( Sequence.new(Literal.new("a"), Literal.new("b")),
+                  left.expression )
+    assert_equal(%w[a b a b], @parser.parse_prec("ab"))
+    assert_instance_of(Transform, right)
+    assert_equal(Literal.new("c"), right.expression)
+    assert_equal("ccc", @parser.parse_prec("c"))
+  end
+  
+  def test_multiple_assignments
+    build <<-END_GRAMMAR
+    one = 'one'
+    two = 'two'
+    END_GRAMMAR
+    assert_equal(Literal.new("one"), @parser[:one].expression)
+    assert_equal(Literal.new("two"), @parser[:two].expression)
+  end
+  
+  private
+  
+  def build(grammar)
+    @builder = ParserBuilder::GhostWheel.new(grammar)
+    @parser  = @builder.to_parser
+  end
+end

data/test/dsl/tc_ruby_dsl.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require File.join(File.dirname(__FILE__), %w[.. helpers ghost_wheel_namespace])
+
+class TestRubyDSL < Test::Unit::TestCase
+  include GhostWheelNamespace
+  
+  def setup
+    @builder = ParserBuilder::Ruby.new
+  end
+  
+  def test_to_parser
+    assert_instance_of(Parser, @builder.to_parser)
+  end
+  
+  def test_dual_build_interface
+    build do |b|
+      assert_instance_of(TestRubyDSL, self)
+      assert_instance_of(ParserBuilder::Ruby, b)
+    end
+    
+    test_case = self  # preparing for instance_eval()
+    build { test_case.assert_instance_of(ParserBuilder::Ruby, self) }
+  end
+  
+  def test_rule
+    build { rule(:test_rule, nil) }
+    
+    assert_instance_of(Rule, @parser[:test_rule])
+  end
+  
+  def test_parser_builds_rule
+    build { parser(:test_parser, nil) }
+    
+    assert_instance_of(Rule, @parser[:test_parser])
+  end
+  
+  def test_parser_wraps_rule_adding_scanner_for_source
+    build { parser(:test_parser, nil) }
+  
+    assert_respond_to(@parser, :parse_test_parser)
+    assert_raise(EmptyRuleError) { @parser.parse_test_parser("not_used") }
+    
+    @parser[:test_parser].expression = Literal.new(/\w+/)
+    assert_equal("first", @parser.parse_test_parser("first word"))
+  end
+  
+  def test_parser_adds_parse_shortcut
+    assert( !@builder.to_parser.respond_to?(:parse),
+            "A parse() method was defined, but not expected." )
+    
+    build { parser(:first_parser, nil) }
+    assert_respond_to(@builder.to_parser, :parse_first_parser)
+    assert_respond_to(@builder.to_parser, :parse)
+    
+    build { parser(:second_parser, nil) }
+    assert_respond_to(@builder.to_parser, :parse_first_parser)
+    assert_respond_to(@builder.to_parser, :parse_second_parser)
+    assert( !@builder.to_parser.respond_to?(:parse),
+            "A parse() method was defined, but not expected." )
+    
+    build { parser(:third_parser, nil) }
+    assert_respond_to(@builder.to_parser, :parse_first_parser)
+    assert_respond_to(@builder.to_parser, :parse_second_parser)
+    assert_respond_to(@builder.to_parser, :parse_third_parser)
+    assert( !@builder.to_parser.respond_to?(:parse),
+            "A parse() method was defined, but not expected." )
+  end
+  
+  def test_parser_result_handling
+    build { parser(:create_result, Literal.new(/\w+/)) }
+    
+    result = @parser.parse_create_result("successful parse")
+    assert_instance_of(String, result)
+    assert_equal("successful", result)
+    
+    assert_raise(FailedParseError) { @parser.parse_create_result("") }
+    
+    # default
+    @parser[:create_result].expression = Empty.instance
+    assert_raise(EmptyParseError) { @parser.parse_create_result("not_used") }
+    
+    # override empty return
+    assert_equal(42, @parser.parse_create_result("not_used", 42))
+  end
+  
+  def test_ref
+    # post reference
+    build { parser(:post, Literal.new(/\w+/)) }
+    assert_same(@parser[:post], @builder.ref(:post))
+    
+    # pre reference
+    ref = @builder.ref(:pre)
+    assert_instance_of(Rule, ref)
+    assert_nil(ref.expression)
+    build { parser(:pre, Literal.new(/\w+/)) }
+    assert_not_nil(ref.expression)
+    assert_same(@parser[:pre], ref)
+  end
+  
+  def test_expression_factories
+    assert_equal(Literal.new("keyword"), @builder.lit("keyword"))
+    
+    assert_equal(Literal.new("keyword", true), @builder.skip("keyword"))
+    assert_equal(Literal.new("keyword", true), @builder.lit(true, "keyword"))
+    assert_equal(Literal.new("keyword", true), @builder.lit("keyword", true))
+    
+    assert_equal( Sequence.new(Literal.new("one"), Literal.new("two")),
+                  @builder.seq(@builder.lit("one"), @builder.lit("two")) )
+    
+    assert_equal( Alternation.new(Literal.new("one"), Literal.new("two")),
+                  @builder.alt(@builder.lit("one"), @builder.lit("two")) )
+    
+    assert_equal(Empty.instance, @builder.empty)
+    
+    assert_equal( Optional.new(Literal.new("one")),
+                  @builder.opt(@builder.lit("one")) )
+    
+    assert_equal( Repetition.new(Literal.new("one")),
+                  @builder.zplus(@builder.lit("one")) )
+    assert_equal( Repetition.new(Literal.new("one"), 1),
+                  @builder.oplus(@builder.lit("one")) )
+    assert_equal( Repetition.new(Literal.new("one"), 1),
+                  @builder.min(1, @builder.lit("one")) )
+    assert_equal( Repetition.new(Literal.new("one"), 0, 5),
+                  @builder.max(5, @builder.lit("one")) )
+    assert_equal( Repetition.new(Literal.new("one"), 1, 5),
+                  @builder.minmax(1, 5, @builder.lit("one")) )
+    assert_equal( Repetition.new(Literal.new("one"), 5, 5),
+                  @builder.count(5, @builder.lit("one")) )
+    
+    assert_equal( LookAhead.new(Literal.new("one")),
+                  @builder.look(@builder.lit("one")) )
+    
+    assert_equal( LookAhead.new(Literal.new("one"), true),
+                  @builder.nlook(@builder.lit("one")) )
+    assert_equal( LookAhead.new(Literal.new("one"), true),
+                  @builder.look(true, @builder.lit("one")) )
+    assert_equal( LookAhead.new(Literal.new("one"), true),
+                  @builder.look(@builder.lit("one"), true) )
+    
+    assert_equal(EndOfFile.instance, @builder.eof)
+    
+    assert_equal( Query.new(Literal.new("one")) { },
+                  @builder.query(@builder.lit("one")) { } )
+    
+    assert_equal( Transform.new(Literal.new("one")) { },
+                  @builder.trans(@builder.lit("one")) { } )
+  end
+  
+  def test_literal_expression_shortcut
+    ["one", /\w+/, ?a].each do |literal|
+      %w[ seq alt opt zplus oplus min max minmax count
+          look nlook query trans ].each do |wrapper|
+          wrapped = if %w[min max count].include? wrapper
+            @builder.send(wrapper, 5, literal)
+          elsif wrapper == "minmax"
+            @builder.send(wrapper, 5, 5, literal)
+          else
+            @builder.send(wrapper, literal)
+          end
+          unwrapped = wrapped.expressions.first rescue wrapped.expression
+          assert_equal(Literal.new(literal), unwrapped)
+      end
+      %w[seq alt].each do |wrapper|
+        assert_equal( [Literal.new(literal), Literal.new("two")],
+                      @builder.send(wrapper, literal, "two").expressions )
+      end
+    end
+  end
+  
+  def test_reference_shortcut
+    build do
+      parser(:test_rule,    Literal.new(/\w+/))
+      parser(:another_rule, Literal.new("two"))
+    end
+    %w[ seq alt opt zplus oplus min max minmax count
+        look nlook query trans ].each do |wrapper|
+        wrapped = if %w[min max count].include? wrapper
+          @builder.send(wrapper, 5, :test_rule)
+        elsif wrapper == "minmax"
+          @builder.send(wrapper, 5, 5, :test_rule)
+        else
+          @builder.send(wrapper, :test_rule)
+        end
+        unwrapped = wrapped.expressions.first rescue wrapped.expression
+        assert_same(@parser[:test_rule], unwrapped)
+    end
+    %w[seq alt].each do |wrapper|
+      assert_equal( [@parser[:test_rule], @parser[:another_rule]],
+                    @builder.send( wrapper,
+                                   :test_rule,
+                                   :another_rule ).expressions )
+    end
+  end
+  
+  def test_transform_expression_shortcut
+    %w[ rule parser ref lit skip seq alt empty opt zplus oplus
+        min max minmax count look nlook eof ].each do |wrapper|
+        wrapped = if %w[rule parser].include? wrapper
+          @builder.send(wrapper, :test_rule, "lit") { 42 }
+          @builder.to_parser[:test_rule].expression
+        elsif wrapper == "ref"
+          @builder.send(wrapper, :test_rule) { 42 }
+        elsif %w[min max count].include? wrapper
+          @builder.send(wrapper, 5, "lit") { 42 }
+        elsif wrapper == "minmax"
+          @builder.send(wrapper, 5, 5, "lit") { 42 }
+        elsif %w[empty eof].include? wrapper
+          @builder.send(wrapper) { 42 }
+        else
+          @builder.send(wrapper, "lit") { 42 }
+        end
+        assert_instance_of(Transform, wrapped)
+        assert_equal(42, wrapped.transformer.call)
+    end
+  end
+  
+  private
+  
+  def build(&block)
+    @builder.build(&block)
+    @parser = @builder.to_parser
+  end
+end

data/test/example/tc_json_core.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require File.join(File.dirname(__FILE__), %w[.. helpers ghost_wheel_namespace])
+require File.join(File.dirname(__FILE__), %w[.. helpers parse_helpers])
+require File.join(File.dirname(__FILE__), %w[.. helpers json_tests])
+
+class TestJSONCore < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  include JSONTests
+  
+  def setup
+    value = Rule.new
+    
+    keyword = Transform.new(
+      Alternation.new(*%w[true false null].map { |k| Literal.new(k) })
+    ) { |keyword| {"true" => true, "false" => false, "null" => nil}[keyword] }
+    
+    number = Transform.new(
+      Literal.new(/-?(?:0|[1-9]\d*)(?:\.\d+(?:[eE][+-]?\d+)?)?/)
+    ) { |number| number.include?(".") ? Float(number) : Integer(number) }
+    
+    string = Transform.new(
+      Sequence.new(
+        Literal.new('"', true),
+        Repetition.new(
+          Alternation.new(
+            Transform.new(Literal.new(%r{\\["\\/]})) { |escape| escape[-1, 1] },
+            Transform.new(
+              Literal.new(/\\[bfnrt]/)
+            ) { |escape| Hash[*%W[b \n f \f n \n r \r t \t]][escape[-1, 1]] },
+            Transform.new(
+              Literal.new(/\\u[0-9a-fA-F]{4}/)
+            ) { |escape| [Integer("0x#{escape[2..-1]}")].pack("U") },
+            Literal.new(/[^\\"]+/)
+          )
+        ),
+        Literal.new('"', true)
+      )
+    ) { |string| string.flatten.join }
+    
+    array = Transform.new(
+      Sequence.new(
+        Literal.new(/\[\s*/, true),
+        Alternation.new(
+          Transform.new(
+            Sequence.new(
+              Repetition.new(
+                Sequence.new(value, Literal.new(/\s*,\s*/, true)), 1
+              ),
+              value
+            )
+          ) { |array| array.first.inject(Array.new) { |vs, v| vs.push(*v) } +
+                      [array.last] },
+          Sequence.new(Optional.new(value))
+        ),
+        Literal.new(/\s*\]/, true)
+      )
+    ) { |array| array.first }
+    
+    object_pair = Transform.new(
+      Sequence.new(string, Literal.new(/\s*:\s*/), value)
+    ) { |key_and_val| {key_and_val.first => key_and_val.last} }
+    object      = Transform.new(
+      Sequence.new(
+        Literal.new(/\{\s*/, true),
+        Alternation.new(
+          Transform.new(
+            Sequence.new(
+              Repetition.new(
+                Sequence.new(object_pair, Literal.new(/\s*;\s*/, true)), 1
+              ),
+              object_pair
+            )
+          ) { |pairs| pairs.first.first + [pairs.last] },
+          Sequence.new(Optional.new(object_pair))
+        ),
+        Literal.new(/\}\s*/, true)
+      )
+    ) { |pairs| pairs.first.inject(Hash.new) { |hash, pair| hash.merge(pair) } }
+    
+    space = Optional.new(Literal.new(/\s+/, true))
+    value.expression = Transform.new(
+      Sequence.new(
+        space, Alternation.new(object, array, string, number, keyword), space
+      )
+    ) { |value| value.first }
+    
+    @parser = Transform.new(
+      Sequence.new(value, EndOfFile.instance)
+    ) { |json| json.first }
+  end
+end