rley 0.1.08 → 0.1.09

data/lib/rley/parser/parsing.rb

@@ -45,7 +45,8 @@ module Rley # This module is used as a namespace
               if ptree.current_node.is_a?(PTree::TerminalNode)
                 ptree.current_node.token = tokens[state_set_index]
               end
-              parse_state = chart[state_set_index].predecessor_state(parse_state)
+              state_set = chart[state_set_index]
+              parse_state = state_set.predecessor_state(parse_state)
               curr_dotted_item = parse_state.dotted_rule
               
             when Syntax::NonTerminal
@@ -58,8 +59,8 @@ module Rley # This module is used as a namespace
               node_range =  ptree.current_node.range
               ptree.add_children(curr_dotted_item.production, node_range)
               if ptree.current_node.is_a?(PTree::TerminalNode)
-                curr_node = ptree.current_node
-                curr_node.token = tokens[state_set_index-1] unless curr_node.token
+                a_node = ptree.current_node
+                a_node.token = tokens[state_set_index - 1] unless a_node.token
               end
               
             when NilClass
@@ -102,12 +103,12 @@ module Rley # This module is used as a namespace
       #   determine the "next" dotted rule for a given one.
       def scanning(aTerminal, aPosition, &nextMapping)
         curr_token = tokens[aPosition]
-        if curr_token.terminal == aTerminal
-          states = states_expecting(aTerminal, aPosition)
-          states.each do |s|
-            next_item = nextMapping.call(s.dotted_rule)
-            push_state(next_item, s.origin, aPosition + 1)
-          end
+        return unless curr_token.terminal == aTerminal
+        
+        states = states_expecting(aTerminal, aPosition)
+        states.each do |s|
+          next_item = nextMapping.call(s.dotted_rule)
+          push_state(next_item, s.origin, aPosition + 1)
         end
       end
 

data/lib/rley/parser/state_set.rb

@@ -42,15 +42,13 @@ module Rley # This module is used as a namespace
       # Retrieve the parse state that is the predecessor of the given one.
       def predecessor_state(aParseState)
         if aParseState.dotted_rule.prev_position.nil?
-          raise StandardError, "#{aParseState}"
+          fail StandardError, "#{aParseState}"
         else
-          prod = aParseState.dotted_rule.production
           candidate = states.find { |s| s.precedes?(aParseState) }
         end
         
         return candidate
       end
-      
 
       private
 

data/lib/rley/ptree/non_terminal_node.rb

@@ -26,4 +26,4 @@ module Rley # This module is used as a namespace
     end # class
   end # module
 end # module
-# End of file
+# End of file

data/lib/rley/ptree/parse_tree.rb

@@ -38,9 +38,9 @@ module Rley # This module is used as a namespace
         aProduction.rhs.each do |symb|
           case symb
             when Syntax::Terminal
-              new_node = TerminalNode.new(symb,{})
+              new_node = TerminalNode.new(symb, {})
             when Syntax::NonTerminal
-              new_node = NonTerminalNode.new(symb,{})
+              new_node = NonTerminalNode.new(symb, {})
           end
 
           current_node.add_child(new_node)
@@ -49,57 +49,55 @@ module Rley # This module is used as a namespace
         children = current_node.children
         children.first.range = low_bound(aRange)
         children.last.range = high_bound(aRange)
-        unless children.empty?
-          path_increment = [children.size - 1, children.last]
-          @current_path.concat(path_increment)
-        end
+        return if children.empty?
+
+        path_increment = [children.size - 1, children.last]
+        @current_path.concat(path_increment)
       end
-      
+
       # Move the current node to the parent node.
       # @param tokenPos [Fixnum] position of the matching input token
-      def step_up(tokenPos)
-        (pos, last_node) = current_path.pop(2)
+      def step_up(_tokenPos)
+        current_path.pop(2)
       end
-      
+
 
 
       # Move the current node to the previous sibling node.
       # @param tokenPos [Fixnum] position of the matching input token
       def step_back(tokenPos)
         (pos, last_node) = current_path[-2, 2]
-        last_node.range = low_bound({low: tokenPos})
-
-        if pos > 0
-          current_path.pop(2)
-          new_pos = pos - 1
-          new_curr_node = current_path.last.children[new_pos]
-          current_path << new_pos
-          current_path << new_curr_node
-          new_curr_node.range = high_bound({high: tokenPos})
-        end
+        last_node.range = low_bound(low: tokenPos)
+
+        return if pos <= 0
+        current_path.pop(2)
+        new_pos = pos - 1
+        new_curr_node = current_path.last.children[new_pos]
+        current_path << new_pos
+        current_path << new_curr_node
+        new_curr_node.range = high_bound(high: tokenPos)
       end
 
       private
 
-        def low_bound(aRange)
-          result = case aRange
-            when Hash then aRange[:low]
-            when TokenRange then aRange.low
-          end
-
-          return { low: result }
+      def low_bound(aRange)
+        result = case aRange
+          when Hash then aRange[:low]
+          when TokenRange then aRange.low
         end
 
-        def high_bound(aRange)
-          result = case aRange
-            when Hash then aRange[:high]
-            when TokenRange then aRange.high
-          end
+        return { low: result }
+      end
 
-          return { high: result }
+      def high_bound(aRange)
+        result = case aRange
+          when Hash then aRange[:high]
+          when TokenRange then aRange.high
         end
 
+        return { high: result }
+      end
     end # class
   end # module
 end # module
-# End of file
+# End of file

data/lib/rley/ptree/parse_tree_node.rb

@@ -9,7 +9,6 @@ module Rley # This module is used as a namespace
       # A range of indices for tokens corresponding to the node.
       attr_reader(:range)
 
-
       def initialize(aSymbol, aRange)
         @symbol = aSymbol
         @range = TokenRange.new(aRange)
@@ -18,8 +17,7 @@ module Rley # This module is used as a namespace
       def range=(aRange)
         range.assign(aRange)
       end
-
     end # class
   end # module
 end # module
-# End of file
+# End of file

data/lib/rley/ptree/terminal_node.rb

@@ -15,8 +15,7 @@ module Rley # This module is used as a namespace
       def accept(aVisitor)
         aVisitor.visit_terminal(self)
       end
-
     end # class
   end # module
 end # module
-# End of file
+# End of file

data/lib/rley/ptree/token_range.rb

@@ -12,18 +12,18 @@ module Rley # This module is used as a namespace
         assign_low(aRangeRep)
         assign_high(aRangeRep)
       end
-      
-      
+
+
       def ==(other)
         return true if object_id == other.object_id
-        
+
         case other
           when Hash
             result = low == other[:low] && high == other[:high]
           when TokenRange
             result = low == other.low && high == other.high
         end
-        
+
         return result
       end
 
@@ -31,31 +31,31 @@ module Rley # This module is used as a namespace
       def bounded?()
         return !(low.nil? || high.nil?)
       end
-      
+
       # Conditional assign
       def assign(aRange)
         return if bounded?
-        
+
         assign_low(aRange) if low.nil?
         assign_high(aRange) if high.nil?
       end
-      
+
       private
+
       def assign_low(aRange)
         case aRange
-        when Hash then @low = aRange.fetch(:low, nil)
-        when TokenRange then @low = aRange.low
+          when Hash then @low = aRange.fetch(:low, nil)
+          when TokenRange then @low = aRange.low
         end
       end
-      
+
       def assign_high(aRange)
         case aRange
-        when Hash then @high = aRange.fetch(:high, nil)
-        when TokenRange then @high = aRange.high
+          when Hash then @high = aRange.fetch(:high, nil)
+          when TokenRange then @high = aRange.high
         end
       end
-
     end # class
   end # module
 end # module
-# End of file
+# End of file

data/spec/rley/formatter/debug_spec.rb

@@ -10,75 +10,73 @@ require_relative '../../../lib/rley/parse_tree_visitor'
 require_relative '../../../lib/rley/formatter/debug'
 
 module Rley # Re-open the module to get rid of qualified names
-module Formatter
+  module Formatter
+    describe Debug do
+      include GrammarABCHelper  # Mix-in module for grammar abc
 
-describe Debug do
-  include GrammarABCHelper  # Mix-in module with builder for grammar abc
+      # Factory method. Build a production with the given sequence
+      # of symbols as its rhs.
+      let(:grammar_abc) do
+        builder = grammar_abc_builder
+        builder.grammar
+      end
+      
+      # Variables for the terminal symbols
+      let(:a_) { grammar_abc.name2symbol['a'] }
+      let(:b_) { grammar_abc.name2symbol['b'] }
+      let(:c_) { grammar_abc.name2symbol['c'] }
+      
+      # Helper method that mimicks the output of a tokenizer
+      # for the language specified by gramma_abc
+      let(:grm_abc_tokens1) do
+        [
+          Parser::Token.new('a', a_),
+          Parser::Token.new('a', a_),
+          Parser::Token.new('b', b_),
+          Parser::Token.new('c', c_),
+          Parser::Token.new('c', c_)
+        ]
+      end
 
-  # Factory method. Build a production with the given sequence
-  # of symbols as its rhs.
-    let(:grammar_abc) do
-      builder = grammar_abc_builder
-      builder.grammar
-    end
-    
-    # Variables for the terminal symbols
-    let(:a_) { grammar_abc.name2symbol['a'] }
-    let(:b_) { grammar_abc.name2symbol['b'] }
-    let(:c_) { grammar_abc.name2symbol['c'] }
-    
-    # Helper method that mimicks the output of a tokenizer
-    # for the language specified by gramma_abc
-    let(:grm_abc_tokens1) do
-      [
-        Parser::Token.new('a', a_),
-        Parser::Token.new('a', a_),
-        Parser::Token.new('b', b_),
-        Parser::Token.new('c', c_),
-        Parser::Token.new('c', c_)
-      ]
-    end
-
-    # Factory method that builds a sample parse tree.
-    # Generated tree has the following structure:
-    # S[0,5]
-    # +- A[0,5]
-    #    +- a[0,0]
-    #    +- A[1,4]
-    #    |  +- a[1,1]
-    #    |  +- A[2,3]
-    #    |  |  +- b[2,3]
-    #    |  +- c[3,4]
-    #    +- c[4,5]
-    # Capital letters represent non-terminal nodes
-    let(:grm_abc_ptree1) do
-      parser = Parser::EarleyParser.new(grammar_abc)
-      parse_result = parser.parse(grm_abc_tokens1)
-      parse_result.parse_tree
-    end
+      # Factory method that builds a sample parse tree.
+      # Generated tree has the following structure:
+      # S[0,5]
+      # +- A[0,5]
+      #    +- a[0,0]
+      #    +- A[1,4]
+      #    |  +- a[1,1]
+      #    |  +- A[2,3]
+      #    |  |  +- b[2,3]
+      #    |  +- c[3,4]
+      #    +- c[4,5]
+      # Capital letters represent non-terminal nodes
+      let(:grm_abc_ptree1) do
+        parser = Parser::EarleyParser.new(grammar_abc)
+        parse_result = parser.parse(grm_abc_tokens1)
+        parse_result.parse_tree
+      end
   
-  let(:destination) { StringIO.new('', 'w') }
-
-  context 'Standard creation & initialization:' do
+      let(:destination) { StringIO.new('', 'w') }
 
-    it 'should be initialized with an IO argument' do
-      expect { Debug.new(StringIO.new('', 'w')) }.not_to raise_error
-    end
-    
-    it 'should know its output destination' do
-      instance = Debug.new(destination)
-      expect(instance.output).to eq(destination)
-    end
-  end # context
+      context 'Standard creation & initialization:' do
+        it 'should be initialized with an IO argument' do
+          expect { Debug.new(StringIO.new('', 'w')) }.not_to raise_error
+        end
+        
+        it 'should know its output destination' do
+          instance = Debug.new(destination)
+          expect(instance.output).to eq(destination)
+        end
+      end # context
   
 
  
-  context 'Formatting events:' do   
-    it 'should support visit events of a parse tree' do
-      instance = Debug.new(destination)
-      visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
-      instance.render(visitor)
-      expectations = <<-SNIPPET
+      context 'Formatting events:' do   
+        it 'should support visit events of a parse tree' do
+          instance = Debug.new(destination)
+          visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
+          instance.render(visitor)
+          expectations = <<-SNIPPET
 before_ptree
   before_non_terminal
     before_children
@@ -108,12 +106,11 @@ before_ptree
   after_non_terminal
 after_ptree
 SNIPPET
-      expect(destination.string).to eq(expectations)
-    end
-  end # context
-end # describe
-
-end # module
+          expect(destination.string).to eq(expectations)
+        end
+      end # context
+    end # describe
+  end # module
 end # module
 
 # End of file

data/spec/rley/formatter/json_spec.rb

@@ -11,75 +11,73 @@ require_relative '../../../lib/rley/parse_tree_visitor'
 require_relative '../../../lib/rley/formatter/json'
 
 module Rley # Re-open the module to get rid of qualified names
-module Formatter
+  module Formatter
+    describe Json do
+      include GrammarABCHelper  # Mix-in module with builder for grammar abc
 
-describe Json do
-  include GrammarABCHelper  # Mix-in module with builder for grammar abc
-
-  # Factory method. Build a production with the given sequence
-  # of symbols as its rhs.
-    let(:grammar_abc) do
-      builder = grammar_abc_builder
-      builder.grammar
-    end
-    
-    # Variables for the terminal symbols
-    let(:a_) { grammar_abc.name2symbol['a'] }
-    let(:b_) { grammar_abc.name2symbol['b'] }
-    let(:c_) { grammar_abc.name2symbol['c'] }
-    
-    # Helper method that mimicks the output of a tokenizer
-    # for the language specified by gramma_abc
-    let(:grm_abc_tokens1) do
-      [
-        Parser::Token.new('a', a_),
-        Parser::Token.new('a', a_),
-        Parser::Token.new('b', b_),
-        Parser::Token.new('c', c_),
-        Parser::Token.new('c', c_)
-      ]
-    end
-
-    # Factory method that builds a sample parse tree.
-    # Generated tree has the following structure:
-    # S[0,5]
-    # +- A[0,5]
-    #    +- a[0,0]
-    #    +- A[1,4]
-    #    |  +- a[1,1]
-    #    |  +- A[2,3]
-    #    |  |  +- b[2,3]
-    #    |  +- c[3,4]
-    #    +- c[4,5]
-    # Capital letters represent non-terminal nodes
-    let(:grm_abc_ptree1) do
-      parser = Parser::EarleyParser.new(grammar_abc)
-      parse_result = parser.parse(grm_abc_tokens1)
-      parse_result.parse_tree
-    end
-  
-  let(:destination) { StringIO.new('', 'w') }
+      # Factory method. Build a production with the given sequence
+      # of symbols as its rhs.
+      let(:grammar_abc) do
+        builder = grammar_abc_builder
+        builder.grammar
+      end
+        
+      # Variables for the terminal symbols
+      let(:a_) { grammar_abc.name2symbol['a'] }
+      let(:b_) { grammar_abc.name2symbol['b'] }
+      let(:c_) { grammar_abc.name2symbol['c'] }
+        
+      # Helper method that mimicks the output of a tokenizer
+      # for the language specified by gramma_abc
+      let(:grm_abc_tokens1) do
+        [
+          Parser::Token.new('a', a_),
+          Parser::Token.new('a', a_),
+          Parser::Token.new('b', b_),
+          Parser::Token.new('c', c_),
+          Parser::Token.new('c', c_)
+        ]
+      end
 
-  context 'Standard creation & initialization:' do
+      # Factory method that builds a sample parse tree.
+      # Generated tree has the following structure:
+      # S[0,5]
+      # +- A[0,5]
+      #    +- a[0,0]
+      #    +- A[1,4]
+      #    |  +- a[1,1]
+      #    |  +- A[2,3]
+      #    |  |  +- b[2,3]
+      #    |  +- c[3,4]
+      #    +- c[4,5]
+      # Capital letters represent non-terminal nodes
+      let(:grm_abc_ptree1) do
+        parser = Parser::EarleyParser.new(grammar_abc)
+        parse_result = parser.parse(grm_abc_tokens1)
+        parse_result.parse_tree
+      end
+      
+      let(:destination) { StringIO.new('', 'w') }
 
-    it 'should be initialized with an IO argument' do
-      expect { Json.new(StringIO.new('', 'w')) }.not_to raise_error
-    end
-    
-    it 'should know its output destination' do
-      instance = Json.new(destination)
-      expect(instance.output).to eq(destination)
-    end
-  end # context
-  
+      context 'Standard creation & initialization:' do
+        it 'should be initialized with an IO argument' do
+          expect { Json.new(StringIO.new('', 'w')) }.not_to raise_error
+        end
+        
+        it 'should know its output destination' do
+          instance = Json.new(destination)
+          expect(instance.output).to eq(destination)
+        end
+      end # context
+      
 
- 
-  context 'Formatting events:' do   
-    it 'should render a parse tree in JSON' do
-      instance = Json.new(destination)
-      visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
-      instance.render(visitor)
-      expectations = <<-SNIPPET
+     
+      context 'Formatting events:' do   
+        it 'should render a parse tree in JSON' do
+          instance = Json.new(destination)
+          visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
+          instance.render(visitor)
+          expectations = <<-SNIPPET
 {
   "root":
     { "S": [
@@ -100,13 +98,12 @@ describe Json do
       ]
     }
 }
-SNIPPET
-      expect(destination.string).to eq(expectations.chomp)
-    end
-  end # context
-end # describe
-
-end # module
+    SNIPPET
+          expect(destination.string).to eq(expectations.chomp)
+        end
+      end # context
+    end # describe
+  end # module
 end # module
 
 # End of file