ghostwheel 0.0.1

data/test/parser/tc_sequence_expression.rb

@@ -0,0 +1,42 @@
+#!/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 TestSequenceExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def setup
+    @source = Scanner.new("3 + 42")
+  end
+  
+  def test_match
+    assert_parses( %w[3 \  + \  42],
+                   parse_sequence("3", /\s*/, ?+, /\s*/, /\d+/) )
+  end
+  
+  def test_failed_match
+    assert_doesnt_parse(parse_sequence("3", /\s*/, ?*, /\s*/, /\d+/))
+  end
+  
+  def test_sequence_trims_empty_results
+    e = Empty.instance
+    assert_parses( %w[3 \  + \  42],
+                   parse_sequence("3", e, /\s*/, ?+, e, /\s*/, /\d+/, e) )
+  end
+  
+  def test_equality
+    assert_not_equal(Sequence.new(Literal.new("one")), Sequence.new)
+    assert_not_equal( Sequence.new(Literal.new("one"), Literal.new("two")),
+                      Sequence.new(Literal.new("one")) )
+    assert_not_equal( Sequence.new(Literal.new("one"), Literal.new("two")),
+                      Sequence.new(Literal.new("a"), Literal.new("b")) )
+    
+    assert_equal(Sequence.new, Sequence.new)
+    assert_equal( Sequence.new(Literal.new("one"), Literal.new("two")),
+                  Sequence.new(Literal.new("one"), Literal.new("two")) )
+  end
+end

data/test/parser/tc_transform_expression.rb

@@ -0,0 +1,77 @@
+#!/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 TestTransformExpression < Test::Unit::TestCase
+  include GhostWheelNamespace
+  include ParseHelpers
+  
+  def test_transform_changes_parse_result
+    @parser = Transform.new(Literal.new(/(?:\\n|\\\\|[^\\]+)/)) do |str|
+      str == "\\\\" ? "\\" : str == "\\n" ? "\n" : str
+    end
+    
+    assert_parses("\n", parse("\\n"))
+    assert_parses("word", parse("word"))
+    assert_parses("\\", parse("\\\\"))
+  end
+  
+  def test_building_up_a_complex_object_with_transforms
+    build_hash_parser
+    
+    assert_parses(Hash.new, parse("{}"))
+    assert_parses({"James" => "Gray"}, parse(%Q{{"James" : "Gray"}}))
+    assert_parses( {"James" => "Gray", "Greg" => "Brown"},
+                   parse(%Q{{"James": "Gray"; "Greg": "Brown"}}) )
+  end
+  
+  def test_yields_empty
+    Transform.new(Empty.instance) do |empty|
+      assert_instance_of(EmptyParseResult, empty)
+    end.parse(Scanner.new("not_used"))
+  end
+  
+  def test_equality
+    assert_not_equal( Transform.new(Literal.new("one")) { },
+                      Transform.new(Literal.new("two")) { } )
+    assert_not_equal( Transform.new(Literal.new("one")) { Array.new },
+                      Transform.new(Literal.new("one")) { } )
+    
+    block = lambda { Array.new } # must be *exact* same block
+    assert_equal( Transform.new(Literal.new("one"), &block),
+                  Transform.new(Literal.new("one"), &block) )
+  end
+  
+  private
+  
+  def build_hash_parser
+    # optional whitespace
+    space   = Optional.new(Literal.new(/\s+/, true))
+    # a string literal
+    string  = Transform.new(Literal.new(/"[^"]*"/)) { |str| str[1..-2] }
+    # a key/value pair in the Hash
+    pair    = Transform.new(
+      Sequence.new(string, space, Literal.new(":"), space, string)
+    ) { |key_and_val| {key_and_val.first => key_and_val.last} }
+    # a pair plus separator
+    join    = Sequence.new(pair, space, Literal.new(";", true), space)
+    # the primary parser for merging a sequence of pairs into a Ruby Hash
+    @parser = Transform.new(
+      Sequence.new(
+        Literal.new("{", true),
+        space,
+        Alternation.new(
+          Transform.new(
+            Sequence.new(Repetition.new(join, 1), pair)
+          ) { |pairs| pairs.first.first + [pairs.last] },
+          Sequence.new(Optional.new(pair))
+        ),
+        space,
+        Literal.new("}", true)
+      )
+    ) { |pairs| pairs.first.inject(Hash.new) { |hash, pair| hash.merge(pair) } }
+  end
+end

data/test/ts_all.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require "ts_parser"
+require "ts_dsl"
+require "ts_example"

data/test/ts_dsl.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require "dsl/tc_ruby_dsl"
+require "dsl/tc_ghost_wheel_dsl"
+
+require "dsl/tc_build_parser"

data/test/ts_example.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require "example/tc_json_core.rb"
+require "example/tc_json_ruby.rb"
+require "example/tc_json_ghost_wheel.rb"

data/test/ts_parser.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby -w
+
+require "test/unit"
+
+require "parser/tc_scanning"
+
+require "parser/tc_literal_expression"
+require "parser/tc_sequence_expression"
+require "parser/tc_alternation_expression"
+require "parser/tc_empty_expression"
+require "parser/tc_optional_expression"
+require "parser/tc_repetition_expression"
+require "parser/tc_look_ahead_expression"
+require "parser/tc_end_of_file_expression"
+require "parser/tc_query_expression"
+require "parser/tc_transform_expression"
+require "parser/tc_rule_expression"
+
+require "parser/tc_memoization"

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: ghostwheel
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-07-02 00:00:00 -05:00
+summary: Ghost Wheel is a pure Ruby parser generator.
+require_paths: 
+- lib
+email: james@grayproductions.net
+homepage: http://ghostwheel.rubyforge.org
+rubyforge_project: ghostwheel
+description: Ghost Wheel is a packrat parser generator handling scanning and parsing of context-free grammars. Parsers can be built using an EBNF-like syntax or a with a Ruby DSL.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- James Edward Gray II
+files: 
+- lib/ghost_wheel/build_parser.rb
+- lib/ghost_wheel/errors.rb
+- lib/ghost_wheel/expression/alternation.rb
+- lib/ghost_wheel/expression/empty.rb
+- lib/ghost_wheel/expression/end_of_file.rb
+- lib/ghost_wheel/expression/literal.rb
+- lib/ghost_wheel/expression/look_ahead.rb
+- lib/ghost_wheel/expression/optional.rb
+- lib/ghost_wheel/expression/query.rb
+- lib/ghost_wheel/expression/repetition.rb
+- lib/ghost_wheel/expression/rule.rb
+- lib/ghost_wheel/expression/sequence.rb
+- lib/ghost_wheel/expression/transform.rb
+- lib/ghost_wheel/expression.rb
+- lib/ghost_wheel/parse_results.rb
+- lib/ghost_wheel/parser.rb
+- lib/ghost_wheel/parser_builder/ghost_wheel.rb
+- lib/ghost_wheel/parser_builder/ruby.rb
+- lib/ghost_wheel/scanner.rb
+- lib/ghost_wheel.rb
+- test/dsl/tc_build_parser.rb
+- test/dsl/tc_ghost_wheel_dsl.rb
+- test/dsl/tc_ruby_dsl.rb
+- test/example/tc_json_core.rb
+- test/example/tc_json_ghost_wheel.rb
+- test/example/tc_json_ruby.rb
+- test/helpers/ghost_wheel_namespace.rb
+- test/helpers/json_tests.rb
+- test/helpers/parse_helpers.rb
+- test/parser/tc_alternation_expression.rb
+- test/parser/tc_empty_expression.rb
+- test/parser/tc_end_of_file_expression.rb
+- test/parser/tc_literal_expression.rb
+- test/parser/tc_look_ahead_expression.rb
+- test/parser/tc_memoization.rb
+- test/parser/tc_optional_expression.rb
+- test/parser/tc_parser.rb
+- test/parser/tc_query_expression.rb
+- test/parser/tc_repetition_expression.rb
+- test/parser/tc_rule_expression.rb
+- test/parser/tc_scanning.rb
+- test/parser/tc_sequence_expression.rb
+- test/parser/tc_transform_expression.rb
+- test/ts_all.rb
+- test/ts_dsl.rb
+- test/ts_example.rb
+- test/ts_parser.rb
+- Rakefile
+- setup.rb
+test_files: 
+- test/ts_all.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+