sequitur 0.1.09 → 0.1.10

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    M2JmMGMzOGFjNjg3YmQzZDNlMWNjODI2ZmIzNjA4MTM4ZDNkMzUzZA==
+    ZGMxY2RmOWZlOWI3MzljMjNmZmEyZDFjZDUzZDg2YzQzNzM2MmRhZQ==
   data.tar.gz: !binary |-
-    ZTAyMGI0MDYzMDBkMDJlNWFhNjE2Yjc5NTUyZjhiNDEzZjEzYzg1ZQ==
+    YzNhZGJmNWY4YTg3MWY3ODI5YzE4ZTg5MTUyNTlkMGFmMzhlNjdiYw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OGQ1YjVhY2M2MmM2YWNiODYyYzQxMmRjNmFmYWY2NjYyMGYyMWM5YjVjNzFh
-    OTVmMDhhZTE2YTRhMWNmODVhYTJjMDUyMDNlYjk0NmJjMjRkN2Q0ODcyYTRj
-    YzAyZDA2ZDJiY2E1YWE5ZTYyYWExNmJkMzI3ODYyZDgwZGUyMzI=
+    NWY1NDhiZjUzNjJjNTdlMmE2ZjI0ODc3MDNlMjQ2MGM3ZjEzMWQxNzUxZDgz
+    YmE4ZmFlNzI4NDc2NGE0YjQzOTJhNmViYmQ4MThjZTg0YmEyN2JiOTlkMzk4
+    MTc4MWUwMWE3ZWY0NTQ0Y2ZlYjU3MmVkODNiZjUwMzgxZWNlMDQ=
   data.tar.gz: !binary |-
-    N2EyZmU3NTNiMTc1YmZkZjk4ODNmMzYyY2ExYzI0YTNmNTFlYWY4OWUxZTQ4
-    NjJmMWUzYzM3Yjc4ZDU5YzIyNTEwZTI5OWI1ZDlhY2RiYzQ3Yzc5OTgxZDZk
-    MzY1MzEwMDBjYTliYmQxYTEwYzQ4MjQzYzFjYjVhNDgxMGE4YTA=
+    MWI3N2U3ZGU5N2Y4ZTEzNDdmYjQyYjExOWIzYWRjMWE0ZDUxYmM2MjI4YzU0
+    ODZiZTQ3ZDlkMWMxMmY2ZWQwM2JjNmZiNmU1ZDRhMTFhMjY4ZjI5MjJmNWFl
+    MDYxZmU0ZWUwOTdhNDBkODE4NDJjNzQ0MGRmMWQwMDIxMjkwMTI=

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 0.1.10 / 2014-10-05
+* [CHANGE] Code refactoring for performance. Impacted classes: `SequiturGrammar`, `SymbolSequence` and `Production`.
+
 ### 0.1.09 / 2014-10-03
 * [NEW] Class `SymbolSequence`. Part of code refactoring that reduces code complexity reported by CodeClimate.
 * [CHANGE] Class `Production` refactored to use a SymbolSequence instance as its rhs.

data/lib/sequitur/constants.rb

@@ -3,7 +3,7 @@
 
 module Sequitur # Module used as a namespace
   # The version number of the gem.
-  Version = '0.1.09'
+  Version = '0.1.10'
 
   # Brief description of the gem.
   Description = 'Ruby implementation of the Sequitur algorithm'

data/lib/sequitur/digram.rb

@@ -27,7 +27,7 @@ class Digram
   #   the sequence symbol1 symbol2 appears.
   def initialize(symbol1, symbol2, aProduction)
     @symbols = [symbol1, symbol2]
-    @key = "#{symbol1.hash.to_s(16)}:#{symbol2.hash.to_s(16)}" 
+    @key = symbol1.hash.to_s(16) + ':' + symbol2.hash.to_s(16) 
     @production = aProduction
   end
   

data/lib/sequitur/grammar_visitor.rb

@@ -48,14 +48,14 @@ class GrammarVisitor
   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. 
+  # @param rhs [SymbolSequence] the rhs of a production to visit.
   def start_visit_rhs(rhs)
-    broadcast(:before_rhs, rhs)  
+    broadcast(:before_rhs, rhs)
   end
 
-  # Visit event. The visitor is visiting the 
+  # 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)
@@ -64,18 +64,18 @@ class GrammarVisitor
     broadcast(:after_non_terminal, production)
   end
 
-  # Visit event. The visitor is visiting the 
+  # 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) 
+    broadcast(:after_rhs, rhs)
   end
 
   # Visit event. The visitor has completed its visit of the given production.
@@ -91,6 +91,7 @@ class GrammarVisitor
   end
 
   private
+
   # Send a notification to all subscribers.
   # @param msg [Symbol] event to notify
   # @param args [Array] arguments of the notification.

data/lib/sequitur/production.rb

@@ -78,9 +78,9 @@ class Production
   # Look in the rhs all the references to a production passed a argument.
   # aProduction [aProduction or ProductionRef] The production to search for.
   # @return [Array] the array of ProductionRef to the passed production
-  def references_of(aProduction)
-    refs = references
-    return refs.select { |a_ref| a_ref == aProduction }
+  def references_of(a_prod)
+    real_prod = a_prod.is_a?(ProductionRef) ? a_prod.production : a_prod
+    return rhs.references_of(real_prod)
   end
 
 
@@ -158,7 +158,7 @@ class Production
   # Clear the right-hand side.
   # Any referenced production has its reference counter decremented.
   def clear_rhs()
-    rhs.clear()
+    rhs.clear
   end
 
   # Find all the positions where the digram occurs in the rhs

data/lib/sequitur/sequitur_grammar.rb

@@ -9,7 +9,7 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
 class SequiturGrammar < DynamicGrammar
 
   # Build the grammar from an enumerator of tokens.
-  # @param anEnum [Enumerator] an enumerator that will iterate 
+  # @param anEnum [Enumerator] an enumerator that will iterate
   #   over the input tokens.
   def initialize(anEnum)
     super()
@@ -25,12 +25,12 @@ class SequiturGrammar < DynamicGrammar
 
   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
-)
+  # 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,
@@ -49,13 +49,13 @@ CollisionDiagnosis = Struct.new(
     loop do
       unicity_diagnosis = detect_collision if unicity_diagnosis.nil?
       restore_unicity(unicity_diagnosis) if unicity_diagnosis.collision_found
-      
-      useless_prod = detect_useless_production
-      restore_utility(useless_prod) if useless_prod
+
+      prod_index = detect_useless_production
+      restore_utility(prod_index) unless prod_index.nil?
 
       unicity_diagnosis = detect_collision
-      useless_prod = detect_useless_production
-      break unless unicity_diagnosis.collision_found || useless_prod
+      prod_index = detect_useless_production
+      break unless unicity_diagnosis.collision_found || !prod_index.nil?
     end
   end
 
@@ -72,7 +72,7 @@ CollisionDiagnosis = Struct.new(
         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 
+          # Disregard sequence like a a a
           if ((orig_digr.production == a_prod) && a_digr.repeating? &&
             (orig_digr == a_digr))
             next
@@ -112,20 +112,23 @@ CollisionDiagnosis = Struct.new(
 
   # Return a production that is used less than twice in the grammar.
   def detect_useless_production()
-    useless = productions.find { |prod| prod.refcount < 2 }
-    return (useless == productions[0]) ? nil : useless
+    useless = productions.index { |prod| prod.refcount < 2 }
+    unless useless.nil?
+      useless = nil if useless == 0
+    end
+    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(useless_prod)
-    # Retrieve index of useless_prod
-    index =  productions.index(useless_prod)
+  def restore_utility(prod_index)
+    # Retrieve useless prod from its index
+    useless_prod =  productions[prod_index]
 
     # Retrieve production referencing useless one
     referencing = nil
-    productions.each do |a_prod|
+    productions.reverse.each do |a_prod|
       # Next line assumes non-recursive productions
       next if a_prod == useless_prod
 
@@ -136,7 +139,7 @@ CollisionDiagnosis = Struct.new(
     end
 
     referencing.derive_step(useless_prod)
-    remove_production(index)
+    remove_production(prod_index)
   end
 
   # Create a new production that will have the symbols from digram
@@ -145,7 +148,7 @@ CollisionDiagnosis = Struct.new(
     new_prod = Production.new
     aDigram.symbols.each { |sym| new_prod.append_symbol(sym) }
     add_production(new_prod)
-    
+
     return new_prod
   end
 end # class

data/lib/sequitur/symbol_sequence.rb

@@ -17,6 +17,7 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
       @symbols = orig.symbols.map do |sym|
         sym.is_a?(Symbol) ? sym : sym.dup
       end
+      invalidate_refs
     end
 
     public
@@ -26,6 +27,7 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
       refs = references
       refs.each(&:unbind)      
       @symbols = []
+      invalidate_refs
     end
 
     # Tell whether the sequence is empty.
@@ -44,6 +46,10 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
     # @param aSymbol [Object] The symbol to append.
     def <<(aSymbol)
       symbols << aSymbol
+      if aSymbol.is_a?(ProductionRef)
+        @memo_references ||= []
+        @memo_references << aSymbol
+      end
     end
 
     # Retrieve the element from the sequence at given position.
@@ -58,13 +64,13 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
     # @return true when an item from self equals the corresponding
     #   item from 'other'
     def ==(other)
-      return true if self.object_id == other.object_id
+      return true if object_id == other.object_id
 
       case other
-      when SymbolSequence
-        same = self.symbols == other.symbols
-      when Array
-        same = self.symbols == other
+        when SymbolSequence
+          same = symbols == other.symbols
+        when Array
+          same = symbols == other
       else
         same = false
       end
@@ -76,7 +82,18 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
     # Select the references to production appearing in the rhs.
     # @return [Array of ProductionRef]
     def references()
-      return symbols.select { |symb| symb.is_a?(ProductionRef) }
+      @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]
+    def references_of(aProduction)
+      return [] if references.empty?
+      result = references.select { |a_ref| a_ref == aProduction }
+      return result
     end
 
 
@@ -96,11 +113,12 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
   
     # Insert at position the elements from another sequence.
     # @param position [Fixnum] A zero-based index of the symbols to replace.
-    # @param another [Production] A production with a two-elements rhs
+    # @param another [SymbolSequence] A production with a two-elements rhs
     #   (a single digram).
     def insert_at(position, another)
       klone = another.dup
       symbols.insert(position, *klone.symbols)
+      invalidate_refs
     end
     
     # Given that the production P passed as argument has exactly 2 symbols
@@ -114,16 +132,23 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
       if symbols[index].is_a?(ProductionRef)
         symbols[index].bind_to(aProduction)
       else
-        symbols[index] = ProductionRef.new(aProduction)
+        new_ref = ProductionRef.new(aProduction)
+        symbols[index] = new_ref
+        @memo_references ||= []
+        @memo_references << new_ref
       end
       index1 = index + 1
-      symbols[index1].unbind if symbols[index1].is_a?(ProductionRef)
+      if symbols[index1].is_a?(ProductionRef)
+        symbols[index1].unbind
+        invalidate_refs
+      end
       delete_at(index1)
     end
 
     # Remove the element at given position
     # @param position [Fixnum] a zero-based index.
     def delete_at(position)
+      invalidate_refs if symbols[position].is_a?(ProductionRef)
       symbols.delete_at(position)
     end
 
@@ -144,7 +169,14 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
 
       aVisitor.end_visit_rhs(self)
     end
+    
+    private
+    
+    def invalidate_refs()
+      @memo_references = nil
+      @lookup_references = nil
+    end
 
   end # class
 
-end # module
+end # module

data/spec/sequitur/production_spec.rb

@@ -77,18 +77,19 @@ describe Production do
       # Case 2: production with one reference
       subject.append_symbol(p_a)
       expect(subject.references).to eq([p_a])
-      expect(subject.references_of(p_a)).to eq([p_a])
+      expect(subject.references_of(p_a).map(&:production)).to eq([p_a])
+
 
       # Case 3: production with repeated references
       subject.append_symbol(p_a) # second time
       expect(subject.references).to eq([p_a, p_a])
-      expect(subject.references_of(p_a)).to eq([p_a, p_a])
+      expect(subject.references_of(p_a).map(&:production)).to eq([p_a, p_a])
 
 
       # Case 4: production with multiple distinct references
       subject.append_symbol(p_bc)
       expect(subject.references).to eq([p_a, p_a, p_bc])
-      expect(subject.references_of(p_bc)).to eq([p_bc])
+      expect(subject.references_of(p_bc).map(&:production)).to eq([p_bc])
     end
 
     it 'should know the position(s) of a given digram' do

data/spec/sequitur/symbol_sequence_spec.rb

@@ -9,7 +9,7 @@ module Sequitur # Re-open the module to get rid of qualified names
 
 describe SymbolSequence do
 
-  let(:instance) { SymbolSequence.new } 
+  let(:instance) { SymbolSequence.new }
 
   context 'Creation and initialization:' do
 
@@ -24,34 +24,35 @@ describe SymbolSequence do
   end # context
 
   context 'Provided services:' do
+    let(:a_prod) { Production.new }
+
     subject do
       an_instance = SymbolSequence.new
       [:a, :b, :c].each { |a_sym| an_instance << a_sym }
       an_instance
     end
-    
+
     it 'should deep-copy clone itself' do
-      a_prod = Production.new
       ref = ProductionRef.new(a_prod)
-      
+
       a,  c = 'a', 'c'
       [a, ref, c].each { |ch| instance << ch }
       clone_a = instance.clone
-      
+
       # Check that cloning works
       expect(clone_a).to eq(instance)
-      
+
       # Reference objects are distinct but points to same production
       expect(clone_a.symbols[1].object_id).not_to eq(instance.symbols[1])
-      
+
       # Modifying the clone...
       clone_a.symbols[1] = 'diff'
       expect(clone_a).not_to eq(instance)
-      
+
       # ... should leave original unchanged
       expect(instance.symbols[1]).to eq(ref)
     end
-    
+
 
     it 'should tell that it is equal to itself' do
       # Case: Non-empty sequence
@@ -65,25 +66,53 @@ describe SymbolSequence do
       expect(instance).to eq(instance)
 
       expect(subject).not_to eq(instance)
-      [:a, :b, :c].each { |a_sym| instance << a_sym }      
+      [:a, :b, :c].each { |a_sym| instance << a_sym }
       expect(subject).to eq(instance)
-      
+
       # Check that element order is relevant
       instance.symbols.rotate!
-      expect(subject).not_to eq(instance)      
+      expect(subject).not_to eq(instance)
     end
-    
+
     it 'should know whether it is equal to an array' do
       expect(subject).to eq([:a, :b, :c])
-      
+
       # Check that element order is relevant
-      expect(subject).not_to eq([:c, :b, :a])   
+      expect(subject).not_to eq([:c, :b, :a])
     end
-    
+
     it 'should know that is not equal to something else' do
       expect(subject).not_to eq(:abc)
     end
 
+
+    it 'should know its references' do
+      ref = ProductionRef.new(a_prod)
+      2.times { subject << ref }
+
+      refs = subject.references
+      expect(refs.size).to eq(2)
+      expect(refs).to eq([ref, ref])
+
+      refs = subject.references
+      expect(refs.size).to eq(2)
+      expect(refs).to eq([ref, ref])
+      specific_refs = subject.references_of(a_prod)
+      expect(specific_refs).to eq(refs)
+
+
+      another = Production.new
+      another_ref = ProductionRef.new(another)
+      subject << another_ref
+      refs = subject.references
+      expect(refs.size).to eq(3)
+      expect(refs).to eq([ref, ref, another])
+      specific_refs = subject.references_of(a_prod)
+      expect(specific_refs).to eq([ref, ref])
+      specific_refs = subject.references_of(another)
+      expect(specific_refs).to eq([another])
+    end
+
   end # context
 
 
@@ -92,4 +121,4 @@ end # describe
 
 end # module
 
-# End of file
+# End of file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.1.09
+  version: 0.1.10
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-03 00:00:00.000000000 Z
+date: 2014-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake