rubypeg 0.0.2

data/spec/lookahead_spec.rb

@@ -0,0 +1,101 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'rubypeg'
+
+class TestNegativeLookahead < RubyPeg
+  def root
+    node :root do 
+      one_or_more { negative || word || space }
+    end
+  end
+  
+  def negative
+    node :negative do
+      terminal('!') && not_followed_by { terminal('!') }
+    end
+  end
+  
+  def word
+    node :word do
+      terminal(/\S+/)
+    end
+  end
+  
+  def space
+    ignore { terminal(/\s+/) }
+  end
+  
+end
+
+describe TestNegativeLookahead do
+  
+  it "matches normally" do
+    TestNegativeLookahead.parse("one two three").to_ast.should == [:root,[:word,"one"],[:word,"two"],[:word,"three"]]
+  end
+  
+  it "inverts normally" do
+    TestNegativeLookahead.parse("one !two three").to_ast.should == [:root,[:word,"one"],[:negative,"!"],[:word,"two"],[:word,"three"]]
+  end
+  
+  it "looks ahead so as to interpret double negatives" do
+    TestNegativeLookahead.parse("one !!two three").to_ast.should == [:root,[:word,"one"],[:word,"!!two"],[:word,"three"]]
+  end
+end
+
+class TestPositiveLookahead < RubyPeg
+  def root
+    node :root do 
+      one_or_more {  noun || verb || adjective || adverb || word || space }
+    end
+  end
+  
+  def adjective
+    node :adjective do
+      terminal(/\S+/) && followed_by { space && noun }
+    end
+  end
+  
+  def adverb
+    node :adverb do
+      terminal(/\S+/) && followed_by { space && verb }
+    end    
+  end
+  
+  def word
+    node :word do
+      terminal(/\S+/)
+    end
+  end
+  
+  def noun
+    node :noun do
+      terminal('dog') || terminal('fox')
+    end
+  end
+  
+  def verb
+    node :verb do
+      terminal('jumped') || terminal('ran')
+    end    
+  end
+  
+  def space
+    ignore { terminal(/\s+/) }
+  end
+  
+end
+
+
+describe TestPositiveLookahead do
+  
+  it "matches normally" do
+    TestPositiveLookahead.parse("black blinking").to_ast.should == [:root,[:word,"black"],[:word,"blinking"]]
+  end
+    
+  it "matches when looking ahead" do
+    TestPositiveLookahead.parse("brown dog").to_ast.should == [:root,[:adjective,"brown"],[:noun,"dog"]]
+  end
+  
+  it "matches in slighlty more complicated squences" do
+    TestPositiveLookahead.parse("brown dog jumped as it lazily ran").to_ast.should == [:root,[:adjective,"brown"],[:noun,"dog"],[:verb,"jumped"],[:word,'as'],[:word,'it'],[:adverb,'lazily'],[:verb,'ran']]
+  end
+end

data/spec/non_terminal_spec.rb

@@ -0,0 +1,229 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'rubypeg'
+
+class NonTerminalNodeTest < RubyPeg
+  def root
+    node :one do
+      terminal("one")
+    end
+  end
+end
+
+class ChildlessNonTerminalNodeTest < RubyPeg
+  def root
+    node :one do
+      ignore { terminal("one") }
+    end
+  end
+end
+
+class MultipleChildNonTerminalNodeTest < RubyPeg
+  def root
+    node :one do 
+      terminal("one") && terminal("two")
+    end
+  end
+end
+
+# class CustomNode
+#   def initialize(children)
+#     # ignored
+#   end
+# end
+# 
+# class CustomNodeClassNonTerminalNodeTest < RubyPeg
+#   def root
+#     node CustomNode do
+#       terminal("one")
+#     end
+#   end 
+# end
+# 
+# module CustomNodeA; end
+# module CustomNodeB; end
+# 
+# class CustomNodeModuleNonTerminalNodeTest < RubyPeg
+#   def root
+#     node CustomNodeA, CustomNodeB do
+#       terminal("one")
+#     end
+#   end
+# end
+
+class CreateNonTerminalNodeTest < NonTerminalNodeTest
+  
+  def create_non_terminal_node(type,children)
+    [type,*children.map(&:to_s)]
+  end
+end
+
+describe NonTerminalNodeTest do
+  
+  def parse(text)
+    NonTerminalNodeTest.parse(text)
+  end
+  
+  it "non terminals are only created if the terminals that they contain match" do
+    parse("two").should == nil
+  end
+  
+  it "if a symbol is passed to the node method then non terminals are, by default, instances of Array that have been extended with a NonTerminalNode moduoe" do
+    parse("one").class.should == Array
+    parse("one").should be_kind_of(NonTerminalNode)
+  end
+  
+  it "NonTerminalNode instances have a type attribute that returns the symbol used as an argument to the node call" do
+    parse("one").type.should == :one
+  end  
+  
+  it "NonTerminalNode instances are an array of child nodes" do
+    parse("one").should be_kind_of(Array)
+    parse("one").first.should be_kind_of(TerminalNode)
+    parse("one").first.to_s.should == "one"
+  end  
+
+  it "if there are no children, it is an empty array" do
+    ChildlessNonTerminalNodeTest.parse("one").should == []
+  end
+  
+  it "NonTerminalNode instances respond to to_ast by returning [:type,*children]" do
+    parse("one").to_ast.should be_kind_of(Array)
+    parse("one").to_ast.should == [:one,"one"]
+    MultipleChildNonTerminalNodeTest.parse("onetwo").to_ast.should == [:one,"one","two"]
+  end
+  
+  it "NonTerminalNode instances respond to to_ast by returning [:type] if there are no children" do
+    ChildlessNonTerminalNodeTest.parse("one").to_ast.should be_kind_of(Array)
+    ChildlessNonTerminalNodeTest.parse("one").to_ast.should == [:one]
+  end
+  
+  it "NonTerminalNode instances respond to visit(builder) by trying to call a method with the same name on the builder and with its children as arguments" do
+    builder = mock(:TestBuilder)
+    builder.should_receive(:one).with {|a| a.kind_of?(TerminalNode) && a.to_s == "one"}.and_return(1)
+    parse("one").visit(builder).should == 1
+  end
+  
+  it "If the builder doesn't have a method with its name, then it calls visit(builder) on its children, returning a string if there is only one child" do
+    builder = mock(:TestBuilder)
+    parse("one").visit(builder).should == "one"
+  end
+  
+  it "If the builder doesn't have a method with its name, then it calls visit(builder) on its children, returning a an array of strings if there is more than one child" do
+    builder = mock(:TestBuilder)
+    MultipleChildNonTerminalNodeTest.parse("onetwo").visit(builder).should == ["one","two"]
+  end
+  
+  it "the class of the non terminal can be altered by overriding the create_non_terminal_node(type,children) method" do
+    result = CreateNonTerminalNodeTest.parse("one")
+    result.should be_kind_of(Array)
+    result.first.should == :one
+    result.last.should == "one"
+  end
+  
+  # it "if a class is passed to the node method then a class of that type is created as the non-terminal. Its initializer must take an array of children as its argument" do
+  #   CustomNodeClassNonTerminalNodeTest.parse("one").class.should == CustomNode
+  # end
+  # 
+  # it "if one or more modules are passed to the node method then they are used to extend the non-terminal array" do
+  #   CustomNodeModuleNonTerminalNodeTest.parse("one").should be_kind_of(Array)
+  #   CustomNodeModuleNonTerminalNodeTest.parse("one").should be_kind_of(CustomNodeA)
+  #   CustomNodeModuleNonTerminalNodeTest.parse("one").should be_kind_of(CustomNodeB)
+  # end
+  
+end
+
+class BasketPeg < RubyPeg
+  def root
+    node :basket do
+      one_or_more { items }
+    end
+  end
+  
+  def items
+    node :item do
+      number && optional_space && fruit && optional_space
+    end
+  end
+  
+  def number
+    terminal(/\d+/)
+  end
+
+  def fruit
+    node :fruit do
+      (terminal("apple") || terminal("pear")) && ignore{ optional{ terminal("s") } }
+    end
+  end
+  
+  def optional_space
+    ignore{ optional{ terminal(" ") }}
+  end
+end
+
+describe BasketPeg do
+  
+  it "Illustrates NonTerminalNode" do
+    BasketPeg.parse("1 apple 2 apples 3 pears").should be_kind_of(NonTerminalNode)
+  end
+  
+  it "Illustrates NonTerminalNode#type" do
+    BasketPeg.parse("1 apple 2 apples 3 pears").type.should == :basket
+  end
+  
+  it "Illustrates NonTerminalNode#to_ast" do
+    BasketPeg.parse("1 apple 2 apples 3 pears").to_ast.should == [:basket, [:item, "1", [:fruit, "apple"]], [:item, "2", [:fruit, "apple"]], [:item, "3", [:fruit, "pear"]]]
+  end
+  
+  it "Illustrates NonTerminalNode#to_s" do
+    BasketPeg.parse("1 apple 2 apples 3 pears").to_s.should == "1apple2apple3pear"
+  end
+  
+  it "Illustrates NonTerminalNode#inspect" do
+    BasketPeg.parse("1 apple 2 apples 3 pears").inspect.should == '[:basket, [:item, "1", [:fruit, "apple"]], [:item, "2", [:fruit, "apple"]], [:item, "3", [:fruit, "pear"]]]'
+  end
+  
+  it "Illustrates NonTerminalNode#build" do
+    BasketPeg.parse("1 apple 2 apples 3 pears").visit.should == [["1", "apple"], ["2", "apple"], ["3", "pear"]]
+    class BasketPegBuilderExample
+      attr_accessor :total
+      
+      def initialize
+        @total = 0
+      end
+      
+      def item(number,kind)
+        @total = @total + (number.to_f * kind.visit(self).to_f)
+      end
+      
+      def fruit(kind_of_fruit)
+        case kind_of_fruit
+        when "apple"; 3.0
+        when "pear"; 1.0
+        else  10.0
+        end
+      end
+    end
+    counter = BasketPegBuilderExample.new
+    BasketPeg.parse("1 apple 2 apples 3 pears").visit(counter)
+    counter.total.should == 12.0
+  end
+  
+  it "Illustrates NonTerminalNode#children" do
+    basket = BasketPeg.parse("1 apple 2 apples 3 pears")
+    basket.class.should == Array
+    basket.size.should == 3
+    basket.first.should be_kind_of(NonTerminalNode)
+    basket.first.type.should == :item
+    basket.first.class.should == Array
+    basket.first.size.should == 2
+    basket.first.first.should be_kind_of(TerminalNode)
+    basket.first.first.should == "1"
+    basket.first.last.should be_kind_of(NonTerminalNode)
+    basket.first.last.type == :fruit
+    basket.first.last.class.should == Array
+    basket.first.last.size.should == 1
+    basket.first.last.first.should be_kind_of(TerminalNode)
+    basket.first.last.first.should == "apple"
+  end
+  
+end

data/spec/peg_leg_spec.rb

@@ -0,0 +1,63 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'rubypeg'
+
+class TestLeg1 < RubyPeg
+  def root
+    node :grammar do
+      optional_indent && grammar_keyword && space && grammar_name && newline && ignore {one_or_more { terminal('end') || terminal('END')}}
+    end
+  end
+
+  def optional_indent
+    ignore { terminal(/\s*/) }
+  end
+  
+  def grammar_keyword
+    ignore { terminal('grammar') }
+  end
+  
+  def space
+    ignore { terminal(/ +/) }
+  end
+  
+  def newline
+     ignore { terminal(/\n+\s*/m) }
+  end
+  
+  def grammar_name
+    terminal(/[a-zA-Z]+/)
+  end
+end
+
+
+describe TestLeg1 do
+  
+  it "works with simple sequence" do
+    grammar = <<-EOF
+      grammar TestGrammar
+      end
+    EOF
+    TestLeg1.parse(grammar).to_ast.should == [:grammar, "TestGrammar"]
+  end
+
+  it "works with simple alternatives" do
+    grammar = <<-EOF
+      grammar TestGrammar
+      END
+    EOF
+    TestLeg1.parse(grammar).to_ast.should == [:grammar, "TestGrammar"]
+  end
+
+  it "works with one or more" do
+    grammar = <<-EOF
+      grammar TestGrammar
+      endEND
+    EOF
+    TestLeg1.parse(grammar).to_ast.should == [:grammar, "TestGrammar"]
+    grammar = <<-EOF
+      grammar TestGrammar
+
+    EOF
+    TestLeg1.parse(grammar).should == nil
+  end  
+end

data/spec/repetition_spec.rb

@@ -0,0 +1,74 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'rubypeg'
+
+class OneOrMore < RubyPeg
+  def root
+    node :root do 
+      one_or_more { terminal('x') }
+    end
+  end  
+end
+
+describe OneOrMore do
+  
+  it "matches one" do
+    OneOrMore.parse("x.").to_ast.should == [:root,'x']
+  end
+  
+  it "matches more than one" do
+    OneOrMore.parse("xx.").to_ast.should == [:root,'x','x']
+  end
+  
+  it "doesn't match none" do
+    OneOrMore.parse(".").should == nil
+  end
+  
+end
+
+class ZeroOrMore < RubyPeg
+  def root
+    node :root do 
+      any_number_of { terminal('x') }
+    end
+  end  
+end
+
+describe ZeroOrMore do
+  
+  it "matches one" do
+    ZeroOrMore.parse("x.").to_ast.should == [:root,'x']
+  end
+  
+  it "matches more than one" do
+    ZeroOrMore.parse("xx.").to_ast.should == [:root,'x','x']
+  end
+  
+  it "matches none" do
+    ZeroOrMore.parse(".").to_ast.should == [:root]
+  end
+  
+end
+
+class ZeroOrOne < RubyPeg
+  def root
+    node :root do 
+      optional { terminal('x') }
+    end
+  end  
+end
+
+describe ZeroOrOne do
+  
+  it "matches one" do
+    ZeroOrOne.parse("x.").to_ast.should == [:root,'x']
+  end
+  
+  it "doesn't match more than one" do
+    ZeroOrOne.parse("xx.").to_ast.should == [:root,'x']
+  end
+  
+  it "matches none" do
+    ZeroOrOne.parse(".").to_ast.should == [:root]
+  end
+  
+end

data/spec/sequence_spec.rb

@@ -0,0 +1,50 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'rubypeg'
+
+class SimpleSequence < RubyPeg
+  def root
+    node :root do 
+      terminal('x') && terminal('y') && terminal('z')
+    end
+  end  
+end
+
+describe SimpleSequence do
+  
+  it "matches the sequence" do
+    SimpleSequence.parse("xyz").to_ast.should == [:root,'x','y','z']
+  end
+  
+  it "doesn't matches anything else" do
+    SimpleSequence.parse("xy.").should == nil
+  end
+  
+end
+
+class RepeatedSequence < RubyPeg
+  def root
+    node :root do 
+      any_number_of { terminal('1') && ignore { terminal('2') } && terminal('3') } &&  one_or_more { terminal('x') && terminal('y') && terminal('z') } && terminal('z')
+    end
+  end  
+end
+
+describe RepeatedSequence do
+  
+  it "matches the sequence" do
+    RepeatedSequence.parse("xyzz").to_ast.should == [:root,'x','y','z','z']
+  end
+  
+  it "matches a repeated sequence" do
+    RepeatedSequence.parse("xyzxyzz").to_ast.should == [:root,'x','y','z','x','y','z','z']
+  end
+  
+  it "matches an optional repeated sequence" do
+    RepeatedSequence.parse("123123xyzxyzz").to_ast.should == [:root,'1','3','1','3','x','y','z','x','y','z','z']
+  end
+  
+  it "doesn't matches anything else" do
+    RepeatedSequence.parse("xyxy.").should == nil
+  end
+  
+end

data/spec/terminal_spec.rb

@@ -0,0 +1,118 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'rubypeg'
+
+class TerminalNodeTest < RubyPeg
+  def root
+    terminal "one"
+  end
+end
+
+describe TerminalNodeTest do
+  
+  def parse(text)
+    TerminalNodeTest.parse(text)
+  end
+  
+  it "terminals are, by default, Strings" do
+    parse("one").should == "one"
+  end
+  
+  it "they have been, by default, extended with the module TerminalNode" do
+    parse("one").should be_kind_of(TerminalNode)    
+  end
+  
+  it "TerminalNode responds to to_ast by returning itself" do
+    parse("one").to_ast.should be_kind_of(String)
+    parse("one").to_ast.should == "one"
+  end
+  
+  it "TerminalNode responds to visit(builder) by returning itself" do
+    class TestBuilder; end
+    parse("one").visit(TestBuilder.new).should be_kind_of(String)
+    parse("one").visit(TestBuilder.new).should == "one"
+  end
+  
+end
+
+class CreateTerminalNodeTest < RubyPeg
+  def root
+    terminal "one"
+  end
+  
+  def create_terminal_node(string)
+    /#{string}/
+  end
+end
+
+describe CreateTerminalNodeTest do
+  
+  def parse(text)
+    CreateTerminalNodeTest.parse(text)
+  end
+  
+  it "the class of the terminal can be altered by overriding the create_terminal_node(string) method" do
+    parse("one").should be_kind_of(Regexp)
+  end
+    
+end
+
+class StringTerminalTest < RubyPeg
+  def root
+    terminal "one"
+  end
+end
+
+describe StringTerminalTest do
+  
+  def parse(text)
+    StringTerminalTest.parse(text)
+  end
+  
+  it "if given a string, matches that string but nothing else" do
+    parse("one").to_ast.should == 'one'
+    parse("two").should == nil
+    parse("onetwo").to_ast.should == 'one'
+  end
+    
+end
+
+class RegexpTerminalTest < RubyPeg
+  def root
+    terminal /one|Two/i
+  end
+end
+
+describe RegexpTerminalTest do
+  
+  def parse(text)
+    RegexpTerminalTest.parse(text)
+  end
+  
+  it "if given a regular expression, matches that expression but nothing else" do
+    parse("one").to_ast.should == 'one'
+    parse("two").to_ast.should == 'two'
+    parse("onetwo").to_ast.should == 'one'
+    parse("three").should == nil
+  end
+    
+end
+
+class AnythingTerminalTest < RubyPeg
+  def root
+    terminal 1.0
+  end
+end
+
+describe AnythingTerminalTest do
+  
+  def parse(text)
+    AnythingTerminalTest.parse(text)
+  end
+  
+  it "if given anything else, converts it to astring and tries to match that" do
+    parse("1.0").to_ast.should == '1.0'
+    parse("1").should == nil
+    parse("1.011").to_ast.should == '1.0'
+  end
+    
+end