sequitur 0.1.18 → 0.1.23

data/lib/sequitur/dynamic_grammar.rb

@@ -1,101 +1,99 @@
+# frozen_string_literal: true
+
 require_relative 'production'
 require_relative 'grammar_visitor'
 
 module Sequitur # Module for classes implementing the Sequitur algorithm
-# A dynamic grammar is a context-free grammar that can be built incrementally.
-#   Formally, a grammar has:
-#   One start production
-#   Zero or more other productions
-#   Each production has a rhs that is a sequence of grammar symbols.
-#   Grammar symbols are categorized into
-#   -terminal symbols (i.e. String, Ruby Symbol,...)
-#   -non-terminal symbols (i.e. ProductionRef)
-class DynamicGrammar
-  # Link to the start production.
-  attr_reader(:start)
-
-  # The set of production rules of the grammar
-  attr_reader(:productions)
-
-  # nodoc Trace the execution of the algorithm.
-  attr(:trace)
-
-
-  # Constructor.
-  # Build a grammar with one empty rule as start/start rule.
-  def initialize()
-    @start = Production.new
-    @productions = [ start ]
-    @trace = false
-  end
-
-  # Emit a text representation of the grammar.
-  # Each production rule is emitted per line.
-  # @return [String]
-  def to_string()
-    rule_text = productions.map(&:to_string).join("\n")
-    return rule_text
-  end
-
-
-  # Add a given production to the grammar.
-  # @param aProduction [Production]
-  def add_production(aProduction)
-    # TODO: remove output
-    puts "Adding #{aProduction.object_id}" if trace
-    puts aProduction.to_string if trace
-    productions << aProduction
-  end
-
-
-  # Remove a production with given index from the grammar
-  # @param anIndex [Fixnum]
-  # @return [Production] the production removed from the grammar.
-  def remove_production(anIndex)
-    puts "Before production removal #{productions[anIndex].object_id}" if trace
-    puts to_string if trace
-    prod = productions.delete_at(anIndex)
-    # TODO: remove output
-    puts('Removed: ' + prod.to_string) if trace
-    prod.clear_rhs
-
-    return prod
-  end
-
-
-  # Add the given token to the grammar.
-  #   Append the token to the rhs of the start/start rule.
-  # @param aToken [Object] input token to add
-  def add_token(aToken)
-    append_symbol_to(start, aToken)
-  end
-
-  # Part of the 'visitee' role in the Visitor design pattern.
-  #   A visitee is expected to accept the visit from a visitor object
-  # @param aVisitor [GrammarVisitor] the visitor object
-  def accept(aVisitor)
-    aVisitor.start_visit_grammar(self)
-
-    # Let's proceed with the visit of productions
-    productions.each { |prod| prod.accept(aVisitor) }
-
-    aVisitor.end_visit_grammar(self)
-  end
-
-  # Factory method. Returns a visitor for this grammar.
-  # @return [GrammarVisitor]
-  def visitor()
-    return GrammarVisitor.new(self)
-  end
-
-  protected
-
-  # Append a given symbol to the rhs of passed production.
-  # @param aProduction [Production]
-  # @param aSymbol [Object]
-  def append_symbol_to(aProduction, aSymbol)
-    aProduction.append_symbol(aSymbol)
-  end
-end # class
+  # A dynamic grammar is a context-free grammar that can be built incrementally.
+  #   Formally, a grammar has:
+  #   One start production
+  #   Zero or more other productions
+  #   Each production has a rhs that is a sequence of grammar symbols.
+  #   Grammar symbols are categorized into
+  #   -terminal symbols (i.e. String, Ruby Symbol,...)
+  #   -non-terminal symbols (i.e. ProductionRef)
+  class DynamicGrammar
+    # Link to the start production.
+    attr_reader(:start)
+
+    # The set of production rules of the grammar
+    attr_reader(:productions)
+
+    # nodoc Trace the execution of the algorithm.
+    attr_accessor(:trace)
+
+    # Constructor.
+    # Build a grammar with one empty rule as start/start rule.
+    def initialize
+      @start = Production.new
+      @productions = [start]
+      @trace = false
+    end
+
+    # Emit a text representation of the grammar.
+    # Each production rule is emitted per line.
+    # @return [String]
+    def to_string
+      rule_text = productions.map(&:to_string).join("\n")
+      return rule_text
+    end
+
+    # Add a given production to the grammar.
+    # @param aProduction [Production]
+    def add_production(aProduction)
+      # TODO: remove output
+      puts "Adding #{aProduction.object_id}" if trace
+      puts aProduction.to_string if trace
+      productions << aProduction
+    end
+
+    # Remove a production with given index from the grammar
+    # @param anIndex [Fixnum]
+    # @return [Production] the production removed from the grammar.
+    def remove_production(anIndex)
+      puts "Before production removal #{productions[anIndex].object_id}" if trace
+      puts to_string if trace
+      prod = productions.delete_at(anIndex)
+      # TODO: remove output
+      puts("Removed: #{prod.to_string}") if trace
+      prod.clear_rhs
+
+      return prod
+    end
+
+    # Add the given token to the grammar.
+    #   Append the token to the rhs of the start/start rule.
+    # @param aToken [Object] input token to add
+    def add_token(aToken)
+      append_symbol_to(start, aToken)
+    end
+
+    # Part of the 'visitee' role in the Visitor design pattern.
+    #   A visitee is expected to accept the visit from a visitor object
+    # @param aVisitor [GrammarVisitor] the visitor object
+    def accept(aVisitor)
+      aVisitor.start_visit_grammar(self)
+
+      # Let's proceed with the visit of productions
+      productions.each { |prod| prod.accept(aVisitor) }
+
+      aVisitor.end_visit_grammar(self)
+    end
+
+    # Factory method. Returns a visitor for this grammar.
+    # @return [GrammarVisitor]
+    def visitor
+      return GrammarVisitor.new(self)
+    end
+
+    protected
+
+    # Append a given symbol to the rhs of passed production.
+    # @param aProduction [Production]
+    # @param aSymbol [Object]
+    def append_symbol_to(aProduction, aSymbol)
+      aProduction.append_symbol(aSymbol)
+    end
+  end # class
 end # module
 # End of file

data/lib/sequitur/formatter/base_formatter.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Sequitur
   # Namespace dedicated to grammar formatters.
   module Formatter
     # Superclass for grammar formatters.
     class BaseFormatter
       # The IO output stream in which the formatter's result will be sent.
-      attr(:output)
+      attr_accessor(:output)
 
       # Constructor.
       # @param anIO [IO] an output IO where the formatter's result will

data/lib/sequitur/formatter/base_text.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base_formatter'
 
 module Sequitur
@@ -72,7 +74,7 @@ module Sequitur
       private
 
       # Read accessor of the production lookup
-      def prod_lookup()
+      def prod_lookup
         return @prod_lookup
       end
 

data/lib/sequitur/formatter/debug.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base_formatter'
 
 
@@ -13,7 +15,7 @@ module Sequitur
     #   formatter.run(some_grammar.visitor)
     class Debug < BaseFormatter
       # Current indentation level
-      attr(:indentation)
+      attr_accessor(:indentation)
 
       # Constructor.
       # @param anIO [IO] The output stream to which the rendered grammar
@@ -109,11 +111,11 @@ module Sequitur
 
       private
 
-      def indent()
+      def indent
         @indentation += 1
       end
 
-      def dedent()
+      def dedent
         @indentation -= 1
       end
 

data/lib/sequitur/grammar_visitor.rb

@@ -1,104 +1,105 @@
+# frozen_string_literal: true
+
 module Sequitur # Module for classes implementing the Sequitur algorithm
 # A visitor class dedicated in the visit of Grammar.
-class GrammarVisitor
-  # Link to the grammar to visit
-  attr_reader(:grammar)
-
-  # List of objects that subscribed to the visit event notification.
-  attr_reader(:subscribers)
-
-  # Build a visitor for the given grammar.
-  # @param aGrammar [DynamicGrammar-like] the grammar to visit.
-  def initialize(aGrammar)
-    @grammar = aGrammar
-    @subscribers = []
-  end
-
-  # Add a subscriber for the visit event notification.
-  # @param aSubscriber [Object]
-  def subscribe(aSubscriber)
-    subscribers << aSubscriber
-  end
-
-  # Remove the given object from the subscription list.
-  # The object won't be notified of visit events.
-  # @param aSubscriber [Object]
-  def unsubscribe(aSubscriber)
-    subscribers.delete_if { |entry| entry == aSubscriber }
-  end
-
-  # The signal to start the visit.
-  def start()
-    grammar.accept(self)
-  end
-
-
-  # Visit event. The visitor is about to visit the grammar.
-  # @param aGrammar [DynamicGrammar-like] the grammar to visit.
-  def start_visit_grammar(aGrammar)
-    broadcast(:before_grammar, aGrammar)
-  end
-
-
-  # Visit event. The visitor is about to visit the given production.
-  # @param aProduction [Production] the production to visit.
-  def start_visit_production(aProduction)
-    broadcast(:before_production, aProduction)
-  end
-
-  # Visit event. The visitor is about to visit the given rhs of production.
-  # @param rhs [SymbolSequence] the rhs of a production to visit.
-  def start_visit_rhs(rhs)
-    broadcast(:before_rhs, rhs)
-  end
-
-  # Visit event. The visitor is visiting the
-  # given reference production (= non-terminal symbol).
-  # @param aProdRef [ProductionRef] the production reference to visit.
-  def visit_prod_ref(aProdRef)
-    production = aProdRef.production
-    broadcast(:before_non_terminal, production)
-    broadcast(:after_non_terminal, production)
-  end
-
-  # Visit event. The visitor is visiting the
-  # given terminal symbol.
-  # @param aTerminal [Object] the terminal to visit.
-  def visit_terminal(aTerminal)
-    broadcast(:before_terminal, aTerminal)
-    broadcast(:after_terminal, aTerminal)
-  end
-
-  # Visit event. The visitor has completed its visit of the given rhs.
-  # @param rhs [SymbolSequence] the rhs of a production to visit.
-  def end_visit_rhs(rhs)
-    broadcast(:after_rhs, rhs)
-  end
-
-  # Visit event. The visitor has completed its visit of the given production.
-  # @param aProduction [Production] the production to visit.
-  def end_visit_production(aProduction)
-    broadcast(:after_production, aProduction)
-  end
-
-  # Visit event. The visitor has completed the visit of the grammar.
-  # @param aGrammar [DynamicGrammar-like] the grammar to visit.
-  def end_visit_grammar(aGrammar)
-    broadcast(:after_grammar, aGrammar)
-  end
-
-  private
-
-  # Send a notification to all subscribers.
-  # @param msg [Symbol] event to notify
-  # @param args [Array] arguments of the notification.
-  def broadcast(msg, *args)
-    subscribers.each do |a_subscriber|
-      next unless a_subscriber.respond_to?(msg)
-      a_subscriber.send(msg, *args)
+  class GrammarVisitor
+    # Link to the grammar to visit
+    attr_reader(:grammar)
+
+    # List of objects that subscribed to the visit event notification.
+    attr_reader(:subscribers)
+
+    # Build a visitor for the given grammar.
+    # @param aGrammar [DynamicGrammar-like] the grammar to visit.
+    def initialize(aGrammar)
+      @grammar = aGrammar
+      @subscribers = []
+    end
+
+    # Add a subscriber for the visit event notification.
+    # @param aSubscriber [Object]
+    def subscribe(aSubscriber)
+      subscribers << aSubscriber
+    end
+
+    # Remove the given object from the subscription list.
+    # The object won't be notified of visit events.
+    # @param aSubscriber [Object]
+    def unsubscribe(aSubscriber)
+      subscribers.delete_if { |entry| entry == aSubscriber }
+    end
+
+    # The signal to start the visit.
+    def start
+      grammar.accept(self)
+    end
+
+    # Visit event. The visitor is about to visit the grammar.
+    # @param aGrammar [DynamicGrammar-like] the grammar to visit.
+    def start_visit_grammar(aGrammar)
+      broadcast(:before_grammar, aGrammar)
+    end
+
+    # Visit event. The visitor is about to visit the given production.
+    # @param aProduction [Production] the production to visit.
+    def start_visit_production(aProduction)
+      broadcast(:before_production, aProduction)
+    end
+
+    # Visit event. The visitor is about to visit the given rhs of production.
+    # @param rhs [SymbolSequence] the rhs of a production to visit.
+    def start_visit_rhs(rhs)
+      broadcast(:before_rhs, rhs)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given reference production (= non-terminal symbol).
+    # @param aProdRef [ProductionRef] the production reference to visit.
+    def visit_prod_ref(aProdRef)
+      production = aProdRef.production
+      broadcast(:before_non_terminal, production)
+      broadcast(:after_non_terminal, production)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given terminal symbol.
+    # @param aTerminal [Object] the terminal to visit.
+    def visit_terminal(aTerminal)
+      broadcast(:before_terminal, aTerminal)
+      broadcast(:after_terminal, aTerminal)
+    end
+
+    # Visit event. The visitor has completed its visit of the given rhs.
+    # @param rhs [SymbolSequence] the rhs of a production to visit.
+    def end_visit_rhs(rhs)
+      broadcast(:after_rhs, rhs)
+    end
+
+    # Visit event. The visitor has completed its visit of the given production.
+    # @param aProduction [Production] the production to visit.
+    def end_visit_production(aProduction)
+      broadcast(:after_production, aProduction)
+    end
+
+    # Visit event. The visitor has completed the visit of the grammar.
+    # @param aGrammar [DynamicGrammar-like] the grammar to visit.
+    def end_visit_grammar(aGrammar)
+      broadcast(:after_grammar, aGrammar)
+    end
+
+    private
+
+    # Send a notification to all subscribers.
+    # @param msg [Symbol] event to notify
+    # @param args [Array] arguments of the notification.
+    def broadcast(msg, *args)
+      subscribers.each do |a_subscriber|
+        next unless a_subscriber.respond_to?(msg)
+
+        a_subscriber.send(msg, *args)
+      end
     end
-  end
-end # class
+  end # class
 end # module
 
 # End of file