sequitur 0.1.07 → 0.1.09

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzBkNjMyMWI2NjUxNDUxMWE0ZDg0Y2MxOTQ5NDViMThkZjk5NDlhNQ==
+    M2JmMGMzOGFjNjg3YmQzZDNlMWNjODI2ZmIzNjA4MTM4ZDNkMzUzZA==
   data.tar.gz: !binary |-
-    NmFjODAxMDdiODNmNDdiYmQwNTMzOGJiMmY5NDVhOTFkMjUyOTEyMw==
+    ZTAyMGI0MDYzMDBkMDJlNWFhNjE2Yjc5NTUyZjhiNDEzZjEzYzg1ZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZTBhYzNkMmM2ZTExOTQwNmIzMTlmYmUxNTVlZTY1MjJjYmMwMzYxZmEwMjhm
-    MWY1MDJhZDY3ZTdhZWEwZjRiY2M3Yjc1NTY4ZjkxYzZiMWNkYjY2YTA3Zjhh
-    MTY0ZmMxZTAyYTMxYWE3MmJhMjE0MDFiMWViMWUxYmQ1ZDQwOWU=
+    OGQ1YjVhY2M2MmM2YWNiODYyYzQxMmRjNmFmYWY2NjYyMGYyMWM5YjVjNzFh
+    OTVmMDhhZTE2YTRhMWNmODVhYTJjMDUyMDNlYjk0NmJjMjRkN2Q0ODcyYTRj
+    YzAyZDA2ZDJiY2E1YWE5ZTYyYWExNmJkMzI3ODYyZDgwZGUyMzI=
   data.tar.gz: !binary |-
-    NjBkYmE4MjYwNGQxODFkMjJlZGFkNWI1Yzc3YmE0OWY5OWQyNGZmZTZhNzQ5
-    ZTA4NDhiMWQwMGFiM2EzODczOTJkZTA4OTlhZmY0NzUwMDBlMTJmZDM2MjY1
-    OWU0MzM3NjdhYWNhNDAyOTQ1MDc5YzQ5ZWJkZTY3YjcxMDkzNjI=
+    N2EyZmU3NTNiMTc1YmZkZjk4ODNmMzYyY2ExYzI0YTNmNTFlYWY4OWUxZTQ4
+    NjJmMWUzYzM3Yjc4ZDU5YzIyNTEwZTI5OWI1ZDlhY2RiYzQ3Yzc5OTgxZDZk
+    MzY1MzEwMDBjYTliYmQxYTEwYzQ4MjQzYzFjYjVhNDgxMGE4YTA=

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+### 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.
+* [CHANGE] File `README.md`: Minor cosmetic enhancements.
+
+### 0.1.08 / 2014-09-30
+* [CHANGE] Method `SequiturGrammar#restore_unicity` Code refactored to reduce code complexity reported by CodeClimate.
+* [CHANGE] File `README.md`: Minor cosmetic enhancements.
+
 ### 0.1.07 / 2014-09-29
 * [CHANGE] File `README.md`: Fixed bad Markdown syntax in badge part.
 

data/README.md

@@ -8,7 +8,7 @@ _Ruby gem implementing the Sequitur algorithm_
 [![Gem Version](https://badge.fury.io/rb/sequitur.svg)](http://badge.fury.io/rb/sequitur)
 [![Dependency Status](https://gemnasium.com/famished-tiger/Sequitur.png)](https://gemnasium.com/famished-tiger/Sequitur)
 [![Inline docs](http://inch-ci.org/github/famished-tiger/Sequitur.svg?branch=master)](http://inch-ci.org/github/famished-tiger/Sequitur)
-
+[![Code Climate](https://codeclimate.com/github/famished-tiger/Sequitur.png)](https://codeclimate.com/github/famished-tiger/Sequitur)
 
 ### What is the Sequitur algorithm? ###
 The following are good entry points to learn about the algorithm:  
@@ -23,7 +23,7 @@ in a very compact way.
 Of interest is the fact that the algorithm runs in time linear in the length of the input sequence.
 
 **Can you give a simple example?**  
-Sure. Let's begin with a very basic case. Assume that 'abcabcabc' is our input string.
+Sure. Let's begin with a very basic case. Assume that *'abcabcabc'* is our input string.
 Notice that it is the same as the text 'abc' repeated three times. The Sequitur algorithm captures
 this repetition and will generate the two following rules:
 
@@ -32,13 +32,13 @@ start : P1 P1 P1.
 P1 : a b c.
 ```
 
-In plain English:
+In plain English:  
 -The first rule (named start) always represents the whole input. Here, it indicates that the input
-is three time the pattern encoded by the rule called P1.
--The second rule (named P1) represents the sequence a b c.
+is three time the pattern encoded by the rule called P1.  
+-The second rule (named P1) represents the sequence a b c.  
 
 **Can you give another example?**  
-Yep. Assume this time that the input is 'ababcabcdabcde'. 
+Yep. Assume this time that the input is *'ababcabcdabcde'*. 
 Then Sequitur algorithm will generate the rule set:  
 ```
 start : P1 P2 P3 P3 e.  

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.07'
+  Version = '0.1.09'
 
   # Brief description of the gem.
   Description = 'Ruby implementation of the Sequitur algorithm'

data/lib/sequitur/grammar_visitor.rb

@@ -47,7 +47,12 @@ class GrammarVisitor
   # @param aProduction [Production] the production to visit.
   def start_visit_production(aProduction)
     broadcast(:before_production, aProduction)
-    broadcast(:before_rhs, aProduction.rhs)
+  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 
@@ -66,13 +71,17 @@ class GrammarVisitor
     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_rhs, aProduction.rhs)
     broadcast(:after_production, aProduction)
-
   end
 
   # Visit event. The visitor has completed the visit of the grammar.

data/lib/sequitur/production.rb

@@ -1,4 +1,5 @@
 require_relative 'digram'
+require_relative 'symbol_sequence'
 require_relative 'production_ref'
 
 module Sequitur # Module for classes implementing the Sequitur algorithm
@@ -25,10 +26,12 @@ class Production
   # Constructor. 
   # Build a production with an empty RHS.
   def initialize()
-    clear_rhs
+    @rhs = SymbolSequence.new
     @refcount = 0
     @digrams = []
   end
+  
+  
 
   public
 
@@ -69,7 +72,7 @@ class Production
   # Select the references to production appearing in the rhs.
   # @return [Array of ProductionRef]
   def references()
-    return rhs.select { |symb| symb.is_a?(ProductionRef) }
+    return rhs.references
   end
 
   # Look in the rhs all the references to a production passed a argument.
@@ -87,8 +90,7 @@ class Production
     return [] if rhs.size < 2
 
     result = []
-    rhs.each_cons(2) { |couple| result << Digram.new(*couple, self) }
-
+    rhs.symbols.each_cons(2) { |couple| result << Digram.new(*couple, self) }
     @digrams = result
   end
 
@@ -129,14 +131,7 @@ class Production
   # object id of production : rhs as space-separated sequence of symbols.
   # @return [String]
   def to_string()
-    rhs_text = rhs.map do |elem|
-      case elem
-        when String then "'#{elem}'"
-        else elem.to_s
-      end
-    end
-
-    return "#{object_id} : #{rhs_text.join(' ')}."
+    return "#{object_id} : #{rhs.to_string}."
   end
 
   # Add a (grammar) symbol at the end of the RHS.
@@ -163,11 +158,7 @@ class Production
   # Clear the right-hand side.
   # Any referenced production has its reference counter decremented.
   def clear_rhs()
-    if rhs
-      refs = references
-      refs.each(&:unbind)
-    end
-    @rhs = []
+    rhs.clear()
   end
 
   # Find all the positions where the digram occurs in the rhs
@@ -203,20 +194,11 @@ class Production
   # @param another [Production or ProductionRef] a production that
   #   consists exactly of one digram (= 2 symbols).
   def reduce_step(another)
-    (symb1, symb2) = another.rhs
+    (symb1, symb2) = another.rhs.symbols
     pos = positions_of(symb1, symb2).reverse
 
     # Replace the two symbol sequence by the production
-    pos.each do |index|
-      if rhs[index].is_a?(ProductionRef)
-        rhs[index].bind_to(another)
-      else
-        rhs[index] = ProductionRef.new(another)
-      end
-      index1 = index + 1
-      rhs[index1].unbind if rhs[index1].is_a?(ProductionRef)
-      rhs.delete_at(index1)
-    end
+    pos.each { |index| rhs.reduce_step(index, another) }
 
     recalc_digrams
   end
@@ -235,11 +217,7 @@ class Production
     (0...rhs.size).to_a.reverse.each do |index|
       next unless rhs[index] == another
 
-      # Avoid the aliasing of production reference
-      other_rhs = another.rhs.map do |symb|
-        symb.is_a?(ProductionRef) ? symb.dup : symb
-      end
-      rhs.insert(index + 1, *other_rhs)
+      rhs.insert_at(index + 1, another.rhs)
       another.decr_refcount
       rhs.delete_at(index)
     end
@@ -253,13 +231,7 @@ class Production
   def accept(aVisitor)
     aVisitor.start_visit_production(self)
 
-    rhs.each do |a_symb|
-      if a_symb.is_a?(ProductionRef)
-        a_symb.accept(aVisitor)
-      else
-        aVisitor.visit_terminal(a_symb)
-      end
-    end
+    rhs.accept(aVisitor)
 
     aVisitor.end_visit_production(self)
   end

data/lib/sequitur/sequitur_grammar.rb

@@ -97,7 +97,6 @@ CollisionDiagnosis = Struct.new(
   # Then create a new production that will have
   # the symbols of d as its rhs members.
   def restore_unicity(aDiagnosis)
-    digr = aDiagnosis.digram
     prods = aDiagnosis.productions
     if prods.any?(&:single_digram?)
       (simple, compound) = prods.partition(&:single_digram?)
@@ -105,14 +104,9 @@ CollisionDiagnosis = Struct.new(
     else
       # Create a new production with the digram's symbols as its
       # sole rhs members.
-      new_prod = Production.new
-      digr.symbols.each { |sym| new_prod.append_symbol(sym) }
-      add_production(new_prod)
-      if prods[0] == prods[1]
-        prods[0].reduce_step(new_prod)
-      else
-        prods.each { |a_prod| a_prod.reduce_step(new_prod) }
-      end
+      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
 
@@ -145,7 +139,15 @@ CollisionDiagnosis = Struct.new(
     remove_production(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)
+    
+    return new_prod
+  end
 end # class
 
 end # module

data/lib/sequitur/symbol_sequence.rb

@@ -0,0 +1,150 @@
+module Sequitur # Module for classes implementing the Sequitur algorithm
+  # Represents a sequence (concatenation) of grammar symbols
+  # as they appear in rhs of productions
+  class SymbolSequence
+    # The sequence of symbols itself
+    attr_reader(:symbols)
+
+    # Create an empty sequence
+    def initialize()
+      @symbols = []
+    end
+    
+    # Copy constructor invoked by dup or clone methods.
+    # @param orig [SymbolSequence]
+    def initialize_copy(orig)
+      # Deep copy to avoid the aliasing of production reference
+      @symbols = orig.symbols.map do |sym|
+        sym.is_a?(Symbol) ? sym : sym.dup
+      end
+    end
+
+    public
+    
+    # Clear the symbol sequence.
+    def clear()
+      refs = references
+      refs.each(&:unbind)      
+      @symbols = []
+    end
+
+    # Tell whether the sequence is empty.
+    # @return [true / false] true only if the sequence has no symbol in it.
+    def empty?()
+      return symbols.empty?
+    end
+
+    # Count the number of elements in the sequence.
+    #  @return [Fixnum] the number of elements
+    def size()
+      return symbols.size
+    end
+    
+    # Append a grammar symbol at the end of the sequence.
+    # @param aSymbol [Object] The symbol to append.
+    def <<(aSymbol)
+      symbols << aSymbol
+    end
+
+    # 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]
+    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
+    #   item from 'other'
+    def ==(other)
+      return true if self.object_id == other.object_id
+
+      case other
+      when SymbolSequence
+        same = self.symbols == other.symbols
+      when Array
+        same = self.symbols == other
+      else
+        same = false
+      end
+
+      return same
+    end
+
+
+    # Select the references to production appearing in the rhs.
+    # @return [Array of ProductionRef]
+    def references()
+      return symbols.select { |symb| symb.is_a?(ProductionRef) }
+    end
+
+
+    # Emit a text representation of the symbol sequence.
+    # Text is of the form: space-separated sequence of symbols.
+    # @return [String]
+    def to_string()
+      rhs_text = symbols.map do |elem|
+        case elem
+          when String then "'#{elem}'"
+          else elem.to_s
+        end
+      end
+
+      return rhs_text.join(' ')
+    end
+  
+    # 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
+    #   (a single digram).
+    def insert_at(position, another)
+      klone = another.dup
+      symbols.insert(position, *klone.symbols)
+    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.
+    # @param index [Fixnum] the position of a two symbol sequence to be replaced
+    #   by the production
+    # @param aProduction [Production or ProductionRef] a production that
+    #   consists exactly of one digram (= 2 symbols).
+    def reduce_step(index, aProduction)
+      if symbols[index].is_a?(ProductionRef)
+        symbols[index].bind_to(aProduction)
+      else
+        symbols[index] = ProductionRef.new(aProduction)
+      end
+      index1 = index + 1
+      symbols[index1].unbind if symbols[index1].is_a?(ProductionRef)
+      delete_at(index1)
+    end
+
+    # Remove the element at given position
+    # @param position [Fixnum] a zero-based index.
+    def delete_at(position)
+      symbols.delete_at(position)
+    end
+
+
+    # Part of the 'visitee' role in Visitor design pattern.
+    # @param aVisitor[GrammarVisitor]
+    def accept(aVisitor)
+      aVisitor.start_visit_rhs(self)
+
+      # Let's proceed with the visit of productions
+      symbols.each do |a_symb|
+        if a_symb.is_a?(ProductionRef)
+          a_symb.accept(aVisitor)
+        else
+          aVisitor.visit_terminal(a_symb)
+        end
+      end
+
+      aVisitor.end_visit_rhs(self)
+    end
+
+  end # class
+
+end # module

data/spec/sequitur/dynamic_grammar_spec.rb

@@ -108,9 +108,12 @@ describe DynamicGrammar do
       a_visitor.subscribe(fake_formatter)
 
       expect(fake_formatter).to receive(:before_grammar).with(subject).ordered
-      expect(fake_formatter).to receive(:before_production).with(subject.start)
-      expect(fake_formatter).to receive(:before_rhs).with([]).ordered
-      expect(fake_formatter).to receive(:after_rhs).with([]).ordered
+      expect(fake_formatter).to receive(:before_production)
+        .with(subject.start).ordered
+      expect(fake_formatter).to receive(:before_rhs)
+        .with(subject.start.rhs).ordered
+      expect(fake_formatter).to receive(:after_rhs)
+        .with(subject.start.rhs).ordered
       expect(fake_formatter).to receive(:after_production).with(subject.start)
       expect(fake_formatter).to receive(:before_production).with(p_a)
       expect(fake_formatter).to receive(:before_rhs).with(p_a.rhs)

data/spec/sequitur/grammar_visitor_spec.rb

@@ -78,16 +78,6 @@ describe GrammarVisitor do
       
       subject.start_visit_grammar(fake)
     end
-    
-    it 'should react to the start_visit_production message' do
-      expect(mock_production).to receive(:rhs).and_return([1, 2, 3])
-      
-      # Notify subscribers when start the visit of the production
-      expect(listener1).to receive(:before_production).with(mock_production)
-      expect(listener1).to receive(:before_rhs).with([1, 2, 3])
-      
-      subject.start_visit_production(mock_production)
-    end
 
   end # context  
 

data/spec/sequitur/production_spec.rb

@@ -330,6 +330,8 @@ describe Production do
       
       # Empty production: visitor will receive a start and end visit messages
       expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:start_visit_rhs).once.ordered
+      expect(fake).to receive(:end_visit_rhs).once.ordered
       expect(fake).to receive(:end_visit_production).once.ordered
 
       expect { subject.accept(fake) }.not_to raise_error
@@ -339,8 +341,10 @@ describe Production do
       # Use a mock visitor
       fake = double('fake_visitor')      
       expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:start_visit_rhs).once.ordered
       expect(fake).to receive(:visit_terminal).with('b').ordered
       expect(fake).to receive(:visit_terminal).with('c').ordered
+      expect(fake).to receive(:end_visit_rhs).once.ordered
       expect(fake).to receive(:end_visit_production).once.ordered
 
       expect { p_bc.accept(fake) }.not_to raise_error
@@ -353,8 +357,10 @@ describe Production do
       
       fake = double('fake_visitor')      
       expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:start_visit_rhs).once.ordered
       expect(fake).to receive(:visit_prod_ref).with(p_a).ordered
       expect(fake).to receive(:visit_prod_ref).with(p_bc).ordered
+      expect(fake).to receive(:end_visit_rhs).once.ordered
       expect(fake).to receive(:end_visit_production).once.ordered
 
       expect { subject.accept(fake) }.not_to raise_error

data/spec/sequitur/symbol_sequence_spec.rb

@@ -0,0 +1,95 @@
+require_relative '../spec_helper'
+
+# Load the class under test
+require_relative '../../lib/sequitur/symbol_sequence'
+require_relative '../../lib/sequitur/production_ref'
+require_relative '../../lib/sequitur/production'
+
+module Sequitur # Re-open the module to get rid of qualified names
+
+describe SymbolSequence do
+
+  let(:instance) { SymbolSequence.new } 
+
+  context 'Creation and initialization:' do
+
+    it 'should be created without argument' do
+      expect { SymbolSequence.new }.not_to raise_error
+    end
+
+    it 'should be empty at creation' do
+      expect(subject).to be_empty
+    end
+
+  end # context
+
+  context 'Provided services:' do
+    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
+      expect(subject).to eq(subject)
+
+      # Case: empty sequence
+      expect(instance).to eq(instance)
+    end
+
+    it 'should know whether it is equal to another instance' do
+      expect(instance).to eq(instance)
+
+      expect(subject).not_to eq(instance)
+      [: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)      
+    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])   
+    end
+    
+    it 'should know that is not equal to something else' do
+      expect(subject).not_to eq(:abc)
+    end
+
+  end # context
+
+
+
+end # describe
+
+end # module
+
+# End of file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.1.07
+  version: 0.1.09
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-29 00:00:00.000000000 Z
+date: 2014-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -114,6 +114,7 @@ files:
 - lib/sequitur/production.rb
 - lib/sequitur/production_ref.rb
 - lib/sequitur/sequitur_grammar.rb
+- lib/sequitur/symbol_sequence.rb
 - spec/sequitur/digram_spec.rb
 - spec/sequitur/dynamic_grammar_spec.rb
 - spec/sequitur/formatter/base_text_spec.rb
@@ -122,6 +123,7 @@ files:
 - spec/sequitur/production_ref_spec.rb
 - spec/sequitur/production_spec.rb
 - spec/sequitur/sequitur_grammar_spec.rb
+- spec/sequitur/symbol_sequence_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/famished-tiger/Sequitur
 licenses:
@@ -163,3 +165,4 @@ test_files:
 - spec/sequitur/production_ref_spec.rb
 - spec/sequitur/production_spec.rb
 - spec/sequitur/sequitur_grammar_spec.rb
+- spec/sequitur/symbol_sequence_spec.rb