rley 0.7.08 → 0.8.03

data/spec/rley/syntax/match_closest_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/symbol_seq'
+
+# Load the class under test
+require_relative '../../../lib/rley/syntax/production'
+
+# Load the class under test
+require_relative '../../../lib/rley/syntax/match_closest'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Syntax # Open this namespace to avoid module qualifier prefixes
+    describe MatchClosest do
+      # 'stmt' => 'IF boolean THEN stmt ELSE stmt'
+      let(:boolean) { NonTerminal.new('boolean') }
+      let(:stmt) { NonTerminal.new('stmt') }
+      let(:if_t) { Terminal.new('IF') }
+      let(:then_t) { Terminal.new('THEN') }
+      let(:else_t) { Terminal.new('ELSE') }
+      let(:sequence) { [if_t, boolean, then_t, stmt, else_t, stmt] }
+      let(:prod) { Production.new(stmt, sequence) }
+
+      subject { MatchClosest.new(prod.rhs.members, 4, 'IF') }
+
+      context 'Initialization:' do
+        it 'should be created with an symbol seq., an indice and a name' do
+          expect { MatchClosest.new(prod.rhs.members, 4, 'IF') }.not_to raise_error
+        end
+
+        it 'should know the index argument' do
+          expect(subject.idx_symbol).to eq(4) # ELSE at position 4
+        end
+
+        it 'should know the name of preceding symbol to pair with' do
+          expect(subject.closest_symb).to eq('IF')
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/syntax/production_spec.rb

@@ -43,6 +43,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.body).to eq(sequence)
         end
 
+        it 'should be free from constraints at start' do
+          expect(subject.constraints).to be_empty
+        end
+
         it 'should know whether its rhs is empty' do
           expect(subject).not_to be_empty
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.7.08
+  version: 0.8.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-30 00:00:00.000000000 Z
+date: 2021-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -136,8 +136,20 @@ files:
 - lib/rley/gfg/shortcut_edge.rb
 - lib/rley/gfg/start_vertex.rb
 - lib/rley/gfg/vertex.rb
+- lib/rley/interface.rb
 - lib/rley/lexical/token.rb
 - lib/rley/lexical/token_range.rb
+- lib/rley/notation/all_notation_nodes.rb
+- lib/rley/notation/ast_builder.rb
+- lib/rley/notation/ast_node.rb
+- lib/rley/notation/ast_visitor.rb
+- lib/rley/notation/grammar.rb
+- lib/rley/notation/grammar_builder.rb
+- lib/rley/notation/grouping_node.rb
+- lib/rley/notation/parser.rb
+- lib/rley/notation/sequence_node.rb
+- lib/rley/notation/symbol_node.rb
+- lib/rley/notation/tokenizer.rb
 - lib/rley/parse_forest_visitor.rb
 - lib/rley/parse_rep/ast_base_builder.rb
 - lib/rley/parse_rep/cst_builder.rb
@@ -154,11 +166,8 @@ files:
 - lib/rley/parser/parse_entry.rb
 - lib/rley/parser/parse_entry_set.rb
 - lib/rley/parser/parse_entry_tracker.rb
-- lib/rley/parser/parse_state.rb
-- lib/rley/parser/parse_state_tracker.rb
 - lib/rley/parser/parse_tracer.rb
 - lib/rley/parser/parse_walker_factory.rb
-- lib/rley/parser/state_set.rb
 - lib/rley/ptree/non_terminal_node.rb
 - lib/rley/ptree/parse_tree.rb
 - lib/rley/ptree/parse_tree_node.rb
@@ -172,10 +181,11 @@ files:
 - lib/rley/sppf/parse_forest.rb
 - lib/rley/sppf/sppf_node.rb
 - lib/rley/sppf/token_node.rb
+- lib/rley/syntax/base_grammar_builder.rb
 - lib/rley/syntax/grammar.rb
-- lib/rley/syntax/grammar_builder.rb
 - lib/rley/syntax/grm_symbol.rb
 - lib/rley/syntax/literal.rb
+- lib/rley/syntax/match_closest.rb
 - lib/rley/syntax/non_terminal.rb
 - lib/rley/syntax/production.rb
 - lib/rley/syntax/symbol_seq.rb
@@ -203,6 +213,9 @@ files:
 - spec/rley/gfg/vertex_spec.rb
 - spec/rley/lexical/token_range_spec.rb
 - spec/rley/lexical/token_spec.rb
+- spec/rley/notation/grammar_builder_spec.rb
+- spec/rley/notation/parser_spec.rb
+- spec/rley/notation/tokenizer_spec.rb
 - spec/rley/parse_forest_visitor_spec.rb
 - spec/rley/parse_rep/ambiguous_parse_spec.rb
 - spec/rley/parse_rep/ast_builder_spec.rb
@@ -212,16 +225,14 @@ files:
 - spec/rley/parse_rep/parse_forest_factory_spec.rb
 - spec/rley/parse_rep/parse_tree_factory_spec.rb
 - spec/rley/parse_tree_visitor_spec.rb
+- spec/rley/parser/dangling_else_spec.rb
 - spec/rley/parser/error_reason_spec.rb
 - spec/rley/parser/gfg_chart_spec.rb
 - spec/rley/parser/gfg_earley_parser_spec.rb
 - spec/rley/parser/gfg_parsing_spec.rb
 - spec/rley/parser/parse_entry_set_spec.rb
 - spec/rley/parser/parse_entry_spec.rb
-- spec/rley/parser/parse_state_spec.rb
-- spec/rley/parser/parse_tracer_spec.rb
 - spec/rley/parser/parse_walker_factory_spec.rb
-- spec/rley/parser/state_set_spec.rb
 - spec/rley/ptree/non_terminal_node_spec.rb
 - spec/rley/ptree/parse_tree_node_spec.rb
 - spec/rley/ptree/parse_tree_spec.rb
@@ -236,13 +247,15 @@ files:
 - spec/rley/support/grammar_arr_int_helper.rb
 - spec/rley/support/grammar_b_expr_helper.rb
 - spec/rley/support/grammar_helper.rb
+- spec/rley/support/grammar_int_seq_helper.rb
 - spec/rley/support/grammar_l0_helper.rb
 - spec/rley/support/grammar_pb_helper.rb
 - spec/rley/support/grammar_sppf_helper.rb
-- spec/rley/syntax/grammar_builder_spec.rb
+- spec/rley/syntax/base_grammar_builder_spec.rb
 - spec/rley/syntax/grammar_spec.rb
 - spec/rley/syntax/grm_symbol_spec.rb
 - spec/rley/syntax/literal_spec.rb
+- spec/rley/syntax/match_closest_spec.rb
 - spec/rley/syntax/non_terminal_spec.rb
 - spec/rley/syntax/production_spec.rb
 - spec/rley/syntax/symbol_seq_spec.rb
@@ -299,16 +312,17 @@ test_files:
 - spec/rley/gfg/vertex_spec.rb
 - spec/rley/lexical/token_range_spec.rb
 - spec/rley/lexical/token_spec.rb
+- spec/rley/notation/grammar_builder_spec.rb
+- spec/rley/notation/parser_spec.rb
+- spec/rley/notation/tokenizer_spec.rb
+- spec/rley/parser/dangling_else_spec.rb
 - spec/rley/parser/error_reason_spec.rb
 - spec/rley/parser/gfg_chart_spec.rb
 - spec/rley/parser/gfg_earley_parser_spec.rb
 - spec/rley/parser/gfg_parsing_spec.rb
 - spec/rley/parser/parse_entry_set_spec.rb
 - spec/rley/parser/parse_entry_spec.rb
-- spec/rley/parser/parse_state_spec.rb
-- spec/rley/parser/parse_tracer_spec.rb
 - spec/rley/parser/parse_walker_factory_spec.rb
-- spec/rley/parser/state_set_spec.rb
 - spec/rley/parse_forest_visitor_spec.rb
 - spec/rley/parse_rep/ambiguous_parse_spec.rb
 - spec/rley/parse_rep/ast_builder_spec.rb
@@ -325,10 +339,11 @@ test_files:
 - spec/rley/sppf/alternative_node_spec.rb
 - spec/rley/sppf/non_terminal_node_spec.rb
 - spec/rley/sppf/token_node_spec.rb
-- spec/rley/syntax/grammar_builder_spec.rb
+- spec/rley/syntax/base_grammar_builder_spec.rb
 - spec/rley/syntax/grammar_spec.rb
 - spec/rley/syntax/grm_symbol_spec.rb
 - spec/rley/syntax/literal_spec.rb
+- spec/rley/syntax/match_closest_spec.rb
 - spec/rley/syntax/non_terminal_spec.rb
 - spec/rley/syntax/production_spec.rb
 - spec/rley/syntax/symbol_seq_spec.rb

data/lib/rley/parser/parse_state.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
-    class ParseState
-      attr_reader(:dotted_rule)
-
-      # the position in the input that matches the beginning of the rhs
-      # of the production.
-      attr_reader(:origin)
-
-      def initialize(aDottedRule, theOrigin)
-        @dotted_rule = valid_dotted_rule(aDottedRule)
-        @origin = theOrigin
-      end
-
-      # Equality comparison. A parse state behaves as a value object.
-      def ==(other)
-        return true if equal?(other)
-
-        (dotted_rule == other.dotted_rule) &&
-          (origin == other.origin)
-      end
-
-      # Returns true if the dot is at the end of the rhs of the production.
-      # In other words, the complete rhs matches the input.
-      def complete?
-        dotted_rule.reduce_item?
-      end
-
-      # Returns true if the dot is at the start of the rhs of the production.
-      def predicted?
-        dotted_rule.predicted_item?
-      end
-
-      # Next expected symbol in the production
-      def next_symbol
-        dotted_rule.next_symbol
-      end
-
-      # Does this parse state have the 'other' as successor?
-      def precedes?(other)
-        return false if other == self
-
-        return false unless origin == other.origin
-
-        other_production = other.dotted_rule.production
-        return false unless dotted_rule.production == other_production
-
-        prev_position = other.dotted_rule.prev_position
-        if prev_position.nil?
-          false
-        else
-          dotted_rule.position == prev_position
-        end
-      end
-
-      # Give a String representation of itself.
-      # The format of the text representation is
-      # "format of dotted rule" + " | " + origin
-      # @return [String]
-      def to_s
-        dotted_rule.to_s + " | #{origin}"
-      end
-
-      private
-
-      # Return the validated dotted item(rule)
-      def valid_dotted_rule(aDottedRule)
-        raise StandardError, 'Dotted item cannot be nil' if aDottedRule.nil?
-
-        aDottedRule
-      end
-    end # class
-  end # module
-end # module
-
-# End of file

data/lib/rley/parser/parse_state_tracker.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
-    # Helper class that keeps track of the parse states used
-    # while a Parsing instance is constructing a parse tree.
-    class ParseStateTracker
-      # The index of the current state set
-      attr_reader(:state_set_index)
-
-      # The current parse state
-      attr_reader(:parse_state)
-
-      # The already processed states from current state set
-      attr_reader(:processed_states)
-
-      # Constructor. Refined variant of the inherited constructor.
-      def initialize(aStateSetIndex)
-        self.state_set_index = aStateSetIndex
-      end
-
-      # Write accessor. Sets the value of the state set index
-      def state_set_index=(anIndex)
-        @state_set_index = anIndex
-        @processed_states = {}
-      end
-
-      # Write accessor. Set the given parse state as the current one.
-      def parse_state=(aParseState)
-        raise StandardError, 'Nil parse state' if aParseState.nil?
-
-        @parse_state = aParseState
-        processed_states[parse_state] = true
-      end
-
-      # Take the first provided state that wasn't processed yet.
-      def select_state(theStates)
-        a_state = theStates.find { |st| !processed_states.include?(st) }
-        self.parse_state = a_state
-      end
-
-      # The dotted item for the current parse state.
-      def curr_dotted_item
-        parse_state.dotted_rule
-      end
-
-      def symbol_on_left
-        return curr_dotted_item.prev_symbol
-      end
-
-      # Notification that one begins with the previous state set
-      def to_prev_state_set
-        self.state_set_index = state_set_index - 1
-      end
-    end # class
-  end # module
-end # module
-
-# End of file

data/lib/rley/parser/state_set.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable' # Delegation
-
-module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
-    class StateSet
-      extend Forwardable
-      def_delegators :states, :empty?, :size, :first, :each
-
-      # The set of parse states
-      attr_reader(:states)
-
-      def initialize
-        @states = []
-      end
-
-      # Append the given state (if it isn't yet in the set)
-      # to the list of states
-      # @param aState [ParseState] the state to push.
-      # @return [TrueClass/FalseClass] true when the state is really added
-      def push_state(aState)
-        if include?(aState)
-          result = false
-        else
-          @states << aState
-          result = true
-        end
-
-        return result
-      end
-
-      # The list of ParseState that expect the given symbol.
-      # @param aSymbol [GrmSymbol] the expected symbol
-      #   (=on the right of the dot)
-      def states_expecting(aSymbol)
-        states.select { |s| s.dotted_rule.next_symbol == aSymbol }
-      end
-
-      # The list of complete ParseState that have the given non-terminal
-      # symbol as the lhs of their production.
-      def states_rewriting(aNonTerm)
-        return states.select do |s|
-          (s.dotted_rule.production.lhs == aNonTerm) && s.complete?
-        end
-      end
-
-      # The list of ParseState that involve the given production
-      def states_for(aProduction)
-        states.select { |s| s.dotted_rule.production == aProduction }
-      end
-
-      # Retrieve the parse state that is the predecessor of the given one.
-      def predecessor_state(aPState)
-        dotted_rule = aPState.dotted_rule
-        raise StandardError, aPState.to_s unless dotted_rule.prev_position
-
-        states.find { |s| s.precedes?(aPState) }
-      end
-
-      # The list of distinct expected terminal symbols. An expected symbol
-      # is on the left of a dot in a parse state of the parse set.
-      def expected_terminals
-        expecting_terminals = states.select do |s|
-          s.dotted_rule.next_symbol.kind_of?(Rley::Syntax::Terminal)
-        end
-
-        terminals = expecting_terminals.map { |s| s.dotted_rule.next_symbol }
-        terminals.uniq
-      end
-
-      # Return an Array of Arrays of ambiguous parse states.
-      def ambiguities
-        complete_states = states.select(&:complete?)
-        return [] if complete_states.size <= 1
-
-        # Group parse state by lhs symbol and origin
-        groupings = complete_states.group_by do |st|
-          st.dotted_rule.lhs.object_id.to_s
-        end
-
-        # Retain the groups having more than one element.
-        ambiguous_groups = []
-        groupings.each_value do |a_group|
-          ambiguous_groups << a_group if a_group.size > 1
-        end
-
-        ambiguous_groups
-      end
-
-      private
-
-      def include?(aState)
-        # TODO: make it better than linear search
-        states.include?(aState)
-      end
-    end # class
-  end # module
-end # module
-# End of file

data/spec/rley/parser/parse_state_spec.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/syntax/terminal'
-require_relative '../../../lib/rley/syntax/non_terminal'
-require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/base/dotted_item'
-
-# Load the class under test
-require_relative '../../../lib/rley/parser/parse_state'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module Parser # Open this namespace to avoid module qualifier prefixes
-    describe ParseState do
-      let(:t_a) { Syntax::Terminal.new('A') }
-      let(:t_b) { Syntax::Terminal.new('B') }
-      let(:t_c) { Syntax::Terminal.new('C') }
-      let(:nt_sentence) { Syntax::NonTerminal.new('sentence') }
-
-      let(:sample_prod) do
-        Syntax::Production.new(nt_sentence, [t_a, t_b, t_c])
-      end
-
-      let(:other_prod) do
-        Syntax::Production.new(nt_sentence, [t_a])
-      end
-
-      let(:empty_prod) do
-        Syntax::Production.new(nt_sentence, [])
-      end
-
-      let(:origin_val) { 3 }
-      let(:dotted_rule) { Base::DottedItem.new(sample_prod, 2) }
-      let(:other_dotted_rule) { double('mock-dotted-item') }
-
-      # Default instantiation rule
-      subject { ParseState.new(dotted_rule, origin_val) }
-
-      context 'Initialization:' do
-        it 'should be created with a dotted item and a origin position' do
-          args = [dotted_rule, origin_val]
-          expect { ParseState.new(*args) }.not_to raise_error
-        end
-
-        it 'should complain when the dotted rule is nil' do
-          err = StandardError
-          msg = 'Dotted item cannot be nil'
-          expect { ParseState.new(nil, 2) }.to raise_error(err, msg)
-        end
-
-        it 'should know the related dotted rule' do
-          expect(subject.dotted_rule).to eq(dotted_rule)
-        end
-
-        it 'should know the origin value' do
-          expect(subject.origin).to eq(origin_val)
-        end
-      end # context
-
-      context 'Provided services:' do
-        def new_parse_state(aProd, aRank, aVal)
-          item = Base::DottedItem.new(aProd, aRank)
-          ParseState.new(item, aVal)
-        end
-
-        it 'should compare with itself' do
-          synonym = subject # Fool Rubocop
-          expect(subject == synonym).to eq(true)
-        end
-
-        it 'should compare with another' do
-          equal = ParseState.new(dotted_rule, origin_val)
-          expect(subject == equal).to eq(true)
-
-          # Same dotted_rule, different origin
-          diff_origin = ParseState.new(dotted_rule, 2)
-          expect(subject == diff_origin).to eq(false)
-
-          # Different dotted item, same origin
-          diff_rule = ParseState.new(other_dotted_rule, 3)
-          expect(subject == diff_rule).to eq(false)
-        end
-
-        it 'should know if the parsing is at the start of the production' do
-          expect(subject).not_to be_predicted
-          at_start = Base::DottedItem.new(sample_prod, 0)
-
-          instance = ParseState.new(at_start, 0)
-          expect(instance).to be_predicted
-        end
-
-        it 'should know if the parsing reached the end of the production' do
-          expect(subject).not_to be_complete
-          at_end = Base::DottedItem.new(sample_prod, 3)
-
-          instance = ParseState.new(at_end, 2)
-          expect(instance).to be_complete
-        end
-
-        it 'should know the next expected symbol' do
-          expect(subject.next_symbol).to eq(t_c)
-        end
-
-        it 'should know whether another instance follows this one' do
-          expect(subject.precedes?(subject)).to eq(false)
-          state1 = new_parse_state(sample_prod, 1, origin_val)
-          expect(state1.precedes?(subject)).to eq(true)
-          state0 = new_parse_state(sample_prod, 0, origin_val)
-          expect(state0.precedes?(state1)).to eq(true)
-          expect(state0.precedes?(subject)).to eq(false)
-          state3 = new_parse_state(sample_prod, 3, origin_val)
-          expect(state3.precedes?(state0)).to eq(false)
-        end
-
-        it 'should know its text representation' do
-          expected = 'sentence => A B . C | 3'
-          expect(subject.to_s).to eq(expected)
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file