sequitur 0.1.18 → 0.1.19

data/lib/sequitur/production.rb

@@ -23,7 +23,7 @@ class Production
 
   # Constructor.
   # Build a production with an empty RHS.
-  def initialize()
+  def initialize
     @rhs = SymbolSequence.new
     @refcount = 0
     @digrams = []
@@ -44,7 +44,6 @@ class Production
     return result
   end
 
-
   # Is the rhs empty?
   # @ return true if the rhs has no members.
   def empty?
@@ -52,20 +51,19 @@ class Production
   end
 
   # Increment the reference count by one.
-  def incr_refcount()
+  def incr_refcount
     @refcount += 1
   end
 
   # Decrement the reference count by one.
-  def decr_refcount()
+  def decr_refcount
     raise StandardError, 'Internal error' if @refcount.zero?
     @refcount -= 1
   end
 
-
   # Select the references to production appearing in the rhs.
   # @return [Array of ProductionRef]
-  def references()
+  def references
     return rhs.references
   end
 
@@ -77,10 +75,9 @@ class Production
     return rhs.references_of(real_prod)
   end
 
-
   # Enumerate the digrams appearing in the right-hand side (rhs)
   # @return [Array] the list of digrams found in rhs of this production.
-  def recalc_digrams()
+  def recalc_digrams
     return [] if rhs.size < 2
 
     result = []
@@ -88,20 +85,17 @@ class Production
     @digrams = result
   end
 
-
-
   # Does the rhs have exactly one digram only (= 2 symbols)?
   # @return [true/false] true when the rhs contains exactly two symbols.
   def single_digram?
     return rhs.size == 2
   end
 
-
   # Detect whether the last digram occurs twice
   # Assumption: when a digram occurs twice in a production then it must occur
   # at the end of the rhs
   # @return [true/false] true when the digram occurs twice in rhs.
-  def repeated_digram?()
+  def repeated_digram?
     return false if rhs.size < 3
 
     my_digrams = digrams
@@ -113,17 +107,16 @@ class Production
 
   # Retrieve the last digram appearing in the RHS (if any).
   # @return [Digram] last digram in the rhs otherwise nil.
-  def last_digram()
+  def last_digram
     result = digrams.empty? ? nil : digrams.last
     return result
   end
 
-
   # Emit a text representation of the production rule.
   # Text is of the form:
   # object id of production : rhs as space-separated sequence of symbols.
   # @return [String]
-  def to_string()
+  def to_string
     return "#{object_id} : #{rhs.to_string}."
   end
 
@@ -150,7 +143,7 @@ class Production
 
   # Clear the right-hand side.
   # Any referenced production has its reference counter decremented.
-  def clear_rhs()
+  def clear_rhs
     rhs.clear
   end
 
@@ -168,7 +161,7 @@ class Production
   #   p.positions_of(a, a) # => [0, 3]
   def positions_of(symb1, symb2)
     # Find the positions where the digram occur in rhs
-    indices = [ -2 ] # Dummy index!
+    indices = [-2] # Dummy index!
     (0...rhs.size).each do |i|
       next if i == indices.last + 1
       indices << i if (rhs[i] == symb1) && (rhs[i + 1] == symb2)
@@ -179,7 +172,6 @@ class Production
     return indices
   end
 
-
   # Given that the production P passed as argument has exactly 2 symbols
   #   in its rhs s1 s2, substitute in the rhs of self all occurrences of
   #   s1 s2 by a reference to P.
@@ -217,7 +209,6 @@ class Production
     recalc_digrams
   end
 
-
   # Part of the 'visitee' role in Visitor design pattern.
   # @param aVisitor[GrammarVisitor]
   def accept(aVisitor)

data/lib/sequitur/production_ref.rb

@@ -1,115 +1,114 @@
 
 
 module Sequitur # Module for classes implementing the Sequitur algorithm
-# A production reference is a grammar symbol that may appear in the right-hand
-# side of a production P1 and that refers to a production P2.
-# Every time a production P2 appears in the left-hand side of
-# production P1, this is implemented by inserting a production reference to P2
-# in the appropriate position in the RHS of P1.
-# In the literature, production references are also called non terminal
-# symbols
-# @example
-#   # Given a production rule...
-#   prod = Sequitur::Production.new
-#   puts prod.refcount # outputs 0
-#   # ... Build a reference to it
-#   ref = Sequitur::ProductionRef.new(prod)
-#   # ... Production reference count is updated...
-#   puts prod.refcount # outputs 1
-class ProductionRef
-  # Link to the production to reference.
-  attr_reader(:production)
-
-  # Constructor
-  # @param target [Production or ProductionRef]
-  #   The production that is being referenced.
-  def initialize(target)
-    bind_to(target)
-  end
-
-  # Copy constructor invoked by dup or clone methods.
-  # @param orig [ProductionRef]
+  # A production reference is a grammar symbol that may appear in the right-hand
+  # side of a production P1 and that refers to a production P2.
+  # Every time a production P2 appears in the left-hand side of
+  # production P1, this is implemented by inserting a production reference to P2
+  # in the appropriate position in the RHS of P1.
+  # In the literature, production references are also called non terminal
+  # symbols
   # @example
+  #   # Given a production rule...
   #   prod = Sequitur::Production.new
+  #   puts prod.refcount # outputs 0
+  #   # ... Build a reference to it
   #   ref = Sequitur::ProductionRef.new(prod)
-  #   copy_ref = ref.dup
-  #   puts prod.refcount # outputs 2
-  def initialize_copy(orig)
-    @production = nil
-    bind_to(orig.production)
-  end
-
-  # Emit the text representation of a production reference.
-  # @return [String]
-  def to_s()
-    return production.object_id.to_s
-  end
-
-  alias to_string to_s
-
-
-  # Equality testing.
-  #   A production ref is equal to another one when its
-  #   refers to the same production or when it is compared to
-  #   the production it refers to.
-  # @param other [ProductionRef]
-  # @return [true / false]
-  def ==(other)
-    return true if object_id == other.object_id
-
-    result = if other.is_a?(ProductionRef)
-               (production == other.production)
-             else
-               (production == other)
-             end
-
-    return result
-  end
-
-  # Produce a hash value.
-  #   A reference has no identity on its own,
-  #   the method returns the hash value of the
-  #   referenced production
-  # @return [Fixnum] the hash value
-  def hash()
-    raise StandardError, 'Nil production' if production.nil?
-    return production.hash
-  end
-
-  # Make this reference point to the given production.
-  # @param aProduction [Production or ProductionRef] the production
-  #   to refer to
-  def bind_to(aProduction)
-    return if aProduction == @production
-
-    production.decr_refcount if production
-    unless aProduction.kind_of?(Production)
-      raise StandardError, "Illegal production type #{aProduction.class}"
+  #   # ... Production reference count is updated...
+  #   puts prod.refcount # outputs 1
+  class ProductionRef
+    # Link to the production to reference.
+    attr_reader(:production)
+
+    # Constructor
+    # @param target [Production or ProductionRef]
+    #   The production that is being referenced.
+    def initialize(target)
+      bind_to(target)
     end
-    @production = aProduction
-    production.incr_refcount
-  end
-
-
-  # Clear the reference to the target production.
-  def unbind()
-    production.decr_refcount
-    @production = nil
-  end
-
-  # Check that the this object doesn't refer to any production.
-  # @return [true / false] true when this object doesn't
-  #   point to a production.
-  def unbound?()
-    return production.nil?
-  end
-
-  # Part of the 'visitee' role in the Visitor design pattern.
-  # @param aVisitor [GrammarVisitor] the visitor
-  def accept(aVisitor)
-    aVisitor.visit_prod_ref(self)
-  end
-end # class
+
+    # Copy constructor invoked by dup or clone methods.
+    # @param orig [ProductionRef]
+    # @example
+    #   prod = Sequitur::Production.new
+    #   ref = Sequitur::ProductionRef.new(prod)
+    #   copy_ref = ref.dup
+    #   puts prod.refcount # outputs 2
+    def initialize_copy(orig)
+      @production = nil
+      bind_to(orig.production)
+    end
+
+    # Emit the text representation of a production reference.
+    # @return [String]
+    def to_s
+      return production.object_id.to_s
+    end
+
+    alias to_string to_s
+
+
+    # Equality testing.
+    #   A production ref is equal to another one when its
+    #   refers to the same production or when it is compared to
+    #   the production it refers to.
+    # @param other [ProductionRef]
+    # @return [true / false]
+    def ==(other)
+      return true if object_id == other.object_id
+
+      result = if other.is_a?(ProductionRef)
+                 (production == other.production)
+               else
+                 (production == other)
+               end
+
+      return result
+    end
+
+    # Produce a hash value.
+    #   A reference has no identity on its own,
+    #   the method returns the hash value of the
+    #   referenced production
+    # @return [Fixnum] the hash value
+    def hash
+      raise StandardError, 'Nil production' if production.nil?
+      return production.hash
+    end
+
+    # Make this reference point to the given production.
+    # @param aProduction [Production or ProductionRef] the production
+    #   to refer to
+    def bind_to(aProduction)
+      return if aProduction == @production
+
+      production.decr_refcount if production
+      unless aProduction.kind_of?(Production)
+        raise StandardError, "Illegal production type #{aProduction.class}"
+      end
+      @production = aProduction
+      production.incr_refcount
+    end
+
+    # Clear the reference to the target production.
+    def unbind
+      production.decr_refcount
+      @production = nil
+    end
+
+    # Check that the this object doesn't refer to any production.
+    # @return [true / false] true when this object doesn't
+    #   point to a production.
+    def unbound?
+      return production.nil?
+    end
+
+    # Part of the 'visitee' role in the Visitor design pattern.
+    # @param aVisitor [GrammarVisitor] the visitor
+    def accept(aVisitor)
+      aVisitor.visit_prod_ref(self)
+    end
+  end # class
 end # module
 
 # End of file

data/lib/sequitur/sequitur_grammar.rb

@@ -43,7 +43,7 @@ class SequiturGrammar < DynamicGrammar
   #     remove P from grammar
   #   end
   #  end until digram unicity and rule utility are met
-  def enforce_rules()
+  def enforce_rules
     loop do
       unicity_diagnosis = detect_collision if unicity_diagnosis.nil?
       restore_unicity(unicity_diagnosis) if unicity_diagnosis.collision_found
@@ -61,7 +61,7 @@ class SequiturGrammar < DynamicGrammar
   # 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()
+  def detect_collision
     diagnosis = CollisionDiagnosis.new(false)
     found_so_far = {}
     productions.each do |a_prod|
@@ -109,7 +109,7 @@ class SequiturGrammar < DynamicGrammar
   end
 
   # Return a production that is used less than twice in the grammar.
-  def detect_useless_production()
+  def detect_useless_production
     useless = productions.index { |prod| prod.refcount < 2 }
     useless = nil if useless && useless.zero?
 

data/lib/sequitur/symbol_sequence.rb

@@ -6,7 +6,7 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
     attr_reader(:symbols)
 
     # Create an empty sequence
-    def initialize()
+    def initialize
       @symbols = []
     end
 
@@ -21,7 +21,7 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
     end
 
     # Clear the symbol sequence.
-    def clear()
+    def clear
       refs = references
       refs.each(&:unbind)
       @symbols = []
@@ -30,13 +30,13 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
 
     # Tell whether the sequence is empty.
     # @return [true / false] true only if the sequence has no symbol in it.
-    def empty?()
+    def empty?
       return symbols.empty?
     end
 
     # Count the number of elements in the sequence.
     #  @return [Fixnum] the number of elements
-    def size()
+    def size
       return symbols.size
     end
 
@@ -76,15 +76,13 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
       return same
     end
 
-
     # Select the references to production appearing in the rhs.
     # @return [Array of ProductionRef]
-    def references()
+    def references
       @memo_references ||= symbols.select { |symb| symb.is_a?(ProductionRef) }
       return @memo_references
     end
 
-
     # Select the references of the given production appearing in the rhs.
     # @param aProduction [Production]
     # @return [Array of ProductionRef]
@@ -94,11 +92,10 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
       return result
     end
 
-
     # Emit a text representation of the symbol sequence.
     # Text is of the form: space-separated sequence of symbols.
     # @return [String]
-    def to_string()
+    def to_string
       rhs_text = symbols.map do |elem|
         case elem
           when String then "'#{elem}'"
@@ -150,7 +147,6 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
       symbols.delete_at(position)
     end
 
-
     # Part of the 'visitee' role in Visitor design pattern.
     # @param aVisitor[GrammarVisitor]
     def accept(aVisitor)
@@ -170,7 +166,7 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
 
     private
 
-    def invalidate_refs()
+    def invalidate_refs
       @memo_references = nil
       @lookup_references = nil
     end

data/spec/sequitur/digram_spec.rb

@@ -5,28 +5,28 @@ require_relative '../../lib/sequitur/digram'
 
 module Sequitur # Re-open the module to get rid of qualified names
 describe Digram do
-  let(:two_symbols) { [:b, :c] }
+  let(:two_symbols) { %i[b c] }
   let(:production) { double('sample-production') }
 
   context 'Standard creation & initialization:' do
     it 'should be created with 3 arguments' do
       instance = Digram.new(: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)
       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 = Digram.new(:a, :b, production)
-       expect(instance1).not_to be_repeating       
+       expect(instance1).not_to be_repeating
     end
   end # context
 
@@ -35,11 +35,11 @@ describe Digram do
       instance1 = Digram.new(:a, :b, production)
       same = Digram.new(:a, :b, production)
       different = Digram.new(:b, :c, production)
-      
+
       expect(instance1).to eq(instance1)
       expect(instance1).to eq(same)
       expect(instance1).not_to eq(different)
-      expect(same).not_to eq(different)       
+      expect(same).not_to eq(different)
     end
   end # context
 end # describe