Spectre 0.0.1

data/test/base/semanticaction_tests.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# This is Spectre, a parser framework inspired by Boost.Spirit,
+# which can be found at http://spirit.sourceforge.net/.
+#
+# If you want to find out more or need a tutorial, go to
+# http://spectre.rubyforge.org/
+# You'll find a nice wiki there!
+#
+# Author::      Fabian Streitel (karottenreibe)
+# Copyright::   Copyright (c) 2009 Fabian Streitel
+# License::     Boost Software License 1.0
+#               For further information regarding this license, you can go to
+#               http://www.boost.org/LICENSE_1_0.txt
+#               or read the file LICENSE distributed with this software.
+# Homepage::    http://spectre.rubyforge.org/
+# Git repo::    http://rubyforge.org/scm/?group_id=7618
+#
+
+require 'rubygems'
+require 'test/unit'
+require 'spectre/string'
+
+class SemanticActionTests < Test::Unit::TestCase
+    include Spectre
+    include Spectre::StringParsing
+    include Spectre::ShortcutsMixin
+
+    def setup
+        @tag_grammar = Grammar.new do ||
+            rule :tag        => lexeme_d['<'.to_p >> blank_char >> :tagname.to_p[:tag] >> '>']
+            rule :tagname    => ( ~char('>') ).+
+            rule :border     => :tag
+            start_with :tag
+        end
+    end
+
+    def testSimpleAction
+        val = 0
+        a = lambda { val = 22 }
+        p = any_char[a]
+
+        ret = parse 'a', p
+        assert_equal 1, ret.length
+        assert_equal 'a', ret.value
+        assert_equal val, 22
+    end
+
+    def testClosureAction
+        c = @tag_grammar.closure = Closure.new
+        ret = parse '< foo>', @tag_grammar
+        assert_equal 'foo', c[:tag]
+    end
+end

data/test/generic/directive_tests.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+# This is Spectre, a parser framework inspired by Boost.Spirit,
+# which can be found at http://spirit.sourceforge.net/.
+#
+# If you want to find out more or need a tutorial, go to
+# http://spectre.rubyforge.org/
+# You'll find a nice wiki there!
+#
+# Author::      Fabian Streitel (karottenreibe)
+# Copyright::   Copyright (c) 2009 Fabian Streitel
+# License::     Boost Software License 1.0
+#               For further information regarding this license, you can go to
+#               http://www.boost.org/LICENSE_1_0.txt
+#               or read the file LICENSE distributed with this software.
+# Homepage::    http://spectre.rubyforge.org/
+# Git repo::    http://rubyforge.org/scm/?group_id=7618
+#
+
+require 'rubygems'
+require 'test/unit'
+require 'spectre/string'
+
+class DirectiveTests < Test::Unit::TestCase
+    include Spectre
+    include Spectre::StringParsing
+    include Spectre::ShortcutsMixin
+
+    def testNoActionD
+        val = 1
+        
+        tester = lambda { |m,c|
+            val += 12
+        }
+
+        p = noaction_d[any_char[tester]]
+        ret = parse 'aaa', p
+        assert_kind_of Match, ret
+        assert_equal 1, val
+        assert_equal "a", ret.value
+    end
+
+    def testResetD
+        val = 1
+        
+        tester = lambda { |m,c|
+            val += 12
+        }
+
+        p = noaction_d[reset_d[any_char[tester]]]
+        ret = parse 'aa', p
+        assert_kind_of Match, ret
+        assert_equal 13, val
+    end
+
+    class Limit
+        include Comparable
+
+        def initialize fn
+            @fn = fn
+        end
+
+        def <=> s
+            @fn <=> s.length
+        end
+    end
+
+    def testLimitD
+        p = limit_d(Limit.new(2),Limit.new(4))[any_char.*]
+        ret = parse 'aa', p
+        assert_kind_of Match, ret
+        ret = parse 'aaa', p
+        assert_kind_of Match, ret
+        ret = parse 'aaaa', p
+        assert_kind_of Match, ret
+        ret = parse 'a', p
+        assert_kind_of NilClass, ret
+        ret = parse 'aaaaa', p
+        assert_kind_of NilClass, ret
+    end
+
+    def testSkipD
+        p = skip_d(['a', 'b', 'c'].to_p)[blank_char >> any_char]
+
+        ret = parse ' u', p
+        assert_kind_of Match, ret
+        assert_equal 2, ret.length
+
+        ret = parse 'abcabc abcu', p
+        assert_kind_of Match, ret
+        assert_equal 11, ret.length
+
+        p = skip_d(["\n", "\r", "\t", "\f", " "].to_p)[char("a") >> any_char]
+        ret = parse " \n  \r a \t\fu  ", p
+        assert_kind_of Match, ret
+    end
+
+    class SP < StringParser
+        class << self
+            attr_accessor :val
+
+            def new *args
+                Spectre::Node.new super(*args)
+            end
+        end
+
+        def scan *args
+            SP.val += 1
+            super(*args)
+        end
+    end
+
+    def testLongestD
+        SP.val = 0
+        p = longest_d[SP.new('a')|SP.new('ab')|SP.new('aac')]
+        ret = parse "aac", p
+        assert_equal 3, SP.val
+        assert_kind_of Match, ret
+        assert_equal "aac", ret.value
+
+        SP.val = 0
+        ret = parse "ab", p
+        assert_equal 3, SP.val
+        assert_kind_of Match, ret
+        assert_equal "ab", ret.value
+
+        SP.val = 0
+        ret = parse "a", p
+        assert_equal 3, SP.val
+        assert_kind_of Match, ret
+        assert_equal "a", ret.value
+    end
+
+    def testShortestD
+        SP.val = 0
+        p = shortest_d[SP.new('a')|SP.new('ab')|SP.new('cac')]
+        ret = parse "cac", p
+        assert_equal 3, SP.val
+        assert_kind_of Match, ret
+        assert_equal "cac", ret.value
+
+        SP.val = 0
+        ret = parse "ab", p
+        assert_equal 3, SP.val
+        assert_kind_of Match, ret
+        assert_equal "a", ret.value
+
+        SP.val = 0
+        ret = parse "a", p
+        assert_equal 3, SP.val
+        assert_kind_of Match, ret
+        assert_equal "a", ret.value
+    end
+
+    def testLexemeD
+        p = noskip_d[char('a') >> char('b')]
+        p = lexeme_d[char('a') >> char('b')]
+        ret = parse "ab", p
+        assert_kind_of Match, ret
+        assert_equal "ab", ret.value
+        assert_equal 2, ret.length
+
+        ret = parse " ab", p
+        assert_kind_of Match, ret
+        assert_equal "ab", ret.value
+        assert_equal 3, ret.length
+
+        ret = parse "a b", p
+        assert_kind_of NilClass, ret
+
+        p = char('o') >> lexeme_d[char('a') >> char('b')]
+        ret = parse "o ab", p
+        assert_kind_of Match, ret
+        assert_equal "oab", ret.value
+        assert_equal 4, ret.length
+
+        ret = parse "oab", p
+        assert_kind_of Match, ret
+        assert_equal "oab", ret.value
+        assert_equal 3, ret.length
+    end
+
+    def testNoPreSkipLexemeD
+        p = noskip_d![char('a') >> char('b')]
+        p = lexeme_d![char('a') >> char('b')]
+        ret = parse "ab", p
+        assert_kind_of Match, ret
+        assert_equal "ab", ret.value
+        assert_equal 2, ret.length
+
+        ret = parse "a b", p
+        assert_kind_of NilClass, ret
+
+        ret = parse " ab", p
+        assert_kind_of NilClass, ret
+
+        p = char('o') >> lexeme_d![char('a') >> char('b')]
+        ret = parse "o ab", p
+        assert_kind_of NilClass, ret
+
+        ret = parse "oab", p
+        assert_kind_of Match, ret
+        assert_equal "oab", ret.value
+        assert_equal 3, ret.length
+    end
+
+    def testEpsilonD
+        p = epsilon[string("foo")]
+        p = e[string("foo")]
+        ret = parse "foo", p
+        assert_kind_of Match, ret
+        assert_equal 0, ret.length
+        assert_equal "foo", ret.value
+
+        ret = parse "  foo", p
+        assert_kind_of Match, ret
+        assert_equal 0, ret.length
+        assert_equal "foo", ret.value
+
+        ret = parse "bar", p
+        assert_kind_of NilClass, ret
+    end
+
+end
+

data/test/generic/negation_tests.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# This is Spectre, a parser framework inspired by Boost.Spirit,
+# which can be found at http://spirit.sourceforge.net/.
+#
+# If you want to find out more or need a tutorial, go to
+# http://spectre.rubyforge.org/
+# You'll find a nice wiki there!
+#
+# Author::      Fabian Streitel (karottenreibe)
+# Copyright::   Copyright (c) 2009 Fabian Streitel
+# License::     Boost Software License 1.0
+#               For further information regarding this license, you can go to
+#               http://www.boost.org/LICENSE_1_0.txt
+#               or read the file LICENSE distributed with this software.
+# Homepage::    http://spectre.rubyforge.org/
+# Git repo::    http://rubyforge.org/scm/?group_id=7618
+#
+
+require 'rubygems'
+require 'test/unit'
+require 'spectre/string'
+
+class GenericNegationTests < Test::Unit::TestCase
+    include Spectre
+    include Spectre::Operators
+    include Spectre::StringParsing
+
+    def testSingleTokenNegation
+        p = Node.new Negation.new, CharParser.new("a")
+        iter = StringInputIterator.new "asdf"
+        ret = p.parse iter
+        assert_kind_of NilClass, ret
+        assert_equal 0, iter.pos
+
+        iter = StringInputIterator.new "33df"
+        ret = p.parse iter
+        assert_kind_of Match, ret
+        assert_equal 1, ret.length
+        assert_equal "3", ret.value
+        assert_equal 1, iter.pos
+
+        iter = StringInputIterator.new "  33df"
+        ret = p.parse iter
+        assert_kind_of Match, ret
+        assert_equal 3, ret.length
+        assert_equal "3", ret.value
+        assert_equal 3, iter.pos
+
+        iter = StringInputIterator.new "\tdf"
+        ret = p.parse iter
+        assert_kind_of Match, ret
+        assert_equal 2, ret.length
+        assert_equal "d", ret.value
+        assert_equal 2, iter.pos
+    end
+
+    def testZeroTokenNegation
+        p = Node.new Negation.new, EOIParser.new
+        iter = StringInputIterator.new " asdf"
+        ret = p.parse iter, false
+        assert_kind_of Match, ret
+        assert_equal 0, ret.length
+        assert_equal "", ret.value
+        assert_equal 0, iter.pos
+
+        iter = StringInputIterator.new "   "
+        ret = p.parse iter
+        assert_kind_of NilClass, ret
+        assert_equal 0, iter.pos
+
+        iter = StringInputIterator.new ""
+        ret = p.parse iter
+        assert_kind_of NilClass, ret
+        assert_equal 0, iter.pos
+    end
+
+    def testSequenceNegation
+        p = Node.new Negation.new, SequenceParser.new("foa")
+        iter = StringInputIterator.new " a of"
+        ret = p.parse iter
+        assert_kind_of Match, ret
+        assert_equal 1, ret.length
+        assert_equal "", ret.value
+        assert_equal 1, iter.pos
+
+        iter = StringInputIterator.new "   "
+        ret = p.parse iter, false
+        assert_kind_of Match, ret
+        assert_equal 0, ret.length
+        assert_equal "", ret.value
+        assert_equal 0, iter.pos
+
+        iter = StringInputIterator.new "fo a"
+        ret = p.parse iter
+        assert_kind_of NilClass, ret
+        assert_equal 0, iter.pos
+    end
+
+    def testStringNegation
+        p = Node.new Negation.new, StringParser.new("foo")
+        iter = StringInputIterator.new " asdf"
+        ret = p.parse iter
+        assert_kind_of Match, ret
+        assert_equal 1, ret.length
+        assert_equal "", ret.value
+        assert_equal 1, iter.pos
+
+        iter = StringInputIterator.new "   "
+        ret = p.parse iter, false
+        assert_kind_of Match, ret
+        assert_equal 0, ret.length
+        assert_equal "", ret.value
+        assert_equal 0, iter.pos
+
+        iter = StringInputIterator.new "foo"
+        ret = p.parse iter
+        assert_kind_of NilClass, ret
+        assert_equal 0, iter.pos
+    end
+
+    def testClosureParserNegation
+        gram = Grammar.new do ||
+            start_with close( lower_char[:foo] >> ~closed(:foo) )
+        end
+
+        iter = StringInputIterator.new 'ab'
+        ret = gram.parse iter
+        assert_kind_of Match, ret
+        assert_equal 2, ret.length
+        assert_equal "ab", ret.value
+        assert_equal 2, iter.pos
+
+        iter = StringInputIterator.new '  ab'
+        ret = gram.parse iter
+        assert_kind_of Match, ret
+        assert_equal 4, ret.length
+        assert_equal "ab", ret.value
+        assert_equal 4, iter.pos
+
+        iter = StringInputIterator.new '  aa'
+        ret = gram.parse iter
+        assert_kind_of NilClass, ret
+    end
+
+end
+

data/test/generic/primitive_tests.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# This is Spectre, a parser framework inspired by Boost.Spirit,
+# which can be found at http://spirit.sourceforge.net/.
+#
+# If you want to find out more or need a tutorial, go to
+# http://spectre.rubyforge.org/
+# You'll find a nice wiki there!
+#
+# Author::      Fabian Streitel (karottenreibe)
+# Copyright::   Copyright (c) 2009 Fabian Streitel
+# License::     Boost Software License 1.0
+#               For further information regarding this license, you can go to
+#               http://www.boost.org/LICENSE_1_0.txt
+#               or read the file LICENSE distributed with this software.
+# Homepage::    http://spectre.rubyforge.org/
+# Git repo::    http://rubyforge.org/scm/?group_id=7618
+#
+
+require 'rubygems'
+require 'test/unit'
+require 'spectre/string'
+
+class StringPrimitivesTests < Test::Unit::TestCase
+    include Spectre
+    include Spectre::StringParsing
+    include Spectre::ShortcutsMixin
+
+    def testRangeParser
+        p = RangeParser.new "a".."c"
+        ret = parse "a", p
+        assert_kind_of Match, ret
+        assert_equal 1, ret.length
+        assert_equal "a", ret.value
+
+        ret = parse "chunky", p
+        assert_kind_of Match, ret
+        assert_equal 1, ret.length
+        assert_equal "c", ret.value
+
+        ret = parse "1", p
+        assert_kind_of NilClass, ret
+
+        ret = parse "zba", p
+        assert_kind_of NilClass, ret
+
+        ret = parse "", p
+        assert_kind_of NilClass, ret
+    end
+
+    def testSequenceParser
+        p = SequenceParser.new "chunky".split("")
+        ret = parse "chunky-b", p
+        assert_kind_of Match, ret
+        assert_equal 6, ret.length
+        assert_equal "chunky", ret.value
+
+        ret = parse "chunky", p
+        assert_kind_of Match, ret
+        assert_equal 6, ret.length
+        assert_equal "chunky", ret.value
+
+        ret = parse "\tc h  u\nnk y\f", p
+        assert_kind_of Match, ret
+        assert_equal 12, ret.length
+        assert_equal "chunky", ret.value
+
+        ret = parse "z", p
+        assert_kind_of NilClass, ret
+
+        ret = parse "", p
+        assert_kind_of NilClass, ret
+    end
+
+    def testNothingParser
+        p = NothingParser.new
+        ret = parse "asdf", p
+        assert_kind_of NilClass, ret
+
+        ret = parse "", p
+        assert_kind_of NilClass, ret
+    end
+
+    def testEOIParser
+        p = EOIParser.new
+        ret = parse "asdf", p
+        assert_kind_of NilClass, ret
+
+        ret = parse "", p
+        assert_kind_of Match, ret
+        assert_equal 0, ret.length
+        assert_equal "", ret.value
+        
+        ret = parse "   ", p
+        assert_kind_of Match, ret
+        assert_equal 0, ret.length
+        assert_equal "", ret.value
+    end
+end
+