ghostwheel 0.0.1

data/test/example/tc_json_ghost_wheel.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require File.join(File.dirname(__FILE__), %w[.. helpers parse_helpers])
+require File.join(File.dirname(__FILE__), %w[.. helpers json_tests])
+
+class TestJSONGhostWheel < Test::Unit::TestCase
+  include ParseHelpers
+  include JSONTests
+  
+  def setup
+    @parser = GhostWheel.build_parser( %q{
+      keyword = 'true' { true } | 'false' { false } | 'null' { nil }
+      
+      number = /-?(?:0|[1-9]\d*)(?:\.\d+(?:[eE][+-]?\d+)?)?/
+               { ast.include?(".") ? Float(ast) : Integer(ast) }
+      
+      string_content = /\\\\["\\\\\/]/ { ast[-1, 1] }
+                     | /\\\\[bfnrt]/
+                       { Hash[*%W[b \n f \f n \n r \r t \t]][ast[-1, 1]] }
+                     | /\\\\u[0-9a-fA-F]{4}/
+                       { [Integer("0x#{ast[2..-1]}")].pack("U") }
+                     | /[^\\\\"]+/
+      string         = '"' string_content* '"' { ast.flatten[1..-2].join }
+
+      array_content = value_with_array_sep+ value
+                      { ast[0].inject([]) { |a, v| a.push(*v) } + ast[-1..-1] }
+                    | value? { ast.is_a?(EmptyParseResult) ? [] : [ast] }
+      array         = /\[\s*/ array_content /\s*\]/ { ast[1] }
+
+      object_pair         = string /\s*:\s*/ value { {ast[0] => ast[-1]} }
+      object_pair_and_sep = object_pair /\s*;\s*/ { ast[0] }
+      object_content      = object_pair_and_sep+ object_pair { ast.flatten }
+                          | object_pair?
+                            { ast.is_a?(EmptyParseResult) ? [] : [ast] }
+      object              = /\\\{\s*/ object_content /\\\}\s*/
+                            { ast[1].inject({}) { |h, p| h.merge(p) } }
+
+      value_space          = /\s*/
+      value_content        = keyword | number | string | array | object
+      value                = value_space value_content value_space { ast[1] }
+      value_with_array_sep = value /\s*,\s*/ { ast[0] }
+
+      json := value EOF { ast[0] }
+    } )[:json]
+  end
+end

data/test/example/tc_json_ruby.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require File.join(File.dirname(__FILE__), %w[.. helpers parse_helpers])
+require File.join(File.dirname(__FILE__), %w[.. helpers json_tests])
+
+class TestJSONRuby < Test::Unit::TestCase
+  include ParseHelpers
+  include JSONTests
+  
+  def setup
+    @parser = GhostWheel.build_parser do
+      rule( :keyword,
+            alt("true", "false", "null") { |k|
+              {"true" => true, "false" => false, "null" => nil}[k]
+            } )
+
+      rule( :number,
+            /-?(?:0|[1-9]\d*)(?:\.\d+(?:[eE][+-]?\d+)?)?/ ) { |n|
+        n.include?(".") ? Float(n) : Integer(n)
+      }
+
+      rule( :string,
+            seq(
+              skip('"'),
+              zplus(
+                alt(
+                  lit(%r{\\["\\/]}) { |e| e[-1, 1] },
+                  lit(/\\[bfnrt]/) { |e|
+                    Hash[*%W[b \n f \f n \n r \r t \t]][e[-1, 1]]
+                  },
+                  lit(/\\u[0-9a-fA-F]{4}/) { |e|
+                    [Integer("0x#{e[2..-1]}")].pack("U")
+                  },
+                  /[^\\"]+/
+                )
+              ),
+              skip('"')
+            ) { |s| s.flatten.join } )
+
+      rule( :array,
+            seq(
+              skip(/\[\s*/),
+              alt(
+                seq(
+                  oplus(seq(:value, skip(/\s*,\s*/))),
+                  :value
+                ) { |a| a[0].inject([]) { |vs, v| vs.push(*v) } + a[-1..-1] },
+                seq(opt(:value))
+              ),
+              skip(/\s*\]/)
+            ) { |a| a.first } )
+
+      rule( :object_pair,
+            seq(:string, /\s*:\s*/, :value) { |kv| {kv[0] => kv[-1]} } )
+      rule( :object,
+            seq(
+              skip(/\{\s*/),
+              alt(
+                seq(
+                  oplus(seq(:object_pair, skip(/\s*;\s*/))),
+                  :object_pair
+                ) { |ps| ps[0][0] + ps[-1..-1] },
+                seq(opt(:object_pair))
+              ),
+              skip(/\}\s*/)
+            ) { |ps| ps[0].inject({}) { |h, p| h.merge(p) } } )
+
+      rule(:value_space, opt(skip(/\s+/)))
+      rule( :value,
+            seq(
+              :value_space,
+              alt(:object, :array, :string, :number, :keyword),
+              :value_space
+            ) { |v| v[0] } )
+
+      parser(:json, seq(:value, eof) { |j| j[0] })
+    end[:json]
+  end
+end

data/test/helpers/ghost_wheel_namespace.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby -w
+
+require "ghost_wheel"
+
+# 
+# Including this module in a test case embeds the GhostWheel namespace for those
+# tests.  Constants both in the root GhostWheel module and in the 
+# GhostWheel::Expression class may be used without qualification.
+# 
+module GhostWheelNamespace
+  # 
+  # Includes the GhostWheel module in +test_case+ and builds a
+  # self.const_missing() method to handle lookups in the GhostWheel::Expression
+  # class.
+  # 
+  def self.included(test_case)
+    test_case.instance_eval do
+      include GhostWheel
+      def const_missing(const)
+        GhostWheel::Expression.const_get(const) rescue super
+      end
+    end
+  end
+end

data/test/helpers/json_tests.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby -w
+
+module JSONTests
+  def test_keyword_parsing
+    assert_parses(true,  parse("true"))
+    assert_parses(false, parse("false"))
+    assert_parses(nil,   parse("null"))
+  end
+  
+  def test_number_parsing
+    assert_parses(42,      parse("42"))
+    assert_parses(-13,     parse("-13"))
+    assert_parses(3.1415,  parse("3.1415"))
+    assert_parses(-0.01,   parse("-0.01"))
+  
+    assert_parses(0.2e1,   parse("0.2e1"))
+    assert_parses(0.2e+1,  parse("0.2e+1"))
+    assert_parses(0.2e-1,  parse("0.2e-1"))
+    assert_parses(0.2E1,   parse("0.2e1"))
+  end
+  
+  def test_string_parsing
+    assert_parses(String.new,          parse(%Q{""}))
+    assert_parses("James",             parse(%Q{"James"}))
+    
+    assert_parses(%Q{nested "quotes"}, parse('"nested \"quotes\""'))
+    assert_parses("\n",                parse(%Q{"\\n"}))
+    assert_parses("a",                 parse(%Q{"\\u#{"%04X" % ?a}"}))
+  end
+  
+  def test_array_parsing
+    assert_parses(Array.new,               parse(%Q{[]}))
+    assert_parses(["James", 3.1415, true], parse(%Q{["James", 3.1415, true]}))
+    assert_parses([1, [2, [3]]],           parse(%Q{[1, [2, [3]]]}))
+  end
+  
+  def test_object_parsing
+    assert_parses(Hash.new, parse(%Q{{}}))
+    assert_parses( {"James" => 3.1415, "Gray" => true},
+                   parse(%Q{{"James": 3.1415; "Gray": true}}) )
+    assert_parses( {"Array" => [1, 2, 3], "Object" => {"nested" => "objects"}},
+                   parse(<<-END_OBJECT) )
+    {"Array": [1, 2, 3]; "Object": {"nested": "objects"}}
+    END_OBJECT
+  end
+  
+  def test_error_parsing
+    assert_doesnt_parse(parse("unknown"))
+  
+    assert_doesnt_parse(parse("$1,000"))
+    assert_doesnt_parse(parse("1_000"))
+    assert_doesnt_parse(parse("1K"))
+  
+    assert_doesnt_parse(parse(%Q{"}))
+    assert_doesnt_parse(parse(%Q{"\\i"}))
+  
+    assert_doesnt_parse(parse("["))
+    assert_doesnt_parse(parse("[1,,2]"))
+  
+    assert_doesnt_parse(parse("{"))
+    assert_doesnt_parse(parse(%q{{"key": true false}}))
+  end
+end

data/test/helpers/parse_helpers.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby -w
+
+require "ghost_wheel"
+
+require File.join(File.dirname(__FILE__), "ghost_wheel_namespace")
+
+module ParseHelpers
+  include GhostWheelNamespace
+  
+  private
+  
+  ##################
+  ### Assertions ###
+  ##################
+
+  def assert_parses(expected_ast, actual_ast, message = nil)
+    if message.nil?
+      parsed  = actual_ast.is_a?(ParseResult) ? actual_ast.value.inspect :
+                                                actual_ast.class
+      message = "Parsed #{parsed} while expecting #{expected_ast.inspect}."
+    end
+    
+    assert_block(message) do
+      actual_ast.is_a?(ParseResult) and actual_ast.value == expected_ast
+    end
+  end
+
+  def assert_doesnt_parse(actual_ast, message = "Parse succeeded.")
+    assert_block(message) { actual_ast.is_a?(FailedParseResult) }
+  end
+
+  def assert_parses_empty(actual_ast, message = "Parse was not empty.")
+    assert_block(message) { actual_ast.is_a?(EmptyParseResult) }
+  end
+  
+  ########################
+  ### Parser Shortcuts ###
+  ########################
+  
+  def parse(source)
+    @parser.parse(Scanner.new(source))
+  end
+
+  def parse_alternation(*expressions)
+    Alternation.new(*wrap_literals(expressions)).parse(@source)
+  end
+  
+  def parse_eof
+    EndOfFile.instance.parse(@source)
+  end
+  
+  def parse_literal(literal, *args)
+    Literal.new(literal, *args).parse(@source)
+  end
+
+  def parse_look_ahead(literal, *args)
+    LookAhead.new(Literal.new(literal), *args).parse(@source)
+  end
+
+  def parse_optional(literal)
+    Optional.new(Literal.new(literal)).parse(@source)
+  end
+
+  def parse_repetition(literal, *args)
+    Repetition.new(Literal.new(literal), *args).parse(@source)
+  end
+
+  def parse_sequence(*expressions)
+    Sequence.new(*wrap_literals(expressions)).parse(@source)
+  end
+  
+  ########################
+  ### Literal Wrappers ###
+  ########################
+  
+  def wrap_literal(literal)
+    literal.is_a?(Expression) ? literal : Literal.new(literal)
+  end
+  
+  def wrap_literals(literals)
+    literals.map { |literal| wrap_literal(literal) }
+  end
+end

data/test/parser/tc_alternation_expression.rb

@@ -0,0 +1,27 @@
+#!/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])
+
+class TestAlternationExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("null")
+  end
+  
+  def test_match
+    assert_parses("null", parse_alternation(*%w[true false null]))
+  end
+  
+  def test_failed_match
+    assert_doesnt_parse(parse_alternation(*%w[true false nil]))
+  end
+  
+  def test_empty_match
+    assert_parses_empty(parse_alternation(Empty.instance))
+  end
+end

data/test/parser/tc_empty_expression.rb

@@ -0,0 +1,15 @@
+#!/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])
+
+class TestEmptyExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def test_empty_expression
+    assert_parses_empty(Empty.instance.parse(Scanner.new("not_used")))
+  end
+end

data/test/parser/tc_end_of_file_expression.rb

@@ -0,0 +1,27 @@
+#!/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])
+
+class TestEndOfFileExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("data")
+  end
+  
+  def test_match
+    test_failed_match
+    assert_parses_empty(parse_eof)
+  end
+  
+  def test_failed_match
+    4.times do
+      assert_doesnt_parse(parse_eof)
+      @source.scan(/./)
+    end
+  end
+end

data/test/parser/tc_literal_expression.rb

@@ -0,0 +1,55 @@
+#!/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])
+
+class TestLiteralExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("some words to parse")
+  end
+  
+  def test_string_match
+    assert_parses("some", parse_literal("some"))
+  end
+  
+  def test_failed_string_match
+    assert_doesnt_parse(parse_literal("doesn't match"))
+  end
+  
+  def test_character_match
+    assert_parses("s", parse_literal(?s))
+  end
+  
+  def test_failed_character_match
+    assert_doesnt_parse(parse_literal(?S))
+  end
+  
+  def test_regexp_match
+    assert_parses("some words ", parse_literal(/(?:\w+\s+){2}/))
+  end
+  
+  def test_failed_regexp_match
+    assert_doesnt_parse(parse_literal(/(?=missing)/))
+  end
+  
+  def test_skip_literal_match
+    assert_parses_empty(parse_literal("some", true))
+  end
+  
+  def test_failed_skip_literal_match
+    assert_doesnt_parse(parse_literal("doesn't match", true))
+  end
+  
+  def test_equality
+    assert_not_equal(Literal.new("keyword"), Literal.new("tag"))
+    assert_not_equal(Literal.new("keyword"), Literal.new("keyword", true))
+
+    assert_equal(Literal.new("keyword"), Literal.new("keyword"))
+    assert_equal(Literal.new("keyword"), Literal.new(/keyword/))
+  end
+end

data/test/parser/tc_look_ahead_expression.rb

@@ -0,0 +1,41 @@
+#!/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])
+
+class TestLookAheadExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("ahead")
+  end
+
+  def test_look_ahead_match
+    assert_parses_empty(parse_look_ahead("ahead"))
+  end
+
+  def test_failed_look_ahead_match
+    assert_doesnt_parse(parse_look_ahead("missing"))
+  end
+
+  def test_negative_look_ahead_match
+    assert_parses_empty(parse_look_ahead("missing", true))
+  end
+
+  def test_failed_negative_look_ahead_match
+    assert_doesnt_parse(parse_look_ahead("ahead", true))
+  end
+  
+  def test_equality
+    assert_not_equal( LookAhead.new(Literal.new("one")),
+                      LookAhead.new(Literal.new("two")) )
+    assert_not_equal( LookAhead.new(Literal.new("one"), true),
+                      LookAhead.new(Literal.new("one")) )
+
+    assert_equal( LookAhead.new(Literal.new("one")),
+                  LookAhead.new(Literal.new("one")) )
+  end
+end