dendroid 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a762fb52e0c8ff6116f41f481b5cb7346b99050d90f77c4e133da37a31dda3b3
-  data.tar.gz: ace142c5221c038eedaab8ea9882a3fbffa34cb424be08083ee722e9e5d8c6ca
+  metadata.gz: 989c88ea00734b7145dfc64ded1318c296a3678039213904c15ead0a306942a2
+  data.tar.gz: 73aa3efff885fcf1f71f23c7907b7c7b953fd3b174aefb9324a1326663652a9c
 SHA512:
-  metadata.gz: 2746b3e1cd03e07e0045d7e41b54ed4c8a2f003df89ea45166fa0b66013f37aa9c1cf0044adc71bbe75d5958d99334b7f612d15c116954fe451f8e1e6756bfaa
-  data.tar.gz: 4917fd27358d80719b722c14a6df8636917ad827dfc29fb8201920b068393dba09dd2b9750d8b5946031a1d821bd6922c84dd27572b4a635e709faa4bfe31ceb
+  metadata.gz: 906746623d20819ce0f1923c8156a27c7ce58b2d926174e0a1dff611407bd873378272c2a2125bb665c8aec20c3beef787942c9fc7f0376aff22e7db4fb6a235
+  data.tar.gz: 34f3aabf74b7598a506e3acd38c9df03a7040203e8a9bda2fa02804b96ea0054d17c3044c7ca1384380bdb55af2cd80f1b9e88baa1b5c985642797cc68d80783

data/.rubocop.yml

@@ -4,7 +4,7 @@ Layout/EndOfLine:
 
 Metrics/AbcSize:
   Enabled: true
-  Max: 25
+  Max: 29
 
 Metrics/BlockLength:
   Enabled: true
@@ -13,10 +13,18 @@ Metrics/BlockLength:
 Metrics/ClassLength:
   Enabled: true
   Max: 200
+  
+Metrics/CyclomaticComplexity:  
+  Enabled: true
+  Max: 10
 
 Metrics/MethodLength:
   Enabled: true
-  Max: 20
+  Max: 30
+  
+Metrics/PerceivedComplexity:
+  Enabled: true
+  Max: 10  
 
 Naming/MethodParameterName:
   Enabled: false

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [0.0.8] - 2023-10-30
+### Added
+- Class `DottedItem` and its spec file
+
+## [0.0.7] - 2023-10-30
+### Added
+- Class `BaseGrmBuilder` and its spec file
 
 ## [0.0.6] - 2023-10-30
 ### Added

data/README.md

@@ -3,10 +3,12 @@ dendroid
 
 A Ruby implementation of the Earley parsing algorithm. WIP
 
+dendroid - Resembling a tree in form and branching structure.
+
 Features
 --------
 
-* WIP 
+* WIP
 
 Examples
 --------

data/lib/dendroid/grm_analysis/dotted_item.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Dendroid
+  module GrmAnalysis
+    # For a given production rule, a dotted item represents a recognition state.
+    # The dot partitions the rhs of the rule in two parts:
+    # a) the left part consists of the symbols in the rhs that are matched
+    # by the input tokens.
+    # b) The right part consists of symbols that are predicted to match the
+    # input tokens.
+    # The terminology stems from the traditional way to visualize the partition
+    # by using a fat dot character as a separator between the left and right
+    # parts.
+    # An item with the dot at the beginning (i.e. before any rhs symbol)
+    #  is called a predicted item.
+    # An item with the dot at the end (i.e. after all rhs symbols)
+    #  is called a reduce item.
+    # An item with a dot in front of a terminal is called a shift item.
+    # An item with the dot not at the beginning is sometimes referred to as a kernel item
+    class DottedItem
+      # Reference to the production rule
+      # @return [Dendroid::Syntax::Production]
+      attr_reader :rule
+
+      # @return [Integer] the dot position
+      attr_reader :position
+
+      # Constructor.
+      # @param aRule [Dendroid::Syntax::Rule]
+      # @param aPosition [Integer] Position of the dot in rhs of production.
+      def initialize(aRule, aPosition)
+        @rule = aRule
+        @position = valid_position(aPosition)
+      end
+
+      # Return a String representation of the dotted item.
+      # @return [String]
+      def to_s
+        rhs_names = rule.body.map(&:to_s)
+        dotted_rhs = rhs_names.insert(position, '.')
+        "#{rule.head} => #{dotted_rhs.join(' ')}"
+      end
+
+      # Indicate whether the rhs of the rule is empty
+      # @return [Boolean]
+      def empty?
+        rule.empty?
+      end
+
+      # Terminology inspired from Luger's book
+      # @return [Symbol] one of: :initial, :initial_and_completed, :partial, :completed
+      def state
+        return :initial_and_completed if empty?
+        return :initial if position.zero?
+
+        position == rule.body.size ? :completed : :partial
+      end
+
+      # Indicate whether the dot is at the start of rhs
+      # @return [Boolean]
+      def initial_pos?
+        position.zero? || empty?
+      end
+
+      # Indicate whether the dot is at the end of rhs
+      # @return [Boolean]
+      def final_pos?
+        empty? || position == rule.body.size
+      end
+
+      alias completed? final_pos?
+
+      # Indicate the dot isn't at start nor at end position
+      # @return [Boolean]
+      def intermediate_pos?
+        return false if empty? || position.zero?
+
+        position < rule.body.size
+      end
+
+      # Return the symbol right after the dot (if any)
+      # @return [Dendroid::Syntax::GrmSymbol, NilClass]
+      def next_symbol
+        return nil if empty? || completed?
+
+        rule.body[position]
+      end
+
+      # Check whether the given symbol is the same as after the dot.
+      # @param [Dendroid::Syntax::GrmSymbol]
+      # @return [Boolean]
+      def expecting?(aSymbol)
+        actual = next_symbol
+        return false if actual.nil?
+
+        actual == aSymbol
+      end
+
+      # Check whether the dotted item is a shift item.
+      # In other words, it expects a terminal to be next symbol
+      # @return [Boolean]
+      def pre_scan?
+        next_symbol&.terminal?
+      end
+
+      # Test for equality with another dotted item.
+      # Two dotted items are equal if they refer to the same rule and
+      # have both the same rhs and dot positions.
+      # @return [Boolean]
+      def ==(other)
+        return true if eql?(other)
+
+        (position == other.position) && rule.eql?(other.rule)
+      end
+
+      private
+
+      def valid_position(aPosition)
+        raise StandardError if aPosition.negative? || aPosition > rule.body.size
+
+        aPosition
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/grm_dsl/base_grm_builder.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative '..\syntax\terminal'
+require_relative '..\syntax\non_terminal'
+require_relative '..\syntax\symbol_seq'
+require_relative '..\syntax\production'
+require_relative '..\syntax\choice'
+require_relative '..\syntax\grammar'
+
+module Dendroid
+  # This module contains classes that define Domain-Specific Language specialized
+  # in grammar definition.
+  module GrmDSL
+    # Builder GoF pattern: Builder builds a complex object.
+    #   here the builder creates a grammar from simpler objects
+    #   (symbols and production rules)
+    #   and using a step by step approach.
+    class BaseGrmBuilder
+      # @return [Symbol] one of: :declaring, :building, :complete
+      attr_reader :state
+
+      # @return [Hash{String, Dendroid::Syntax::GrmSymbol}] The mapping of grammar symbol names
+      #   to the matching grammar symbol object.
+      attr_reader :symbols
+
+      # @return [Array<Dendroid::Syntax::Rule>] The list of rules of the grammar
+      attr_reader :rules
+
+      # Creates a new grammar builder object.
+      # @param aBlock [Proc] code block used to build the grammar.
+      # @example Building a tiny English grammar
+      #   builder = Rley::Syntax::GrammarBuilder.new do
+      #     declare_terminals('n', 'v', 'adj', 'det')
+      #     rule 'S' => 'NP VP'
+      #     rule 'VP' => 'v NP'
+      #     rule 'NP' => ['det n', 'adj NP']
+      #   end
+      #   # Now with `builder`, let's create the grammar
+      #   tiny_eng = builder.grammar
+      def initialize(&aBlock)
+        @symbols = {}
+        @rules = []
+        @state = :declaring
+
+        return unless block_given?
+
+        instance_exec(&aBlock)
+        grammar_complete!
+      end
+
+      # Add the given terminal symbols to the grammar of the language
+      # @param terminalSymbols [String, Terminal] 1..* terminal symbols.
+      # @return [void]
+      def declare_terminals(*terminalSymbols)
+        err_msg = "Terminal symbols may only be declared in state :declaring, current state is: #{state}"
+        raise StandardError, err_msg unless state == :declaring
+
+        new_symbs = build_symbols(Dendroid::Syntax::Terminal, terminalSymbols)
+        symbols.merge!(new_symbs)
+      end
+
+      # Add a production rule in the grammar given one
+      # key-value pair of the form: String => String.
+      #   Where the key is the name of the non-terminal appearing in the
+      #   left side of the rule.
+      #   When the value is a String, it is a sequence of grammar symbol names separated by space.
+      #   When the value is an array of String, the elements represent an alternative rhs
+      # The rule is created and inserted in the grammar.
+      # @example
+      #   builder.rule('sentence' => 'noun_phrase verb_phrase')
+      #   builder.rule('noun_phrase' => ['noun', 'adj noun'])
+      # @param productionRuleRepr [Hash{String, String|Array<String>}]
+      #   A Hash-based representation of a production.
+      # @return [Dendroid::Syntax::Rule] The created Production or Choice instance
+      def rule(productionRuleRepr)
+        raise StandardError, 'Cannot add a production rule in state :complete' if state == :complete
+
+        @state = :building
+
+        return nil unless productionRuleRepr.is_a?(Hash)
+
+        head_name = productionRuleRepr.keys.first
+        if symbols.include? head_name
+          err_msg = "Terminal symbol '#{head_name}' may not be on left-side of a rule."
+          raise StandardError, err_msg if symbols[head_name].is_a?(Dendroid::Syntax::Terminal)
+        else
+          symbols.merge!(build_symbols(Dendroid::Syntax::NonTerminal, [head_name]))
+        end
+        lhs = symbols[head_name]
+        raw_rhs = productionRuleRepr.values.first
+
+        if raw_rhs.is_a? String
+          new_prod = Dendroid::Syntax::Production.new(lhs, build_symbol_seq(raw_rhs))
+        else
+          rhs = raw_rhs.map { |raw| build_symbol_seq(raw) }
+          new_prod = Dendroid::Syntax::Choice.new(lhs, rhs)
+        end
+        rules << new_prod
+        new_prod
+      end
+
+      # A method used to notify the builder that the grammar is complete
+      #   (i.e. all rules were entered).
+      def grammar_complete!
+        @state = :complete
+      end
+
+      # Generate the grammar according to the specifications.
+      # @return [Dendroid::Syntax::Grammar]
+      def grammar
+        terminals = symbols.values.select(&:terminal?)
+        grm = Dendroid::Syntax::Grammar.new(terminals)
+        rules.each { |prod| grm.add_rule(prod) }
+        grm.complete!
+        grm
+      end
+
+      private
+
+      def build_symbol_seq(raw_symbols)
+        symb_array = []
+        raw_stripped = raw_symbols.strip
+        return Dendroid::Syntax::SymbolSeq.new([]) if raw_stripped.empty?
+
+        symbol_names = raw_stripped.split(/(?: |\t)+/)
+        symbol_names.each do |symb_name|
+          unless symbols.include?(symb_name)
+            symbols.merge!(build_symbols(Dendroid::Syntax::NonTerminal, [symb_name]))
+          end
+          symb_array << symbols[symb_name]
+        end
+
+        Dendroid::Syntax::SymbolSeq.new(symb_array)
+      end
+
+      # Add the given grammar symbols.
+      # @param aClass [Class] The class of grammar symbols to instantiate.
+      # @param theSymbols [Array] array of elements are treated as follows:
+      #   if the element is already a grammar symbol, then it added as is,
+      #   otherwise it is considered as the name of a grammar symbol
+      # of the specified class to build.
+      def build_symbols(aClass, theSymbols)
+        symbs = {}
+        theSymbols.each do |s|
+          new_symbol = build_symbol(aClass, s)
+          symbs[new_symbol.name] = new_symbol
+          symbs[s] = new_symbol
+        end
+
+        symbs
+      end
+
+      # If the argument is already a grammar symbol object then it is
+      # returned as is. Otherwise, the argument is treated as a name
+      # for a new instance of the given class.
+      # @param aClass [Class] The class of grammar symbols to instantiate
+      # @param aSymbolArg [GrmSymbol-like or String]
+      # @return [Array] list of grammar symbols
+      def build_symbol(aClass, aSymbolArg)
+        if aSymbolArg.is_a?(Dendroid::Syntax::GrmSymbol)
+          aSymbolArg
+        else
+          aClass.new(aSymbolArg)
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/syntax/choice.rb

@@ -66,15 +66,26 @@ module Dendroid
       private
 
       def valid_alternatives(alt)
+        raise StandardError, "Expecting an Array, found a #{rhs.class} instead." unless alt.is_a?(Array)
+
         if alt.size < 2
           # A choice must have at least two alternatives
-          raise StandardError.new, "The choice for #{lhs} must have at least two alternatives."
+          raise StandardError, "The choice for `#{head}` must have at least two alternatives."
         end
 
-        cyclic = alt.find { |a| a.size == 1 && lhs == a.first }
-        if cyclic
-          # Forbid cyclic rules (e.g. A => A)
-          raise StandardError.new, "Cyclic rule of the kind #{lhs} => #{lhs} is not allowed."
+        # 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

data/lib/dendroid/syntax/grammar.rb

@@ -49,6 +49,7 @@ module Dendroid
         if nonterm2productions[rule.head]&.include? rule
           raise StandardError, "Production rule '#{production}' appears more than once in the grammar."
         end
+
         add_symbol(rule.head)
         rule.nonterminals.each { |nonterm| add_symbol(nonterm) }
         rules << rule
@@ -104,10 +105,10 @@ module Dendroid
       def at_least_one_terminal
         found = symbols.any?(&:terminal?)
 
-        unless found
-          err_msg = "Grammar doesn't contain any terminal symbol."
-          raise StandardError, err_msg
-        end
+        return true if found
+
+        err_msg = "Grammar doesn't contain any terminal symbol."
+        raise StandardError, err_msg
       end
 
       # Does every terminal symbol appear at least once
@@ -173,7 +174,6 @@ module Dendroid
           reachable_sym = backlog.pop
           prods = nonterm2productions[reachable_sym]
           prods.each do |prd|
-            # prd.body.members.each do |member|
             prd.rhs_symbols.each do |member|
               unless member.terminal? || set_reachable.include?(member)
                 backlog.push(member)
@@ -184,7 +184,7 @@ module Dendroid
         end until backlog.empty?
 
         all_symbols = Set.new(symbols)
-        unreachable = all_symbols - set_reachable
+        all_symbols - set_reachable
       end
 
       def mark_non_productive_symbols
@@ -194,7 +194,6 @@ module Dendroid
           backlog.delete(i) if prd.productive?
         end
         until backlog.empty?
-          size_before = backlog.size
           to_remove = []
           backlog.each do |i|
             prd = rules[i]
@@ -232,7 +231,7 @@ module Dendroid
           begin
             seqs_done = []
             backlog.each_pair do |sq, (elem_index, lhs)|
-              member = sq.members[elem_index]
+              member = sq[elem_index]
               if member.terminal?
                 seqs_done << sq # stop with this sequence: it is non-nullable
                 backlog[sq] = [-1, lhs]
@@ -247,14 +246,14 @@ module Dendroid
               end
             end
             seqs_done.each do |sq|
-              if backlog.include? sq
-                (_, lhs) = backlog[sq]
-                if lhs.nullable?
-                  to_drop = sym2seqs[lhs]
-                  to_drop.each { |seq| backlog.delete(seq) }
-                else
-                  backlog.delete(sq)
-                end
+              next unless backlog.include? sq
+
+              (_, lhs) = backlog[sq]
+              if lhs.nullable?
+                to_drop = sym2seqs[lhs]
+                to_drop.each { |seq| backlog.delete(seq) }
+              else
+                backlog.delete(sq)
               end
             end
           end until backlog.empty? || seqs_done.empty?

data/lib/dendroid/syntax/grm_symbol.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Dendroid
+  # The namespace for all classes used to build a grammar.
   module Syntax
     # Abstract class for grammar symbols.
     # A grammar symbol is an element that appears in grammar rules.
@@ -20,7 +21,7 @@ module Dendroid
         name.to_s
       end
 
-      # Equality testing (based on symbol name)
+      # Equality testing (based on symbol names)
       # @return [Boolean]
       def ==(other)
         name == other.name

data/lib/dendroid/syntax/production.rb

@@ -15,7 +15,7 @@ module Dendroid
       # @param rhs [Dendroid::Syntax::SymbolSeq] the sequence of symbols on rhs.
       def initialize(lhs, rhs)
         super(lhs)
-        @body = valid_body(rhs)
+        @body = valid_sequence(rhs)
       end
 
       # Predicate method to check whether the rule body (its rhs) is empty.
@@ -73,17 +73,6 @@ module Dendroid
 
       private
 
-      def valid_body(rhs)
-        raise StandardError unless rhs.is_a?(SymbolSeq)
-
-        if rhs.size == 1 && lhs == rhs.first
-          # Forbid cyclic rules (e.g. A => A)
-          raise StandardError.new, "Cyclic rule of the kind #{lhs} => #{lhs} is not allowed."
-        end
-
-        rhs
-      end
-
       def productive=(val)
         @productive = val
         lhs.productive = val

data/lib/dendroid/syntax/rule.rb

@@ -47,6 +47,19 @@ module Dendroid
         rhs_symbols.select(&:terminal?)
       end
 
+      protected
+
+      def valid_sequence(rhs)
+        raise StandardError, "Expecting a SymbolSeq, found a #{rhs.class} instead." unless rhs.is_a?(SymbolSeq)
+
+        if rhs.size == 1 && lhs == rhs.first
+          # Forbid cyclic rules (e.g. A => A)
+          raise StandardError.new, "Cyclic rules of the kind #{lhs} => #{lhs} are not allowed."
+        end
+
+        rhs
+      end
+
       private
 
       def valid_head(lhs)

data/lib/dendroid/syntax/symbol_seq.rb

@@ -13,7 +13,7 @@ module Dendroid
       # @return [Array<Dendroid::Syntax::GrmSymbol>] The sequence of symbols
       attr_reader :members
 
-      def_delegators(:@members, :empty?, :first, :map, :size)
+      def_delegators(:@members, :[], :empty?, :first, :map, :size)
 
       # Create a sequence of grammar symbols (as in right-hand side of
       # a production rule).

data/spec/dendroid/grm_analysis/dotted_item_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+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\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(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
+  let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_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) }
+
+  # Implements a dotted item: expression => NUMBER . PLUS NUMBER
+  subject { described_class.new(prod, 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
+    end
+
+    it 'knows its related production' do
+      expect(subject.rule).to eq(prod)
+    end
+
+    it 'knows its position' do
+      expect(subject.position).to eq(1)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'renders a String representation of itself' do
+      expect(subject.to_s).to eq('expression => NUMBER . PLUS 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)
+
+      # Case of an empty production
+      expect(described_class.new(empty_prod, 0).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
+
+      # Case of an empty production
+      expect(described_class.new(empty_prod, 0)).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
+
+      # Case of an empty production
+      expect(described_class.new(empty_prod, 0)).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
+
+      # Case of an empty production
+      expect(described_class.new(empty_prod, 0)).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
+
+      # Case of an empty production
+      expect(described_class.new(empty_prod, 0).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)
+    end
+  end # context
+end # describe

data/spec/dendroid/grm_dsl/base_grm_builder_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '..\..\spec_helper'
+require_relative '..\..\..\lib\dendroid\grm_dsl\base_grm_builder'
+
+describe Dendroid::GrmDSL::BaseGrmBuilder do
+  # Builds ingredients for a grammar inspired from https://en.wikipedia.org/wiki/Earley_parser
+  subject do
+    instance = described_class.new
+    instance.declare_terminals('PLUS', 'STAR', 'INTEGER')
+    instance
+  end
+
+  context 'Initialization:' do
+    it 'is initialized with an optional code block' do
+      expect { described_class.new }.not_to raise_error
+    end
+
+    it 'is in "declaring" state by default' do
+      expect(described_class.new.state).to eq(:declaring)
+    end
+
+    it 'has no grammar symbol by default' do
+      expect(described_class.new.symbols).to be_empty
+    end
+
+    it 'has no production rule by default' do
+      expect(described_class.new.rules).to be_empty
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'builds declared terminal symbols' do
+      instance = described_class.new
+      terminals = %w[PLUS STAR INTEGER]
+      instance.declare_terminals(*terminals)
+      expect(instance.symbols.size).to eq(2 * terminals.size)
+      expect(instance.symbols[:PLUS]).to be_kind_of(Dendroid::Syntax::Terminal)
+      expect(instance.symbols['PLUS']).to eq(instance.symbols[:PLUS])
+      expect(instance.symbols[:PLUS].name).to eq(:PLUS)
+      expect(instance.symbols[:STAR]).to be_kind_of(Dendroid::Syntax::Terminal)
+      expect(instance.symbols['STAR']).to eq(instance.symbols[:STAR])
+      expect(instance.symbols[:STAR].name).to eq(:STAR)
+      expect(instance.symbols[:INTEGER]).to be_kind_of(Dendroid::Syntax::Terminal)
+      expect(instance.symbols['INTEGER']).to eq(instance.symbols[:INTEGER])
+      expect(instance.symbols[:INTEGER].name).to eq(:INTEGER)
+      expect(instance.state).to eq(:declaring)
+    end
+
+    it 'builds production rules' do
+      subject.rule('p' => 's')
+      expect(subject.state).to eq(:building)
+
+      # Undeclared symbols in production represent non-terminals
+      expect(subject.symbols['p']).to be_kind_of(Dendroid::Syntax::NonTerminal)
+      expect(subject.symbols['s']).to be_kind_of(Dendroid::Syntax::NonTerminal)
+
+      expect(subject.rules.size).to eq(1)
+      expect(subject.rules.first.to_s).to eq('p => s')
+    end
+
+    it 'builds a grammar' do
+      subject.rule('p' => 's')
+      subject.rule('s' => ['s PLUS m', 'm'])
+      subject.rule('m' => ['m STAR t', 't'])
+      subject.rule('t' => 'INTEGER')
+      subject.grammar_complete!
+
+      grm = subject.grammar
+      expect(grm).to be_kind_of(Dendroid::Syntax::Grammar)
+      (terms, nonterms) = grm.symbols.partition(&:terminal?)
+      expect(terms.map(&:name)).to eq(%i[PLUS STAR INTEGER])
+      expect(nonterms.map(&:name)).to eq(%i[p s m t])
+      grammar_rules = [
+        'p => s',
+        's => s PLUS m | m',
+        'm => m STAR t | t',
+        't => INTEGER'
+      ]
+      expect(subject.rules.map(&:to_s)).to eq(grammar_rules)
+    end
+
+    it 'provides a simple DSL' do
+      instance = described_class.new do
+        declare_terminals('PLUS', 'STAR', 'INTEGER')
+        rule('p' => 's')
+        rule('s' => ['s PLUS m', 'm'])
+        rule('m' => ['m STAR t', 't'])
+        rule('t' => 'INTEGER')
+      end
+
+      grm = instance.grammar
+      expect(grm).to be_kind_of(Dendroid::Syntax::Grammar)
+      (terms, nonterms) = grm.symbols.partition(&:terminal?)
+      expect(terms.map(&:name)).to eq(%i[PLUS STAR INTEGER])
+      expect(nonterms.map(&:name)).to eq(%i[p s m t])
+      grammar_rules = [
+        'p => s',
+        's => s PLUS m | m',
+        'm => m STAR t | t',
+        't => INTEGER'
+      ]
+      expect(instance.rules.map(&:to_s)).to eq(grammar_rules)
+    end
+  end # context
+end # describe

data/spec/dendroid/syntax/choice_spec.rb

@@ -51,4 +51,18 @@ describe Dendroid::Syntax::Choice do
       expect(instance.nonterminals).to eq([expr_symb, foo_symb])
     end
   end # context
+
+  context 'Errors:' do
+    it 'fails when initialized with one alternative only' do
+      err = StandardError
+      err_msg = 'The choice for `expression` must have at least two alternatives.'
+      expect { described_class.new(expr_symb, [alt1]) }.to raise_error(err, err_msg)
+    end
+
+    it 'fails in presence of duplicate rhs' do
+      err = StandardError
+      err_msg = 'Duplicate alternatives: expression => NUMBER PLUS NUMBER'
+      expect { described_class.new(expr_symb, [alt1, alt2, alt1]) }.to raise_error(err, err_msg)
+    end
+  end # context
 end # describe

data/spec/dendroid/syntax/grammar_spec.rb

@@ -40,7 +40,6 @@ describe Dendroid::Syntax::Grammar do
     Dendroid::Syntax::Choice.new(lhs, sequences.map { |arr| build_symbol_seq(arr) })
   end
 
-  # rubocop: disable Metrics/AbcSize
   def build_all_rules
     rule1 = build_production(p_symb, [s_symb]) # p => s
     rule2 = build_choice(s_symb, [[s_symb, plus_symb, m_symb], [m_symb]]) # s => s + m | m
@@ -48,7 +47,6 @@ describe Dendroid::Syntax::Grammar do
     rule4 = build_production(t_symb, [int_symb]) # t => INTEGER
     [rule1, rule2, rule3, rule4]
   end
-  # rubocop: enable Metrics/AbcSize
 
   context 'Initialization:' do
     it 'is initialized with an array of terminal symbols' do

data/spec/dendroid/syntax/production_spec.rb

@@ -12,6 +12,7 @@ describe Dendroid::Syntax::Production do
   let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
   let(:foo_symb) { Dendroid::Syntax::NonTerminal.new('foo') }
   let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
+  let(:cyclic_rhs) { Dendroid::Syntax::SymbolSeq.new([foo_symb]) }
   let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
 
   # Implements a production rule: expression => NUMBER PLUS NUMBER
@@ -74,4 +75,18 @@ describe Dendroid::Syntax::Production do
     end
     # rubocop: enable Lint/BinaryOperatorWithIdenticalOperands
   end # context
+
+  context 'Errors:' do
+    it "fails when rhs isn't initialized with a SymbolSeq" do
+      err = StandardError
+      err_msg = 'Expecting a SymbolSeq, found a String instead.'
+      expect { described_class.new(foo_symb, 'bad') }.to raise_error err, err_msg
+    end
+
+    it 'fails when the production is cyclic' do
+      err = StandardError
+      err_msg = 'Cyclic rules of the kind foo => foo are not allowed.'
+      expect { described_class.new(foo_symb, cyclic_rhs) }.to raise_error err, err_msg
+    end
+  end # context
 end # describe

data/spec/dendroid/syntax/rule_spec.rb

@@ -20,4 +20,11 @@ describe Dendroid::Syntax::Rule do
       expect(subject.head).to eq(expr_symb)
     end
   end # context
+
+  context 'Errors:' do
+    it 'fails when initialized with a terminal' do
+      msg = "Terminal symbol 'NUMBER' may not be on left-side of a rule."
+      expect { described_class.new(num_symb) }.to raise_error(StandardError, msg)
+    end
+  end
 end # describe

data/version.txt

@@ -1 +1 @@
-0.0.6
+0.0.8

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Dimitri Geshef
@@ -24,6 +24,8 @@ files:
 - bin/dendroid
 - dendroid.gemspec
 - lib/dendroid.rb
+- lib/dendroid/grm_analysis/dotted_item.rb
+- lib/dendroid/grm_dsl/base_grm_builder.rb
 - lib/dendroid/syntax/choice.rb
 - lib/dendroid/syntax/grammar.rb
 - lib/dendroid/syntax/grm_symbol.rb
@@ -32,6 +34,8 @@ files:
 - lib/dendroid/syntax/rule.rb
 - lib/dendroid/syntax/symbol_seq.rb
 - lib/dendroid/syntax/terminal.rb
+- spec/dendroid/grm_analysis/dotted_item_spec.rb
+- spec/dendroid/grm_dsl/base_grm_builder_spec.rb
 - spec/dendroid/syntax/choice_spec.rb
 - spec/dendroid/syntax/grammar_spec.rb
 - spec/dendroid/syntax/grm_symbol_spec.rb