dendroid 0.0.12 → 0.2.00

data/lib/dendroid/syntax/grammar.rb

@@ -17,47 +17,48 @@ module Dendroid
       # @return [Array<Dendroid::Syntax::GrmSymbol>] The terminal and non-terminal symbols.
       attr_reader :symbols
 
+      # A Hash that maps symbol names to their grammar symbols
+      # @return [Hash{String|Symbol => Dendroid::Syntax::GrmSymbol}]
+      attr_reader :name2symbol
+
       # The list of production rules for the language.
       # @return [Array<Dendroid::Syntax::Rule>] Array of rules for the grammar.
       attr_reader :rules
 
-      # A Hash that maps symbol names to their grammar symbols
-      # @return [Hash{String => Dendroid::Syntax::GrmSymbol}]
-      attr_reader :name2symbol
-
-      # TODO: make nonterminal - rules one-to-one
       # A Hash that maps symbol names to their grammar symbols
       # @return [Hash{Dendroid::Syntax::GrmSymbol => Dendroid::Syntax::Rule}]
-      attr_reader :nonterm2productions
+      attr_reader :nonterm2production
 
       # Constructor.
       # @param terminals [Array<Dendroid::Syntax::Terminal>]
       def initialize(terminals)
         @symbols = []
         @name2symbol = {}
+        @rules = []
+        @nonterm2production = {}
         add_terminals(terminals)
       end
 
-      # Add a rule to the grammar
+      # Add a rule to the grammar.
       # @param rule [Dendroid::Syntax::Rule]
       def add_rule(rule)
-        if @rules.nil?
-          @rules = []
-          @nonterm2productions = {}
+        if lhs_already_defined?(rule)
+          msg = "Non-terminal '#{rule.head}' is on left-hand side of more than one rule."
+          raise StandardError, msg
         end
-        # TODO: add test for duplicate productions
-        if nonterm2productions[rule.head]&.include? rule
-          raise StandardError, "Production rule '#{rule}' appears more than once in the grammar."
+        if duplicate_rule?(rule)
+          raise StandardError, "Duplicate production rule '#{rule}'."
         end
 
         add_symbol(rule.head)
         rule.nonterminals.each { |nonterm| add_symbol(nonterm) }
         rules << rule
-        nonterm2productions[rule.head] = [] unless nonterm2productions.include? rule.head
-        nonterm2productions[rule.head] << rule
+        nonterm2production[rule.head] = rule
       end
 
-      # Return the start symbol for the language
+      # Return the start symbol for the language, that is,
+      # the non-terminal symbol used to denote the top-level
+      # construct of the language being defined.
       # @return [Dendroid::Syntax::NonTerminal]
       def start_symbol
         rules.first.lhs
@@ -73,10 +74,14 @@ module Dendroid
 
       private
 
-      # rubocop: disable Metrics/AbcSize
-      # rubocop: disable Metrics/BlockNesting
-      # rubocop: disable Metrics/MethodLength
-      # rubocop: disable Metrics/PerceivedComplexity
+      def lhs_already_defined?(rule)
+        nonterm2production.include? rule.head
+      end
+
+      def duplicate_rule?(rule)
+        nonterm2production[rule.head]&.include? rule
+      end
+
       def add_terminals(terminals)
         terminals.each { |term| add_symbol(term) }
       end
@@ -89,6 +94,15 @@ module Dendroid
         name2symbol[symb.name.to_s] = symb
       end
 
+      def all_terminals
+        Set.new(symbols.select(&:terminal?))
+      end
+
+      def all_nonterminals
+        Set.new(symbols.reject(&:terminal?))
+      end
+
+      # Perform correctness checks of the grammar.
       def validate
         at_least_one_terminal
         are_terminals_referenced?
@@ -104,7 +118,6 @@ module Dendroid
       # Does the grammar contain at least one terminal symbol?
       def at_least_one_terminal
         found = symbols.any?(&:terminal?)
-
         return true if found
 
         err_msg = "Grammar doesn't contain any terminal symbol."
@@ -114,37 +127,28 @@ module Dendroid
       # Does every terminal symbol appear at least once
       # in a rhs of a production rule?
       def are_terminals_referenced?
-        all_terminals = Set.new(symbols.select(&:terminal?))
         terms_in_rhs = rules.reduce(Set.new) do |collected, prd|
           found = prd.terminals
           collected.merge(found)
         end
-        check_ok = all_terminals == terms_in_rhs
-        unless check_ok
-          unused_terms = all_terminals.difference(terms_in_rhs)
-          text = unused_terms.map(&:name).join("', '")
-          err_msg = "Terminal symbols '#{text}' never appear in production rules."
-          raise StandardError, err_msg
-        end
+        return true if all_terminals == terms_in_rhs
 
-        check_ok
+        unused_terms = all_terminals.difference(terms_in_rhs)
+        text = unused_terms.map(&:name).join("', '")
+        err_msg = "Terminal symbols '#{text}' never appear in production rules."
+        raise StandardError, err_msg
       end
 
       def are_nonterminals_rewritten?
-        all_nonterminals = Set.new(symbols.reject(&:terminal?))
-
         symbs_in_lhs = rules.reduce(Set.new) do |collected, prd|
           collected.add(prd.head)
         end
-        check_ok = all_nonterminals == symbs_in_lhs
-        unless check_ok
-          undefined_nterms = all_nonterminals.difference(symbs_in_lhs)
-          text = undefined_nterms.map(&:name).join("', '")
-          err_msg = "Non-terminal symbols '#{text}' never appear in head of any production rule."
-          raise StandardError, err_msg
-        end
+        return true if all_nonterminals == symbs_in_lhs
 
-        check_ok
+        undefined_nterms = all_nonterminals.difference(symbs_in_lhs)
+        text = undefined_nterms.map(&:name).join("', '")
+        err_msg = "Non-terminal symbols '#{text}' never appear in head of any production rule."
+        raise StandardError, err_msg
       end
 
       def are_symbols_reachable?
@@ -165,28 +169,31 @@ module Dendroid
         raise StandardError, err_msg
       end
 
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
       # Are all symbols reachable from start symbol?
+      # @return [Set<NonTerminal>] Set of unreachable symbols
       def unreachable_symbols
         backlog = [start_symbol]
         set_reachable = Set.new(backlog.dup)
 
-        begin
+        loop do
           reachable_sym = backlog.pop
-          prods = nonterm2productions[reachable_sym]
-          prods.each do |prd|
-            prd.rhs_symbols.each do |member|
-              unless member.terminal? || set_reachable.include?(member)
-                backlog.push(member)
-              end
-              set_reachable.add(member)
-            end
+          prd = nonterm2production[reachable_sym]
+          prd.rhs_symbols.each do |member|
+            backlog.push(member) unless member.terminal? || set_reachable.include?(member)
+            set_reachable.add(member)
           end
-        end until backlog.empty?
+          break if backlog.empty?
+        end
 
         all_symbols = Set.new(symbols)
         all_symbols - set_reachable
       end
 
+      # @return [Array<Dendroid::Syntax::NonTerminal>]
       def mark_non_productive_symbols
         prod_count = rules.size
         backlog = Set.new(0...prod_count)
@@ -204,7 +211,7 @@ module Dendroid
           backlog.subtract(to_remove)
         end
 
-        backlog.each { |i| rules[i].non_productive }
+        # backlog.each { |i| rules[i].non_productive }
         non_productive = symbols.reject(&:productive?)
         non_productive.each { |symb| symb.productive = false }
         non_productive
@@ -214,11 +221,11 @@ module Dendroid
         nullable_found = false
         sym2seqs = {}
 
-        nonterm2productions.each_pair do |sym, prods|
-          if prods.any?(&:empty?)
+        nonterm2production.each_pair do |sym, prod|
+          if prod.empty?
             sym.nullable = nullable_found = true
           else
-            sym2seqs[sym] = prods.map(&:rhs).flatten
+            sym2seqs[sym] = prod.rhs
           end
         end
 
@@ -228,7 +235,7 @@ module Dendroid
             seqs.each { |sq| backlog[sq] = [0, sym] }
           end
 
-          begin
+          loop do
             seqs_done = []
             backlog.each_pair do |sq, (elem_index, lhs)|
               member = sq[elem_index]
@@ -256,18 +263,23 @@ module Dendroid
                 backlog.delete(sq)
               end
             end
-          end until backlog.empty? || seqs_done.empty?
+            break if backlog.empty? || seqs_done.empty?
+          end
         end
 
+        # symbols.each do |sym|
+        #   next if sym.terminal?
+        #
+        #   sym.nullable = false if sym.nullable.nil?
+        # end
         symbols.each do |sym|
-          next if sym.terminal?
+          next if sym.terminal? || sym.nullable?
 
-          sym.nullable = false if sym.nullable.nil?
+          sym.nullable = false
         end
       end
       # rubocop: enable Metrics/AbcSize
-      # rubocop: enable Metrics/BlockNesting
-      # rubocop: enable Metrics/MethodLength
+      # rubocop: enable Metrics/CyclomaticComplexity
       # rubocop: enable Metrics/PerceivedComplexity
     end # class
   end # module

data/lib/dendroid/syntax/rule.rb

@@ -2,28 +2,60 @@
 
 module Dendroid
   module Syntax
-    # In a context-free grammar, a rule has its left-hand side (LHS)
-    # that consists solely of one non-terminal symbol.
-    # and the right-hand side (RHS) consists of one or more sequence of symbols.
-    # The symbols in RHS can be either terminal or non-terminal symbols.
-    # The rule stipulates that the LHS is equivalent to the RHS,
-    # in other words every occurrence of the LHS can be substituted to
-    # corresponding RHS.
+    # A specialization of the Rule class.
+    # A choice is a rule with multiple rhs
     class Rule
       # @return [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
       attr_reader :head
       alias lhs head
 
-      # Create a Rule instance.
-      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
-      def initialize(lhs)
-        @head = valid_head(lhs)
+      # @return [Array<Dendroid::Syntax::SymbolSeq>]
+      attr_reader :alternatives
+
+      # Create a Choice instance.
+      # @param theLhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
+      # @param alt [Array<Dendroid::Syntax::SymbolSeq>] the alternatives (each as a sequence of symbols).
+      def initialize(theLhs, alt)
+        @head = valid_head(theLhs)
+        @alternatives = valid_alternatives(alt)
       end
 
-      # Return the text representation of the rule
+      # Return the text representation of the choice
       # @return [String]
       def to_s
-        head.to_s
+        "#{head} => #{alternatives.join(' | ')}"
+      end
+
+      # Predicate method to check whether the choice rule body is productive.
+      # It is productive when at least one of its alternative is productive.
+      # @return [Boolean]
+      def productive?
+        productive_alts = alternatives.select(&:productive?)
+        return false if productive_alts.empty?
+
+        @productive = Set.new(productive_alts)
+        head.productive = true
+      end
+
+      # Predicate method to check whether the rule has at least one empty alternative.
+      # @return [Boolean]
+      def empty?
+        alternatives.any?(&:empty?)
+      end
+
+      # Returns an array with the symbol sequence of its alternatives
+      # @return [Array<Dendroid::Syntax::SymbolSeq>]
+      def rhs
+        alternatives
+      end
+
+      # Equality operator
+      # Two production rules are equal when their head and alternatives are equal.
+      # @return [Boolean]
+      def ==(other)
+        return true if equal?(other)
+
+        (head == other.head) && (alternatives == other.alternatives)
       end
 
       # The set of all grammar symbols that occur in the rhs.
@@ -70,6 +102,32 @@ module Dendroid
 
         lhs
       end
+
+      def valid_alternatives(alt)
+        raise StandardError, "Expecting an Array, found a #{rhs.class} instead." unless alt.is_a?(Array)
+
+        if alt.size.zero?
+          # A choice must have at least two alternatives
+          raise StandardError, "The choice for `#{head}` must have at least one alternative."
+        end
+
+        # Verify that each array element is a valid symbol sequence
+        alt.each { |elem| valid_sequence(elem) }
+
+        # Fail when duplicate rhs found
+        alt_texts = alt.map(&:to_s)
+        no_duplicate = alt_texts.uniq
+        if alt_texts.size > no_duplicate.size
+          alt_texts.each_with_index do |str, i|
+            next if str == no_duplicate[i]
+
+            err_msg = "Duplicate alternatives: #{head} => #{alt_texts[i]}"
+            raise StandardError, err_msg
+          end
+        end
+
+        alt
+      end
     end # class
   end # module
 end # module

data/spec/dendroid/grm_analysis/dotted_item_spec.rb

@@ -4,28 +4,29 @@ require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
 require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\production'
+require_relative '..\..\..\lib\dendroid\syntax\rule'
 require_relative '..\..\..\lib\dendroid\grm_analysis\dotted_item'
 
 describe Dendroid::GrmAnalysis::DottedItem do
   let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
   let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
+  let(:minus_symb) { Dendroid::Syntax::Terminal.new('MINUS') }
   let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
-  let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
+  let(:rhs1) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
+  let(:rhs2) { Dendroid::Syntax::SymbolSeq.new([num_symb, minus_symb, num_symb]) }
   let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-  let(:prod) { Dendroid::Syntax::Production.new(expr_symb, rhs) }
-  let(:empty_prod) { Dendroid::Syntax::Production.new(expr_symb, empty_body) }
+  let(:choice) { Dendroid::Syntax::Rule.new(expr_symb, [rhs1, rhs2, empty_body]) }
 
-  # Implements a dotted item: expression => NUMBER . PLUS NUMBER
-  subject { described_class.new(prod, 1) }
+  # Implements a dotted item: expression => NUMBER . MINUS NUMBER
+  subject { described_class.new(choice, 1, 1) }
 
   context 'Initialization:' do
     it 'is initialized with a production and a dot position' do
-      expect { described_class.new(prod, 1) }.not_to raise_error
+      expect { described_class.new(choice, 1, 1) }.not_to raise_error
     end
 
     it 'knows its related production' do
-      expect(subject.rule).to eq(prod)
+      expect(subject.rule).to eq(choice)
     end
 
     it 'knows its position' do
@@ -35,67 +36,78 @@ describe Dendroid::GrmAnalysis::DottedItem do
 
   context 'Provided services:' do
     it 'renders a String representation of itself' do
-      expect(subject.to_s).to eq('expression => NUMBER . PLUS NUMBER')
+      expect(subject.to_s).to eq('expression => NUMBER . MINUS NUMBER')
     end
 
     it 'knows its state' do
-      expect(described_class.new(prod, 0).state).to eq(:initial)
-      expect(described_class.new(prod, 1).state).to eq(:partial)
-      expect(described_class.new(prod, 3).state).to eq(:completed)
+      expect(described_class.new(choice, 0, 1).state).to eq(:initial)
+      expect(described_class.new(choice, 1, 1).state).to eq(:partial)
+      expect(described_class.new(choice, 3, 1).state).to eq(:completed)
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0).state).to eq(:initial_and_completed)
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2).state).to eq(:initial_and_completed)
     end
 
     it 'knows whether it is in the initial position' do
-      expect(described_class.new(prod, 0)).to be_initial_pos
-      expect(described_class.new(prod, 2)).not_to be_initial_pos
-      expect(described_class.new(prod, 3)).not_to be_initial_pos
+      expect(described_class.new(choice, 0, 0)).to be_initial_pos
+      expect(described_class.new(choice, 2, 0)).not_to be_initial_pos
+      expect(described_class.new(choice, 3, 0)).not_to be_initial_pos
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).to be_initial_pos
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).to be_initial_pos
     end
 
     it 'knows whether it is in the final position' do
-      expect(described_class.new(prod, 0)).not_to be_final_pos
-      expect(described_class.new(prod, 2)).not_to be_final_pos
-      expect(described_class.new(prod, 3)).to be_final_pos
-      expect(described_class.new(prod, 3)).to be_completed
+      expect(described_class.new(choice, 0, 1)).not_to be_final_pos
+      expect(described_class.new(choice, 2, 1)).not_to be_final_pos
+      expect(described_class.new(choice, 3, 1)).to be_final_pos
+      expect(described_class.new(choice, 3,1)).to be_completed
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).to be_final_pos
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).to be_final_pos
     end
 
     it 'knows whether it is in an intermediate position' do
-      expect(described_class.new(prod, 0)).not_to be_intermediate_pos
-      expect(described_class.new(prod, 2)).to be_intermediate_pos
-      expect(described_class.new(prod, 3)).not_to be_intermediate_pos
+      expect(described_class.new(choice, 0, 0)).not_to be_intermediate_pos
+      expect(described_class.new(choice, 2, 0)).to be_intermediate_pos
+      expect(described_class.new(choice, 3, 0)).not_to be_intermediate_pos
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).not_to be_intermediate_pos
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).not_to be_intermediate_pos
     end
 
     it 'knows the symbol after the dot (if any)' do
-      expect(described_class.new(prod, 0).next_symbol.name).to eq(:NUMBER)
-      expect(described_class.new(prod, 1).next_symbol.name).to eq(:PLUS)
-      expect(described_class.new(prod, 2).next_symbol.name).to eq(:NUMBER)
-      expect(described_class.new(prod, 3).next_symbol).to be_nil
+      expect(described_class.new(choice, 0, 1).next_symbol.name).to eq(:NUMBER)
+      expect(described_class.new(choice, 1, 1).next_symbol.name).to eq(:MINUS)
+      expect(described_class.new(choice, 2, 1).next_symbol.name).to eq(:NUMBER)
+      expect(described_class.new(choice, 3, 1).next_symbol).to be_nil
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0).next_symbol).to be_nil
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2).next_symbol).to be_nil
     end
 
-    it 'can compare a given symbol to the expected one' do
-      expect(described_class.new(prod, 0)).to be_expecting(num_symb)
-      expect(described_class.new(prod, 0)).not_to be_expecting(plus_symb)
-      expect(described_class.new(prod, 1)).to be_expecting(plus_symb)
-      expect(described_class.new(prod, 2)).to be_expecting(num_symb)
-      expect(described_class.new(prod, 3)).not_to be_expecting(num_symb)
-      expect(described_class.new(prod, 3)).not_to be_expecting(plus_symb)
-
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).not_to be_expecting(num_symb)
-      expect(described_class.new(empty_prod, 0)).not_to be_expecting(plus_symb)
+    it 'knows the symbol before the dot (if any)' do
+      expect(described_class.new(choice, 0, 1).prev_symbol).to be_nil
+      expect(described_class.new(choice, 1, 1).prev_symbol.name).to eq(:NUMBER)
+      expect(described_class.new(choice, 2, 1).prev_symbol.name).to eq(:MINUS)
+      expect(described_class.new(choice, 3, 1).prev_symbol.name).to eq(:NUMBER)
+
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 1).prev_symbol).to be_nil
+    end
+
+    it 'can compare a given symbol to the one expected' do
+      expect(described_class.new(choice, 0, 1)).to be_expecting(num_symb)
+      expect(described_class.new(choice, 0, 1)).not_to be_expecting(plus_symb)
+      expect(described_class.new(choice, 1, 0)).to be_expecting(plus_symb)
+      expect(described_class.new(choice, 1, 1)).to be_expecting(minus_symb)
+      expect(described_class.new(choice, 2, 0)).to be_expecting(num_symb)
+      expect(described_class.new(choice, 3, 1)).not_to be_expecting(num_symb)
+      expect(described_class.new(choice, 3, 1)).not_to be_expecting(plus_symb)
+
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).not_to be_expecting(num_symb)
+      expect(described_class.new(choice, 0, 2)).not_to be_expecting(plus_symb)
     end
   end # context
 end # describe

data/spec/dendroid/grm_analysis/{choice_items_spec.rb → rule_items_spec.rb}

@@ -4,11 +4,10 @@ require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
 require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\choice'
-# require_relative '..\..\..\lib\dendroid\grm_analysis\alternative_item'
-require_relative '..\..\..\lib\dendroid\grm_analysis\choice_items'
+require_relative '..\..\..\lib\dendroid\syntax\rule'
+require_relative '..\..\..\lib\dendroid\grm_analysis\rule_items'
 
-describe Dendroid::GrmAnalysis::ChoiceItems do
+describe Dendroid::GrmAnalysis::RuleItems do
   let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
   let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
   let(:star_symb) { Dendroid::Syntax::Terminal.new('STAR') }
@@ -17,8 +16,8 @@ describe Dendroid::GrmAnalysis::ChoiceItems do
   let(:alt2) { Dendroid::Syntax::SymbolSeq.new([num_symb, star_symb, num_symb]) }
   let(:alt3) { Dendroid::Syntax::SymbolSeq.new([]) }
   subject do
-    choice = Dendroid::Syntax::Choice.new(expr_symb, [alt1, alt2, alt3])
-    choice.extend(Dendroid::GrmAnalysis::ChoiceItems)
+    choice = Dendroid::Syntax::Rule.new(expr_symb, [alt1, alt2, alt3])
+    choice.extend(Dendroid::GrmAnalysis::RuleItems)
     choice.build_items
     choice
   end