rley 0.1.12 → 0.2.00

data/spec/rley/parser/parsing_spec.rb

@@ -19,7 +19,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     describe Parsing do
       include GrammarABCHelper  # Mix-in module with builder for grammar abc
       include GrammarBExprHelper # Mix-in with builder for simple expressions
-    
+
       # Grammar 1: A very simple language
       # S ::= A.
       # A ::= "a" A "c".
@@ -48,7 +48,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
 
       let(:start_dotted_rule) { DottedItem.new(prod_S, 0) }
-      
+
       # Default instantiation rule
       subject { Parsing.new(start_dotted_rule, grm1_tokens) }
 
@@ -116,26 +116,30 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(new_state.dotted_rule).to eq(item1)
           expect(new_state.origin).to eq(0)
         end
-        
+
       end # context
-      
+
       context 'Parse tree building:' do
         let(:sample_grammar1) do
           builder = grammar_abc_builder
           builder.grammar
         end
-        
+
         let(:token_seq1) do
           %w(a a b c c).map do |letter|
             Token.new(letter, sample_grammar1.name2symbol[letter])
           end
         end
-        
+
         let(:b_expr_grammar) do
           builder = grammar_expr_builder
           builder.grammar
         end
 
+        def grm_symbol(aSymbolName)
+          b_expr_grammar.name2symbol[aSymbolName]
+        end
+
 
         it 'should build the parse tree for a simple non-ambiguous grammar' do
           parser = EarleyParser.new(sample_grammar1)
@@ -143,16 +147,86 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ptree = instance.parse_tree
           expect(ptree).to be_kind_of(PTree::ParseTree)
         end
-        
+
         it 'should build the parse tree for a simple expression grammar' do
           parser = EarleyParser.new(b_expr_grammar)
           tokens = expr_tokenizer('2 + 3 * 4', b_expr_grammar)
           instance = parser.parse(tokens)
           ptree = instance.parse_tree
           expect(ptree).to be_kind_of(PTree::ParseTree)
+
+          # Expect parse tree:
+          # P[0, 5]
+          # +- S[0, 5]
+          #    +- S[0, 1]
+          #       +- M[0, 1]
+          #          +- T[0, 1]
+          #          +- integer(2)[0, 1]
+          #    +- +[?, ?]
+          #    +- M[2, 5]
+          expect(ptree.root.symbol). to eq(grm_symbol('P'))
+          expect(ptree.root.range). to eq([0, 5])
+          expect(ptree.root.children.size). to eq(1)
+
+          node = ptree.root.children[0] # S
+          expect(node.symbol). to eq(grm_symbol('S'))
+          expect(node.range). to eq([0, 5])
+          expect(node.children.size). to eq(3)
+
+          (node_s, node_plus, node_m) = node.children
+          expect(node_s.symbol).to eq(grm_symbol('S'))
+          expect(node_s.range).to eq({low: 0, high: 1})
+          expect(node_s.children.size).to eq(1)
+          expect(node_plus.symbol).to eq(grm_symbol('+'))
+          expect(node_plus.range).to eq({low: 0, high: 1})  # TODO: fix this
+          expect(node_plus.token.lexeme). to eq('+')
+          expect(node_m.symbol).to eq(grm_symbol('M'))
+          expect(node_m.range).to eq({low: 2, high: 5})
+          expect(node_m.children.size).to eq(3)
+          
+          node = node_s.children[0] # M
+          expect(node.symbol).to eq(grm_symbol('M'))
+          expect(node.range).to eq([0, 1])
+          expect(node.children.size).to eq(1)
+          
+          node = node.children[0] # T
+          expect(node.symbol).to eq(grm_symbol('T'))
+          expect(node.range).to eq([0, 1])
+          expect(node.children.size).to eq(1)
+          
+          node = node.children[0] # integer(2)
+          expect(node.symbol).to eq(grm_symbol('integer'))
+          expect(node.range).to eq([0, 1])
+          expect(node.token.lexeme).to eq('2')
+          
+          (node_m2, node_star, node_t3) = node_m.children
+          expect(node_m2.symbol).to eq(grm_symbol('M'))
+          expect(node_m2.range).to eq([2, 3])
+          expect(node_m2.children.size).to eq(1)
+          
+          node_t2 = node_m2.children[0] # T
+          expect(node_t2.symbol).to eq(grm_symbol('T'))
+          expect(node_t2.range).to eq([2, 3])
+          expect(node_t2.children.size).to eq(1)
+          
+          node = node_t2.children[0] # integer(3)
+          expect(node.symbol).to eq(grm_symbol('integer'))
+          expect(node.range).to eq([2, 3])
+          expect(node.token.lexeme).to eq('3')
+          
+          expect(node_star.symbol).to eq(grm_symbol('*'))
+          expect(node_star.range).to eq([2, 3])  # Fix this
+          expect(node_star.token.lexeme). to eq('*')
+          
+          expect(node_t3.symbol).to eq(grm_symbol('T'))
+          expect(node_t3.range).to eq([4, 5])
+          expect(node_t3.children.size).to eq(1)
+          
+          node = node_t3.children[0] # integer(4)
+          expect(node.symbol).to eq(grm_symbol('integer'))
+          expect(node.range).to eq([4, 5])
+          expect(node.token.lexeme).to eq('4')
         end
-        
-        
       end # context
     end # describe
   end # module

data/spec/rley/ptree/parse_tree_spec.rb

@@ -11,7 +11,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     describe ParseTree do
       include GrammarABCHelper  # Mix-in module with builder for grammar abc
 
-
       let(:sample_grammar) do
         builder = grammar_abc_builder
         builder.grammar
@@ -19,75 +18,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       let(:sample_prod) { sample_grammar.rules[0] }
       let(:sample_range) { { low: 0, high: 5 } }
-      subject { ParseTree.new(sample_prod, sample_range) }
+      let(:sample_root) { ParseTreeNode.new(sample_prod.lhs, sample_range) }
+
+      subject do
+        ParseTree.new(sample_root)
+      end
 
       context 'Initialization:' do
-        it 'should be created with a production and a range' do
-          construction = -> { ParseTreeNode.new(sample_prod, sample_range) }
-          expect(construction).not_to raise_error
+        it 'should be created with a root node' do
+          expect { ParseTree.new(sample_root) }.not_to raise_error
         end
 
         it 'should know its root node' do
           its_root = subject.root
           expect(its_root.symbol.name).to eq('S')
           expect(its_root.range).to eq(sample_range)
-          expect(its_root.children.size).to eq(1)
-          expect(its_root.children[0].symbol.name).to eq('A')
-          expect(its_root.children[0].range).to eq(sample_range)
-        end
-
-        it 'should know its current path' do
-          path = subject.current_path
-
-          # Given the tree:
-          # S[0,5]
-          # +- A[0,5] <- current node
-          # Expected path: [S[0,5], 0, A[0,5]]
-          expect(path.size).to eq(3)
-          expect(path[0]).to eq(subject.root)
-          expect(path[1]).to eq(0)
-          expect(path[2]).to eq(subject.root.children[0])
-          expect(path[2].range).to eq(sample_range)
         end
       end # context
-
-      context 'Provided service:' do
-        it 'should add children to current node' do
-          subject.add_children(sample_grammar.rules[1], sample_range)
-
-          # Given the tree:
-          # S[0,5]
-          # +- A[0,5]
-          #    +-a[0,nil]
-          #    +-A[nil, nil]
-          #    +-c[nil, 5] <- current node
-          # Expected path: [S[0,5], 0, A[0,5], 2, c[nil, 5]]
-          path = subject.current_path
-          expect(path.size).to eq(5)
-          expect(path[3]).to eq(2)
-          expect(path[4].symbol.name).to eq('c')
-          expect(path[4].range.low).to be_nil
-          expect(path[4].range.high).to eq(5)
-        end
-
-        it 'should step back to a previous sibling node' do
-          subject.add_children(sample_grammar.rules[1], sample_range)
-          subject.step_back(4)
-          # Expected tree:
-          # S[0,5]
-          # +- A[0,5]
-          #    +-a[0,nil]
-          #    +-A[nil, 4] <- current node
-          #    +-c[4, 5]
-          # Expected path: [S[0,5], 0, A[0,5], 1, A[nil, 4]]
-          path = subject.current_path
-          expect(path.size).to eq(5)
-          expect(path[3]).to eq(1)
-          expect(path[4].symbol.name).to eq('A')
-          expect(path[4].range.low).to be_nil
-          expect(path[4].range.high).to eq(4)
-        end
-      end
     end # describe
   end # module
 end # module

data/spec/rley/ptree/token_range_spec.rb

@@ -55,6 +55,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject == me).to eq(true)
           equal = TokenRange.new(low: 0, high: 5)
           expect(subject == equal).to eq(true)
+          expect(subject == [0, 5]).to eq(true)
         end
 
       

data/spec/rley/syntax/grammar_spec.rb

@@ -141,6 +141,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know all its non-terminal symbols' do
           expect(subject.non_terminals).to eq([nt_S, nt_A]) 
         end
+        
+        it 'should know its start production' do
+          expect(subject.start_production).to eq(prod_S)
+        end
       end # context
       
       context 'Provided services:' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-22 00:00:00.000000000 Z
+date: 2015-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -103,6 +103,7 @@ files:
 - examples/grammars/grammar_L0.rb
 - examples/parsers/parsing_abc.rb
 - examples/parsers/parsing_b_expr.rb
+- examples/parsers/parsing_L0.rb
 - examples/recognizers/recognizer_abc.rb
 - lib/rley.rb
 - lib/rley/constants.rb
@@ -113,6 +114,8 @@ files:
 - lib/rley/parser/dotted_item.rb
 - lib/rley/parser/earley_parser.rb
 - lib/rley/parser/parse_state.rb
+- lib/rley/parser/parse_state_tracker.rb
+- lib/rley/parser/parse_tree_builder.rb
 - lib/rley/parser/parsing.rb
 - lib/rley/parser/state_set.rb
 - lib/rley/parser/token.rb
@@ -137,6 +140,7 @@ files:
 - spec/rley/parser/dotted_item_spec.rb
 - spec/rley/parser/earley_parser_spec.rb
 - spec/rley/parser/parse_state_spec.rb
+- spec/rley/parser/parse_tree_builder_spec.rb
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb
@@ -195,6 +199,7 @@ test_files:
 - spec/rley/parser/dotted_item_spec.rb
 - spec/rley/parser/earley_parser_spec.rb
 - spec/rley/parser/parse_state_spec.rb
+- spec/rley/parser/parse_tree_builder_spec.rb
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb