sequitur 0.1.23 → 0.1.24

data/lib/sequitur/sequitur_grammar.rb

@@ -2,155 +2,153 @@
 
 require_relative 'dynamic_grammar'
 
-
 module Sequitur # Module for classes implementing the Sequitur algorithm
-# Specialization of the DynamicGrammar class.
-# A Sequitur grammar is a context-free grammar that is entirely built
-# from a sequence of input tokens through the Sequitur algorithm.
-class SequiturGrammar < DynamicGrammar
-  # Build the grammar from an enumerator of tokens.
-  # @param anEnum [Enumerator] an enumerator that will iterate
-  #   over the input tokens.
-  def initialize(anEnum)
-    super()
-    # Make start production compliant with utility rule
-    2.times { start.incr_refcount }
-
-    # Read the input sequence and apply the Sequitur algorithm
-    anEnum.each do |a_token|
-      add_token(a_token)
-      enforce_rules
+  # Specialization of the DynamicGrammar class.
+  # A Sequitur grammar is a context-free grammar that is entirely built
+  # from a sequence of input tokens through the Sequitur algorithm.
+  class SequiturGrammar < DynamicGrammar
+    # Build the grammar from an enumerator of tokens.
+    # @param anEnum [Enumerator] an enumerator that will iterate
+    #   over the input tokens.
+    def initialize(anEnum)
+      super()
+      # Make start production compliant with utility rule
+      2.times { start.incr_refcount }
+
+      # Read the input sequence and apply the Sequitur algorithm
+      anEnum.each do |a_token|
+        add_token(a_token)
+        enforce_rules
+      end
     end
-  end
-
-  private
-
-  # Struct used for internal purposes
-  CollisionDiagnosis = Struct.new(
-    :collision_found, # true if collision detected
-    :digram, # The digram involved in a collision
-    :productions) # The productions where the digram occurs
-
-
-
-  # Assuming that a new input token was added to the start production,
-  # enforce the digram unicity and rule utility rules
-  # begin
-  #   if a digram D occurs twice in the grammar then
-  #     add a production P : D (if not already there)
-  #     replace both Ds with R (reduction step).
-  #   end
-  #   if a production P : RHS in referenced only once then
-  #     replace P by its RHS (derivation step)
-  #     remove P from grammar
-  #   end
-  #  end until digram unicity and rule utility are met
-  def enforce_rules
-    loop do
-      unicity_diagnosis = detect_collision if unicity_diagnosis.nil?
-      restore_unicity(unicity_diagnosis) if unicity_diagnosis.collision_found
-
-      prod_index = detect_useless_production
-      restore_utility(prod_index) unless prod_index.nil?
-
-      unicity_diagnosis = detect_collision
-      prod_index = detect_useless_production
-      break unless unicity_diagnosis.collision_found || !prod_index.nil?
+
+    private
+
+    # Struct used for internal purposes
+    CollisionDiagnosis = Struct.new(
+      :collision_found, # true if collision detected
+      :digram, # The digram involved in a collision
+      :productions # The productions where the digram occurs
+    )
+
+    # Assuming that a new input token was added to the start production,
+    # enforce the digram unicity and rule utility rules
+    # begin
+    #   if a digram D occurs twice in the grammar then
+    #     add a production P : D (if not already there)
+    #     replace both Ds with R (reduction step).
+    #   end
+    #   if a production P : RHS in referenced only once then
+    #     replace P by its RHS (derivation step)
+    #     remove P from grammar
+    #   end
+    #  end until digram unicity and rule utility are met
+    def enforce_rules
+      loop do
+        unicity_diagnosis = detect_collision if unicity_diagnosis.nil?
+        restore_unicity(unicity_diagnosis) if unicity_diagnosis.collision_found
+
+        prod_index = detect_useless_production
+        restore_utility(prod_index) unless prod_index.nil?
+
+        unicity_diagnosis = detect_collision
+        prod_index = detect_useless_production
+        break unless unicity_diagnosis.collision_found || !prod_index.nil?
+      end
     end
-  end
-
-  # Check whether a digram is used twice in the grammar.
-  # Return an empty Hash if each digram appears once.
-  # Otherwise return a Hash with a pair of the form: digram => [Pi, Pk]
-  # Where Pi, Pk are two productions where the digram occurs.
-  def detect_collision
-    diagnosis = CollisionDiagnosis.new(false)
-    found_so_far = {}
-    productions.each do |a_prod|
-      prod_digrams = a_prod.digrams
-      prod_digrams.each do |a_digr|
-        its_key = a_digr.key
-        if found_so_far.include? its_key
-          orig_digr = found_so_far[its_key]
-          # Disregard sequence like a a a
-          if (orig_digr.production == a_prod) && a_digr.repeating? &&
-             (orig_digr == a_digr)
-            next
-          end
 
-          diagnosis.digram = orig_digr
-          diagnosis.productions = [orig_digr.production, a_prod]
-          diagnosis.collision_found = true
-          break
-        else
-          found_so_far[its_key] = a_digr
+    # Check whether a digram is used twice in the grammar.
+    # Return an empty Hash if each digram appears once.
+    # Otherwise return a Hash with a pair of the form: digram => [Pi, Pk]
+    # Where Pi, Pk are two productions where the digram occurs.
+    def detect_collision
+      diagnosis = CollisionDiagnosis.new(false)
+      found_so_far = {}
+      productions.each do |a_prod|
+        prod_digrams = a_prod.digrams
+        prod_digrams.each do |a_digr|
+          its_key = a_digr.key
+          if found_so_far.include? its_key
+            orig_digr = found_so_far[its_key]
+            # Disregard sequence like a a a
+            if (orig_digr.production == a_prod) && a_digr.repeating? &&
+               (orig_digr == a_digr)
+              next
+            end
+
+            diagnosis.digram = orig_digr
+            diagnosis.productions = [orig_digr.production, a_prod]
+            diagnosis.collision_found = true
+            break
+          else
+            found_so_far[its_key] = a_digr
+          end
         end
+        break if diagnosis.collision_found
       end
-      break if diagnosis.collision_found
+
+      diagnosis
     end
 
-    return diagnosis
-  end
-
-  # When a collision diagnosis indicates that a given
-  # digram d occurs twice in the grammar
-  # Then create a new production that will have
-  # the symbols of d as its rhs members.
-  def restore_unicity(aDiagnosis)
-    prods = aDiagnosis.productions
-    if prods.any?(&:single_digram?)
-      (simple, compound) = prods.partition(&:single_digram?)
-      compound[0].reduce_step(simple[0])
-    else
-      # Create a new production with the digram's symbols as its
-      # sole rhs members.
-      new_prod = build_production_for(aDiagnosis.digram)
-      prods[0].reduce_step(new_prod)
-      prods[1].reduce_step(new_prod) unless prods[1] == prods[0]
+    # When a collision diagnosis indicates that a given
+    # digram d occurs twice in the grammar
+    # Then create a new production that will have
+    # the symbols of d as its rhs members.
+    def restore_unicity(aDiagnosis)
+      prods = aDiagnosis.productions
+      if prods.any?(&:single_digram?)
+        (simple, compound) = prods.partition(&:single_digram?)
+        compound[0].reduce_step(simple[0])
+      else
+        # Create a new production with the digram's symbols as its
+        # sole rhs members.
+        new_prod = build_production_for(aDiagnosis.digram)
+        prods[0].reduce_step(new_prod)
+        prods[1].reduce_step(new_prod) unless prods[1] == prods[0]
+      end
     end
-  end
-
-  # Return a production that is used less than twice in the grammar.
-  def detect_useless_production
-    useless = productions.index { |prod| prod.refcount < 2 }
-    useless = nil if useless&.zero?
-
-    return useless
-  end
-
-  # Given the passed production P is referenced only once.
-  # Then replace P by its RHS where it is referenced.
-  # And delete P
-  def restore_utility(prod_index)
-    # Retrieve useless prod from its index
-    useless_prod = productions[prod_index]
-
-    # Retrieve production referencing useless one
-    referencing = nil
-    productions.reverse_each do |a_prod|
-      # Next line assumes non-recursive productions
-      next if a_prod == useless_prod
-
-      refs = a_prod.references_of(useless_prod)
-      next if refs.empty?
-
-      referencing = a_prod
-      break
+
+    # Return a production that is used less than twice in the grammar.
+    def detect_useless_production
+      useless = productions.index { |prod| prod.refcount < 2 }
+      useless = nil if useless&.zero?
+
+      useless
     end
 
-    referencing.derive_step(useless_prod)
-    remove_production(prod_index)
-  end
+    # Given the passed production P is referenced only once.
+    # Then replace P by its RHS where it is referenced.
+    # And delete P
+    def restore_utility(prod_index)
+      # Retrieve useless prod from its index
+      useless_prod = productions[prod_index]
+
+      # Retrieve production referencing useless one
+      referencing = nil
+      productions.reverse_each do |a_prod|
+        # Next line assumes non-recursive productions
+        next if a_prod == useless_prod
+
+        refs = a_prod.references_of(useless_prod)
+        next if refs.empty?
+
+        referencing = a_prod
+        break
+      end
+
+      referencing.derive_step(useless_prod)
+      remove_production(prod_index)
+    end
 
-  # Create a new production that will have the symbols from digram
-  # as its rhs members.
-  def build_production_for(aDigram)
-    new_prod = Production.new
-    aDigram.symbols.each { |sym| new_prod.append_symbol(sym) }
-    add_production(new_prod)
+    # Create a new production that will have the symbols from digram
+    # as its rhs members.
+    def build_production_for(aDigram)
+      new_prod = Production.new
+      aDigram.symbols.each { |sym| new_prod.append_symbol(sym) }
+      add_production(new_prod)
 
-    return new_prod
-  end
-end # class
+      new_prod
+    end
+  end # class
 end # module
 # End of file

data/lib/sequitur/symbol_sequence.rb

@@ -31,15 +31,15 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
     end
 
     # Tell whether the sequence is empty.
-    # @return [true / false] true only if the sequence has no symbol in it.
+    # @[true / false] true only if the sequence has no symbol in it.
     def empty?
-      return symbols.empty?
+      symbols.empty?
     end
 
     # Count the number of elements in the sequence.
-    #  @return [Fixnum] the number of elements
+    #  @[Fixnum] the number of elements
     def size
-      return symbols.size
+      symbols.size
     end
 
     # Append a grammar symbol at the end of the sequence.
@@ -55,58 +55,55 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
     # Retrieve the element from the sequence at given position.
     # @param anIndex [Fixnum] A zero-based index of the element to access.
     def [](anIndex)
-      return symbols[anIndex]
+      symbols[anIndex]
     end
 
     # Equality testing.
     # @param other [SymbolSequence or Array] the other other sequence
     #   to compare to.
-    # @return true when an item from self equals the corresponding
+    # @true when an item from self equals the corresponding
     #   item from 'other'
     def ==(other)
-      return true if object_id == other.object_id
+      true if object_id == other.object_id
 
-      same = case other
-               when SymbolSequence
-                 symbols == other.symbols
-               when Array
-                 symbols == other
-               else
-                 false
-             end
-
-      return same
+      case other
+      when SymbolSequence
+        symbols == other.symbols
+      when Array
+        symbols == other
+      else
+        false
+      end
     end
 
     # Select the references to production appearing in the rhs.
-    # @return [Array of ProductionRef]
+    # @[Array of ProductionRef]
     def references
       @memo_references ||= symbols.select { |symb| symb.is_a?(ProductionRef) }
-      return @memo_references
+      @memo_references
     end
 
     # Select the references of the given production appearing in the rhs.
     # @param aProduction [Production]
-    # @return [Array of ProductionRef]
+    # @[Array of ProductionRef]
     def references_of(aProduction)
-      return [] if references.empty?
+      [] if references.empty?
 
-      result = references.select { |a_ref| a_ref == aProduction }
-      return result
+      references.select { |a_ref| a_ref == aProduction }
     end
 
     # Emit a text representation of the symbol sequence.
     # Text is of the form: space-separated sequence of symbols.
-    # @return [String]
+    # @[String]
     def to_string
       rhs_text = symbols.map do |elem|
         case elem
-          when String then "'#{elem}'"
-          else elem.to_s
+        when String then "'#{elem}'"
+        else elem.to_s
         end
       end
 
-      return rhs_text.join(' ')
+      rhs_text.join(' ')
     end
 
     # Insert at position the elements from another sequence.

data/lib/sequitur.rb

@@ -9,7 +9,6 @@ require_relative './sequitur/sequitur_grammar'
 require_relative './sequitur/formatter/debug'
 require_relative './sequitur/formatter/base_text'
 
-
 module Sequitur
   # Build a Sequitur-generated grammar based on the sequence of input tokens.
   #
@@ -19,12 +18,12 @@ module Sequitur
   # @return [SequiturGrammar] a grammar that encodes the input.
   def self.build_from(tokens)
     input_sequence = case tokens
-                       when String then tokens.chars
-                       when Enumerator then tokens
-                       else tokens.to_enum
+                     when String then tokens.chars
+                     when Enumerator then tokens
+                     else tokens.to_enum
                      end
 
-    return SequiturGrammar.new(input_sequence)
+    SequiturGrammar.new(input_sequence)
   end
 end # module
 

data/spec/sequitur/digram_spec.rb

@@ -5,38 +5,40 @@ require_relative '../spec_helper'
 # Load the class under test
 require_relative '../../lib/sequitur/digram'
 
-module Sequitur # Re-open the module to get rid of qualified names
-describe Digram do
+describe Sequitur::Digram do
   let(:two_symbols) { %i[b c] }
   let(:production) { double('sample-production') }
+  def make_digram(symb1, symb2, production)
+    Sequitur::Digram.new(symb1, symb2, production)
+  end
 
   context 'Standard creation & initialization:' do
     it 'should be created with 3 arguments' do
-      instance = Digram.new(:b, :c, production)
+      instance = make_digram(:b, :c, production)
 
       expect(instance.symbols).to eq(two_symbols)
       expect(instance.production).to eq(production)
     end
 
     it 'should return the production that it refers to' do
-      instance = Digram.new(:b, :c, production)
+      instance = make_digram(:b, :c, production)
       expect(instance.production).to eq(production)
     end
 
     it 'should whether its symbols are the same' do
-       instance1 = Digram.new(:a, :a, production)
-       expect(instance1).to be_repeating
+      instance1 = make_digram(:a, :a, production)
+      expect(instance1).to be_repeating
 
-       instance1 = Digram.new(:a, :b, production)
-       expect(instance1).not_to be_repeating
+      instance1 = make_digram(:a, :b, production)
+      expect(instance1).not_to be_repeating
     end
   end # context
 
   context 'Provided services:' do
     it 'should compare itself to another digram' do
-      instance1 = Digram.new(:a, :b, production)
-      same = Digram.new(:a, :b, production)
-      different = Digram.new(:b, :c, production)
+      instance1 = make_digram(:a, :b, production)
+      same = make_digram(:a, :b, production)
+      different = make_digram(:b, :c, production)
 
       expect(instance1).to eq(instance1)
       expect(instance1).to eq(same)
@@ -45,6 +47,5 @@ describe Digram do
     end
   end # context
 end # describe
-end # module
 
 # End of file

data/spec/sequitur/dynamic_grammar_spec.rb

@@ -5,14 +5,13 @@ require_relative '../spec_helper'
 # Load the class under test
 require_relative '../../lib/sequitur/dynamic_grammar'
 
-module Sequitur # Re-open the module to get rid of qualified names
-describe DynamicGrammar do
+describe Sequitur::DynamicGrammar do
   # Factory method. Build a production with the given sequence
   # of symbols as its rhs.
   def build_production(*symbols)
-    prod = Production.new
+    prod = Sequitur::Production.new
     symbols.each { |symb| prod.append_symbol(symb) }
-    return prod
+    prod
   end
 
   let(:p_a) { build_production(:a) }
@@ -20,10 +19,9 @@ describe DynamicGrammar do
   let(:p_c) { build_production(:c) }
   let(:p_bc) { build_production(p_b, p_c) }
 
-
   context 'Creation & initialization:' do
     it 'should be created without parameter' do
-      expect { DynamicGrammar.new }.not_to raise_error
+      expect { Sequitur::DynamicGrammar.new }.not_to raise_error
     end
 
     it 'should have an empty start/start production' do
@@ -33,7 +31,6 @@ describe DynamicGrammar do
     end
   end # context
 
-
   context 'Adding productions to the grammar:' do
     it 'should add a simple production' do
       subject.add_production(p_a)
@@ -60,7 +57,6 @@ describe DynamicGrammar do
     end
   end # context
 
-
   context 'Removing a production from the grammar:' do
     it 'should remove an existing production' do
       subject.add_production(p_a) # index = 1
@@ -91,7 +87,7 @@ describe DynamicGrammar do
   context 'Visiting:' do
     it 'should return a visitor' do
       expect { subject.visitor }.not_to raise_error
-      expect(subject.visitor).to be_kind_of(GrammarVisitor)
+      expect(subject.visitor).to be_kind_of(Sequitur::GrammarVisitor)
     end
 
     it 'should accept a visitor' do
@@ -133,7 +129,6 @@ describe DynamicGrammar do
     end
   end # context
 
-
   context 'Generating a text representation of itself:' do
     it 'should generate a text representation when empty' do
       expectation = "#{subject.start.object_id} : ."
@@ -141,6 +136,5 @@ describe DynamicGrammar do
     end
   end # context
 end # describe
-end # module
 
 # End of file