ghostwheel 0.0.1

data/test/parser/tc_memoization.rb

@@ -0,0 +1,31 @@
+#!/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 TestMemoization < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("42")
+  end
+  
+  def test_memoization
+    calls  = 0
+    parser = Transform.new(Literal.new(/\d+/)) { |ast| calls += 1; ast }
+    cache  = Hash.new
+    
+    assert_equal(0, cache.size)
+
+    parsed = parser.parse(@source, cache)
+    @source.pos = 0
+    cached = parser.parse(@source, cache)
+    
+    assert_not_equal(0, cache.size)
+    assert_same(parsed, cached)
+    assert_equal(1, calls)
+  end
+end

data/test/parser/tc_optional_expression.rb

@@ -0,0 +1,31 @@
+#!/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 TestOptionalExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("data")
+  end
+  
+  def test_match
+    assert_parses("data", parse_optional("data"))
+  end
+  
+  def test_failed_match
+    assert_parses_empty(parse_optional("missing"))
+  end
+  
+  def test_equality
+    assert_not_equal( Optional.new(Literal.new("one")),
+                      Optional.new(Literal.new("two")) )
+    
+    assert_equal( Optional.new(Literal.new("one")),
+                  Optional.new(Literal.new("one")) )
+  end
+end

data/test/parser/tc_parser.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require File.join(File.dirname(__FILE__), %w[.. helpers ghost_wheel_namespace])
+
+class TestScanning < Test::Unit::TestCase
+  include GhostWheelNamespace
+  
+  def setup
+    @parser = Parser.new
+  end
+  
+  def test_read_and_write_rules
+    assert_nil(@parser[:empty])
+    
+    @parser[:empty] = Empty.instance
+    @parser[:space] = Literal.new(/\s+/)
+    assert_equal(Empty.instance, @parser[:empty])
+    assert_equal(Literal.new(/\s+/), @parser[:space])
+  end
+  
+  def test_no_parsers_for_rules
+    @parser[:empty] = Empty.instance
+    assert( !@parser.respond_to?(:parse_empty),
+            "A parse_empty() method was defined, but not expected." )
+    assert_raise(NoMethodError) { @parser.parse_empty("not_used") }
+    assert( !@parser.respond_to?(:parse),
+            "A parse() method was defined, but not expected." )
+    assert_raise(NoMethodError) { @parser.parse("not_used") }
+  end
+  
+  def test_named_parsers
+    add_parsers
+    assert_respond_to(@parser, :parse_empty)
+    assert_raise(GhostWheel::EmptyParseError) do
+      @parser.parse_empty("not_used")
+    end
+    assert_respond_to(@parser, :parse_space)
+    assert_equal("  ", @parser.parse_space("  word"))
+  end
+  
+  def test_parse
+    # parse() works with just one rule
+    add_empty_parser
+    assert_respond_to(@parser, :parse)
+    assert_raise(GhostWheel::EmptyParseError) { @parser.parse("not_used") }
+    
+    # but not with more than one
+    add_space_parser
+    assert( !@parser.respond_to?(:parse),
+            "A parse() method was defined, but not expected." )
+    assert_raise(NoMethodError) { @parser.parse("not_used") }
+  end
+  
+  def test_pass_extra_arg
+    add_empty_parser
+    assert_equal(42, @parser.parse_empty("not_used", 42))
+    assert_equal(42, @parser.parse("not_used", 42))
+  end
+  
+  private
+  
+  def add_empty_parser
+    @parser[:empty] = Empty.instance
+    @parser.build_parser(:empty)
+  end
+  
+  def add_space_parser
+    @parser[:space] = Literal.new(/\s+/)
+    @parser.build_parser(:space)
+  end
+  
+  def add_parsers
+    add_empty_parser
+    add_space_parser
+  end
+end

data/test/parser/tc_query_expression.rb

@@ -0,0 +1,40 @@
+#!/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 TestQueryExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @parser = Query.new(Literal.new(/\d+/)) { |i| i.to_i % 2 == 0 }
+  end
+  
+  def test_query_match
+    assert_parses("12", parse("12"))
+  end
+  
+  def test_failed_query_match
+    assert_doesnt_parse(parse("13"))
+  end
+  
+  def test_yields_empty
+    Query.new(Empty.instance) do |empty|
+      assert_instance_of(EmptyParseResult, empty)
+    end.parse(Scanner.new("not_used"))
+  end
+  
+  def test_equality
+    assert_not_equal( Query.new(Literal.new("one")) { },
+                      Query.new(Literal.new("two")) { } )
+    assert_not_equal( Query.new(Literal.new("one")) { true },
+                      Query.new(Literal.new("one")) { } )
+    
+    block = lambda { true } # must be *exact* same block
+    assert_equal( Query.new(Literal.new("one"), &block),
+                  Query.new(Literal.new("one"), &block) )
+  end
+end

data/test/parser/tc_repetition_expression.rb

@@ -0,0 +1,76 @@
+#!/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 TestRepetitionExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("X" * 10 + "YZ")
+  end
+
+  def test_zero_or_more_match
+    assert_parses(["X"] * 10, parse_repetition("X"))
+  end
+
+  def test_failed_zero_or_more_match
+    assert_parses_empty(parse_repetition("Z"))
+  end
+  
+  def test_one_or_more_match
+    assert_parses(["X"] * 10, parse_repetition("X", 1))
+  end
+  
+  def test_failed_one_or_more_match
+    assert_doesnt_parse(parse_repetition("Z", 1))
+  end
+  
+  def test_with_minimum_match
+    assert_parses(["X"] * 10, parse_repetition("X", 5))
+  end
+  
+  def test_failed_with_minimum_match
+    assert_doesnt_parse(parse_repetition("Z", 15))
+  end
+  
+  def test_with_maximum_match
+    assert_parses(["X"] * 3, parse_repetition("X", 0, 3))
+    assert_parses(["X"] * 7, parse_repetition("X", 0, 20))
+  end
+  
+  def test_failed_with_maximum_match
+    assert_parses_empty(parse_repetition("X", 0, 0))
+  end
+  
+  def test_with_minimum_and_maximum_match
+    assert_parses(["X"] * 3, parse_repetition("X", 1, 3))
+  end
+  
+  def test_failed_with_minimum_and_maximum_match
+    assert_doesnt_parse(parse_repetition("X", 20, 40))
+  end
+  
+  def test_exact_count_match
+    assert_parses(["X"] * 3, parse_repetition("X", 3, 3))
+  end
+  
+  def test_failed_exact_count_match
+    assert_doesnt_parse(parse_repetition("X", 11, 11))
+  end
+  
+  def test_equality
+    assert_not_equal( Repetition.new(Literal.new("one")),
+                      Repetition.new(Literal.new("two")) )
+    assert_not_equal( Repetition.new(Literal.new("one"), 1),
+                      Repetition.new(Literal.new("one")) )
+    assert_not_equal( Repetition.new(Literal.new("one"), 1, 5),
+                      Repetition.new(Literal.new("one"), 1) )
+
+    assert_equal( Repetition.new(Literal.new("one")),
+                  Repetition.new(Literal.new("one")) )
+  end
+end

data/test/parser/tc_rule_expression.rb

@@ -0,0 +1,32 @@
+#!/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 TestRuleExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def test_simple_wrapping
+    assert_parses_empty(Rule.new(Empty.instance).parse(Scanner.new("not_used")))
+  end
+  
+  def test_forward_declaration
+    rule = Rule.new
+    assert_raise(EmptyRuleError) { rule.parse(Scanner.new("not_used")) }
+    rule.expression = Empty.instance
+    assert_parses_empty(rule.parse(Scanner.new("not_used")))
+  end
+  
+  def test_equality
+    assert_not_equal(Rule.new(Literal.new("one")), Rule.new)
+    assert_not_equal( Rule.new(Literal.new("one")),
+                      Rule.new(Literal.new("two")) )
+    
+    assert_equal(Rule.new, Rule.new)
+    assert_equal( Rule.new(Literal.new("one")),
+                  Rule.new(Literal.new("one")) )
+  end
+end

data/test/parser/tc_scanning.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require File.join(File.dirname(__FILE__), %w[.. helpers ghost_wheel_namespace])
+
+class TestScanning < Test::Unit::TestCase
+  include GhostWheelNamespace
+  
+  def setup
+    @scanner = Scanner.new("three little words")
+  end
+  
+  def test_scanner_advances_on_match
+    assert_equal("three little words", @scanner.rest)
+    assert_scan_to("little words", /\S+\s+/)
+    assert_scan_to("words", /\S+\s+/)
+  end
+  
+  def test_failed_match_does_not_advance
+    assert_equal("three little words", @scanner.rest)
+    assert_doesnt_scan(/fails/)
+    assert_scan_to("little words", /\S+\s+/)
+  end
+  
+  def test_successful_transaction
+    assert_equal("three little words", @scanner.rest)
+
+    @scanner.transaction do
+      assert_doesnt_scan(/fails/)
+      assert_scan_to("little words", /\S+\s+/)
+    end
+
+    assert_equal("little words", @scanner.rest)
+  end
+  
+  def test_aborted_transaction
+    assert_equal("three little words", @scanner.rest)
+
+    assert_nothing_raised(Exception) do
+      @scanner.transaction do
+        assert_scan_to("little words", /\S+\s+/)
+        
+        @scanner.abort
+        
+        flunk("Should never reach here.")
+      end
+    end
+
+    assert_equal("three little words", @scanner.rest)
+  end
+  
+  def test_nested_transactions
+    assert_equal("three little words", @scanner.rest)
+    
+    # nested aborts...
+    @scanner.transaction do
+      assert_scan_to("little words", /\S+\s+/)
+      
+      @scanner.transaction do
+        assert_scan_to("words", /\S+\s+/)
+
+        @scanner.abort
+
+        flunk("Should never reach here.")
+      end
+      
+      assert_equal("little words", @scanner.rest)
+
+      @scanner.abort
+
+      flunk("Should never reach here.")
+    end
+
+    assert_equal("three little words", @scanner.rest)
+    
+    # nested success...
+    @scanner.transaction do
+      assert_scan_to("little words", /\S+\s+/)
+      
+      @scanner.transaction do
+        assert_scan_to("words", /\S+\s+/)
+      end
+      
+      assert_equal("words", @scanner.rest)
+    end
+
+    assert_equal("words", @scanner.rest)
+  end
+  
+  def test_successful_transactions_auto_commit_changes
+    assert_equal("three little words", @scanner.rest)
+
+    @scanner.transaction do
+      assert_scan_to("little words", /\S+\s+/)
+      
+      @scanner.transaction do
+        assert_scan_to("words", /\S+\s+/)
+      end
+
+      assert_equal("words", @scanner.rest)
+      
+      @scanner.abort
+
+      flunk("Should never reach here.")
+    end
+
+    assert_equal("three little words", @scanner.rest)
+  end
+  
+  def test_exception_aborts_transaction
+    assert_equal("three little words", @scanner.rest)
+
+    @scanner.transaction do
+      assert_scan_to("little words", /\S+\s+/)
+      
+      assert_raise(NoMethodError) do
+        @scanner.transaction do
+          assert_scan_to("words", /\S+\s+/)
+      
+          Object.new.no_such_method  # raise an exception
+
+          flunk("Should never reach here.")
+        end
+      end
+
+      assert_equal("little words", @scanner.rest)
+    end
+
+    assert_equal("little words", @scanner.rest)
+  end
+  
+  def test_stack_underflow_error
+    # abort() without opening a transaction
+    assert_raise(StackUnderflowError) { @scanner.abort }
+  end
+  
+  def test_eos_detection
+    assert(!@scanner.eos?, "Detected eos?() with content left.")
+    assert_scan_to(String.new, /.*/m)
+    assert(@scanner.eos?, "Failed to detect eos?().")
+  end
+  
+  def test_transaction_return_value
+    assert_equal("success", @scanner.transaction { "success" })
+    assert_equal(
+      "failure",
+      @scanner.transaction { @scanner.abort("failure"); "success" }
+    )
+  end
+  
+  def test_pos
+    assert_equal("three little words", @scanner.rest)
+    
+    saved_pos = nil
+    @scanner.transaction do
+      assert_scan_to("little words", /\S+\s+/)
+      
+      @scanner.transaction do
+        assert_scan_to("words", /\S+\s+/)
+    
+        saved_pos = @scanner.pos
+        
+        @scanner.abort
+        
+        flunk("Should never reach here.")
+      end
+
+      assert_equal("little words", @scanner.rest)
+      
+      @scanner.abort
+      
+      flunk("Should never reach here.")
+    end
+    
+    assert_equal("three little words", @scanner.rest)
+
+    @scanner.pos = saved_pos
+    assert_equal("words", @scanner.rest)
+  end
+  
+  private
+  
+  def assert_scan_to(rest, regexp, message = "Scan failed.")
+    assert_block(message) { @scanner.scan(regexp) and @scanner.rest == rest }
+  end
+  
+  def assert_doesnt_scan(regexp, message = "Scan matched unexpectedly.")
+    rest = @scanner.rest
+    assert_block(message) { !@scanner.scan(regexp) and @scanner.rest == rest }
+  end
+end