sequitur 0.0.11 → 0.0.12

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGM4MWZiN2YzOTRmODhhNDlkNGIzMGRiOWYzZjU3MDY5ODc2YWUwMg==
+    ZjQ5ZDcxYTMzZGJlOWUzOTg1YmYxMThiMTAxYjk5YjZmZjkyY2FjMA==
   data.tar.gz: !binary |-
-    ZGJmYzVjMzlkOTE0ZGRhZGI3ZWRjY2IyMDk3ZGY3ZDY1YjIyY2YyNg==
+    ZGIyODgxMjNhMmRiNGUyMjZlMTMzYjQwOGRjMjc3YzYyMTYzYjNmZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    Nzk1ZDRmNjBkN2FmODQ4Yjk5ODNiYTk3NDA1YTkxYmZlYjMyOGI0MDhkZTM5
-    NTg1ZWQyOGIxYzc2NjE4ODg0ODY1MDJiMzJhNDBmNGJlMjdiNzAwMTI3ZmZl
-    MDkzMGFjYWNhNTU4ZWUwYTBjYjdlMjJjNjc2MmY5ZTk5MTUzNTQ=
+    OWFmNTRlN2NkZjRhNjVlOTU0MTlmZjZjNjllMDZjY2M4NWNiNWQ3NzQ0ZGMz
+    MjBkOWQzNjJjN2JiODExNDc2OTFmNjIyMGEyY2VkMDdiNDQyZjdiZTFjNTgw
+    NGE5NmVlZTEwMTkzNjU4ZGI2MjA5MGY3YTVhMjM2ZDcyZjhlMzk=
   data.tar.gz: !binary |-
-    MWQ2OGU3OWIyMzQ5MWVkM2IxZGFhYzhmNDM5MGRkMzA5MjlhNzUxYTViYWMz
-    MzIzY2MxYjk1OTBmMTNkNmM4NDM0NWI4YzJlZDk5YjU2ZjU4YmM2ZWYzMjkx
-    MmNkYWE5MjU3NmI3MTE1OTIwYWZmOWI1ODRlMmQ4ZmZjNjkwY2E=
+    ZjUzNWVlNTQ1ODI0NDkyMGUxOWY4NDIwYWIzNmJjNTEzOTgzZDE3YmRmMTE3
+    NjM1Mzc0Mzk5YmQ1MDdhMzFlZDc2YzVkYjc2MmY4ZWEwZWY0YjY1ZTdlYmFi
+    ZGJjODhmYzBhNGU2Y2IxZGZlODZlODNhNTg2NzU1YTgwNmQ5OTk=

data/.travis.yml

@@ -5,10 +5,15 @@ rvm:
   - 2.0.0
   - 1.9.3
   - 1.9.2
+  - jruby-head
 
 gemfile:
   - Gemfile
   
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+  
 # whitelist
 branches:  
   only:

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### 0.0.12 / 2014-08-24
+* [CHANGE] Significant internal refactoring.
+* [CHANGE] Method `ObjectSpace::id2ref` is no more used => one obstacle to JRuby porting is removed.
+* [NEW] Added new class `ProductionReference`
+
 ### 0.0.11 / 2014-08-24
 * [FIX] `SequiturGrammar#check_unicity`: an exception was raised when it shouldn't. Added example in spec file.
 * [CHANGE] `sequitur.rb` : Added the convenience Sequitur::build_from method.

data/README.md

@@ -20,8 +20,8 @@ It detects repeated token patterns and can represent them in a compact way.
 ```ruby  
 
     require 'sequitur' # Load the Sequitur library
-
-    input_sequence =  'abcabdab'
+    
+    input_sequence =  'abcabdab'  # Let's analyze this string
 
     # The SEQUITUR algorithm will detect the repeated 'ab' pattern
     # and will generate a context-free grammar that represents the input string
@@ -29,7 +29,7 @@ It detects repeated token patterns and can represent them in a compact way.
 
     # Display the grammar rules
     # Each rule is displayed with the format:
-    # rule_id : a_sequence_grammar_symbols
+    # rule_id : a_sequence_of_grammar_symbols
     # Where: 
     # - rule_id is the object id of a rule (in decimal)
     # - a grammar symbol is either a terminal symbol 

data/lib/sequitur/constants.rb

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

data/lib/sequitur/digram.rb

@@ -10,12 +10,12 @@ class Digram
   # The sequence of two consecutive grammar symbols.
   attr_reader(:symbols)
   
-  # The object id of the production that contains this digram in its rhs.
-  attr_reader(:production_id)
-  
   # An unique Hash key of the digram
   attr_reader(:key)
   
+  # The production in which the digram occurs
+  attr_reader(:production)
+  
   # Constructor.
   # @param symbol1 [StringOrSymbol] First element of the digram
   # @param symbol2 [StringOrSymbol] Second element of the digram
@@ -24,13 +24,15 @@ class Digram
   def initialize(symbol1, symbol2, aProduction)
     @symbols = [symbol1, symbol2]
     @key = "#{symbol1.hash.to_s(16)}:#{symbol2.hash.to_s(16)}" 
-    @production_id = aProduction.object_id
+    @production = aProduction
   end
-
-  # Return the production object of this digram
-  def production()
-    ObjectSpace._id2ref(production_id)
+  
+  # Equality testing.
+  # Returns true when keys of both digrams are equal
+  def ==(other)
+    return key == other.key
   end
+  
 end # class
 
 end # module

data/lib/sequitur/dynamic_grammar.rb

@@ -47,11 +47,9 @@ class DynamicGrammar
     puts to_string if trace
     prod = productions.delete_at(anIndex)
     # TODO: remove output
-    puts prod.to_string if trace
+    puts('Removed: ' + prod.to_string) if trace
     prod.clear_rhs
 
-    check_backrefs  # TODO: configurable check
-
     return prod
   end
 
@@ -68,57 +66,20 @@ class DynamicGrammar
   end
 
 
-  # Check that any production reference in rhs is
+  # Check that every production reference in rhs is
   # pointing to a production of the grammar
   def check_rhs_of(aProduction)
     aProduction.references.each do |symb|
-      next if productions.include?(symb)
+      referenced_prod = symb.production
+      next if productions.include?(referenced_prod)
 
-      msg = "Production #{aProduction.object_id} refers to "
-      msg << "production #{symb.object_id}"
+      msg = "Production #{aProduction.object_id} refers to"
+      msg << " production #{referenced_prod.object_id}"
       msg << ' that is not part of the grammar.'
       fail StandardError, msg
     end
   end
 
-  # Check the invariants:
-  # Every back reference must must point to a production of the grammar
-  # Every back reference count must be equal to the number
-  # of occurrences in the referencing production.
-  def check_backrefs()
-    return if productions.size < 2
-
-    all_but_root = productions[1...productions.size]
-    all_but_root.each do |a_prod|
-      a_prod.backrefs.each do |other_prod_id, count|
-        begin
-          other_prod = ObjectSpace._id2ref(other_prod_id)
-        rescue RangeError => exc
-          msg = "Production #{a_prod.object_id} has a backref to "
-          msg << "recycled production #{other_prod_id}."
-          msg << "\n#{to_string}"
-          $stderr.puts msg
-          raise exc
-        end
-        found = productions.find { |elem| elem == other_prod }
-        unless found
-          msg = "Production #{a_prod.object_id} is referenced by the "
-          msg << "unknown production (#{other_prod_id})."
-          msg << "\n#{to_string}"
-          fail StandardError, msg
-        end
-
-        unless count == found.rhs.count { |symb| symb == a_prod }
-          msg = "Production #{a_prod.object_id} has a count mismatch"
-          msg << "\nIt expects #{count} references in rhs of #{other_prod_id} "
-          msg << "but actual count is #{other_prod.rhs.count}."
-          msg << "\n#{to_string}"
-          fail StandardError, msg
-        end
-      end
-    end
-  end
-
 end # class
 
 end # module

data/lib/sequitur/production.rb

@@ -1,4 +1,5 @@
 require_relative 'digram'
+require_relative 'production_ref'
 
 module Sequitur # Module for classes implementing the Sequitur algorithm
 
@@ -14,33 +15,76 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
 class Production
   # The right-hand side (rhs) consists of a sequence of grammar symbols
   attr_reader(:rhs)
+  
+  # The reference count (= how times other productions reference this one)
+  attr_reader(:refcount)
 
-  # A Hash with pairs of the form:
-  # production id => reference count
-  # Where the reference count is the number of times this production
-  # appears in the rhs of the production with given id.
-  attr_reader(:backrefs)
+  # The sequence of digrams appearing in the RHS
+  attr_reader(:digrams)
 
   # Constructor. Build a production with an empty RHS.
   def initialize()
     clear_rhs
-    @backrefs = {}
+    @refcount = 0
+    @digrams = []
   end
 
   public
 
+  def ==(other)
+    return true if object_id == other.object_id
+
+    if other.is_a?(ProductionRef)
+      result = (other == self)
+    else
+      result = false
+    end
+
+    return result
+  end
+
+
   # Is the rhs empty?
   def empty?
     return rhs.empty?
   end
 
+  def incr_refcount()
+    @refcount += 1
+  end
+
+  def decr_refcount()
+    fail StandardError if @refcount == 0
+    @refcount -= 1
+  end
+
 
   # Return the set of productions appearing in the rhs.
   def references()
-    return rhs.select { |symb| symb.kind_of?(Production) }
+    return rhs.select { |symb| symb.is_a?(ProductionRef) }
+  end
+
+  # Return the set of references to a given production
+  def references_of(aProduction)
+    refs = references
+    return refs.select { |a_ref| a_ref == aProduction }
+  end
+
+
+
+
+  # Return the list digrams found in rhs of this production.
+  def recalc_digrams()
+    return [] if rhs.size < 2
+
+    result = []
+    rhs.each_cons(2) { |couple| result << Digram.new(*couple, self) }
+
+    @digrams = result
   end
 
 
+
   # Does the rhs have exactly one digram only (= 2 symbols)?
   def single_digram?
     return rhs.size == 2
@@ -59,53 +103,14 @@ class Production
     same_key_found = all_keys.index(last_key)
     return !same_key_found.nil?
   end
-  
+
   # Return the last digram appearing in the RHS.
   def last_digram()
-    return nil if rhs.size < 2
-    
-    return Digram.new(rhs[-2], rhs[-1], self)
-  end
-
-
-
-  # The back reference count is the number of times this production
-  # appears in the rhs of all the productions of the grammar
-  def refcount()
-    total = backrefs.values.reduce(0) do |sub_result, count|
-      sub_result += count
-    end
-
-    return total
-  end
-
-  # Add a back reference to the given production.
-  # @param aProduction [Production] Assume that production P appears in the 
-  #   RHS of production Q, then a reference count of P is incremented in Q.
-  def add_backref(aProduction)
-    prod_id = aProduction.object_id
-
-    count = backrefs.fetch(prod_id, 0)
-    backrefs[prod_id] = count + 1
-    return count
+    result = digrams.empty? ? nil : digrams.last
+    return result
   end
 
-  # Decrement the reference count for the given production.
-  # If result is zero, then the entry is removed from the Hash.
-  def remove_backref(aProduction)
-    prod_id = aProduction.object_id
-
-    count = backrefs.fetch(prod_id)
-    fail StandardError if count < 1
-
-    if count > 1
-      backrefs[prod_id] = count - 1
-    else
-      backrefs.delete(prod_id)
-    end
 
-    return count
-  end
 
   # Emit a text representation of the production rule.
   # Text is of the form:
@@ -122,17 +127,24 @@ class Production
     return "#{object_id} : #{rhs_text.join(' ')}."
   end
 
-  # Return the digrams for this production as if
-  # the given symbol is appended at the end of the rhs
-  def calc_append_symbol(aSymbol)
-    return [] if empty?
-
-    return digrams + [ Digram.new(rhs.last, aSymbol, self) ]
-  end
-
+  # Add a (grammar) symbol at the end of the RHS.
   def append_symbol(aSymbol)
-    aSymbol.add_backref(self) if aSymbol.kind_of?(Production)
-    rhs << aSymbol
+    case aSymbol
+      when Production
+        new_symb = ProductionRef.new(aSymbol)
+      when ProductionRef
+        if aSymbol.unbound?
+          msg = 'Fail to append reference to nil production in '
+          msg << to_string
+          fail StandardError, msg
+        end
+        new_symb = aSymbol.dup       
+      else
+        new_symb = aSymbol
+    end
+    
+    rhs << new_symb
+    digrams << Digram.new(rhs[-2], rhs[-1], self) if rhs.size >= 2
   end
 
   # Clear the right-hand side.
@@ -140,61 +152,77 @@ class Production
   def clear_rhs()
     if rhs
       refs = references
-      refs.each { |a_ref| a_ref.remove_backref(self) }
+      refs.each { |a_ref| a_ref.unbind }
     end
     @rhs = []
   end
 
-  # Return the list digrams found in rhs of this production.
-  def digrams()
-    return [] if rhs.size < 2
-
-    result = []
-    rhs.each_cons(2) { |couple| result << Digram.new(*couple, self) }
-
-    return result
-  end
+  # Find all the positions where the digram occurs in the rhs
+  # Synopsis:
+  # Given the production p -> a b c a b a b d
+  # Then p.positions_of(a, b) should returns [0, 3, 5]
+  # Caution: "overlapping" digrams shouldn't be counted
+  # Given the production p -> a a b a a a c d
+  # Then p.positions_of(a, a) should returns [0, 3]
+  def positions_of(symb1, symb2)
 
-  # Substitute in self all occurence of the digram that
-  # appears in the rhs of the other production
-  # Pre-condition:
-  # another has a rhs with exactly one digram (= a two-symbol sequence).
-  def replace_digram(another)
     # Find the positions where the digram occur in rhs
-    (symb1, symb2) = another.rhs
     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)
     end
+
     indices.shift
 
-    pos = indices.reverse
+    return indices
+  end
+
+
+  # Substitute in self all occurrences of the digram that
+  # appears in the rhs of the other production
+  # Pre-condition:
+  # another has a rhs with exactly one digram (= a two-symbol sequence).
+  def replace_digram(another)
+    (symb1, symb2) = another.rhs
+    pos = positions_of(symb1, symb2).reverse
 
     # Replace the two symbol sequence by the production
     pos.each do |index|
-      rhs[index].remove_backref(self) if rhs[index].kind_of?(Production)
-      rhs[index] = another
+      if rhs[index].is_a?(ProductionRef)
+        rhs[index].bind_to(another)
+      else
+        rhs[index] = ProductionRef.new(another)
+      end
       index1 = index + 1
-      rhs[index1].remove_backref(self) if rhs[index1].kind_of?(Production)
+      rhs[index1].unbind if rhs[index1].is_a?(ProductionRef)
       rhs.delete_at(index1)
-      another.add_backref(self)
     end
+    
+    recalc_digrams
   end
 
   # Replace every occurrence of 'another' production in rhs by
   # the rhs of 'another'.
+  # Given the production p_A -> a p_B b p_B c
+  # And the production p_B -> x y
+  # Then the call p_A.replace_production(p_B)
+  # Modifies p_A as into:
+  # p_A -> a x y b x y c
   def replace_production(another)
     (0...rhs.size).to_a.reverse.each do |index|
       next unless rhs[index] == another
-      rhs.insert(index + 1, *another.rhs)
-      another.rhs.each do |new_symb|
-        new_symb.add_backref(self) if new_symb.kind_of?(Production)
+      
+      # Avoid the aliasing of production reference
+      other_rhs = another.rhs.map do |symb| 
+        symb.is_a?(ProductionRef) ? symb.dup : symb
       end
-      another.remove_backref(self)
+      rhs.insert(index + 1, *other_rhs)
+      another.decr_refcount
       rhs.delete_at(index)
     end
+    
+    recalc_digrams
   end
 
 end # class

data/lib/sequitur/production_ref.rb

@@ -0,0 +1,89 @@
+
+
+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
+class ProductionRef
+
+  # Link to the production to reference
+  attr_reader(:production)
+
+  # Constructor
+  # [target] The production that is being referenced.
+  def initialize(target)
+    bind_to(target)
+  end
+  
+  # Copy constructor invoked by dup or clone methods
+  def initialize_copy(orig)
+    @production = nil
+    bind_to(orig.production)
+  end
+
+  # Return the text representation of a production reference.
+  def to_s()
+    return "#{production.object_id}"
+  end
+
+  alias_method :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.
+  def ==(other)
+    return true if object_id == other.object_id
+
+    if other.is_a?(ProductionRef)
+      result = (production == other.production)
+    else
+      result = (production == other)
+    end
+
+    return result
+  end
+
+  # Generates a Fixnum value as hash value.
+  # As a reference has no identity on its own,
+  # the method returns the hash value of the
+  # referenced production
+  def hash()
+    fail StandardError, 'Nil production' if production.nil?
+    return production.hash
+  end
+  
+  # Make this reference points to the given production
+  def bind_to(aProduction)
+    return if aProduction == @production
+    
+    production.decr_refcount if production
+    unless aProduction.kind_of?(Production)
+      fail 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.
+  def unbound?()
+    return production.nil?
+  end
+
+end # class
+
+end # module
+
+# End of file

data/lib/sequitur/sequitur_grammar.rb

@@ -13,7 +13,7 @@ class SequiturGrammar < DynamicGrammar
   def initialize(anEnum)
     super()
     # Make start production compliant with utility rule
-    2.times { root.add_backref(root) }
+    2.times { root.incr_refcount }
 
     @digrams = {}
     @parsed = []
@@ -34,14 +34,15 @@ class SequiturGrammar < DynamicGrammar
     all_digrams = {}
     productions.each do |a_prod|
       prod_digrams = a_prod.digrams
-      prod_digrams.each do |a_digram|
+      prod_digrams.each_with_index do |a_digram, index|
+        next if index && a_digram == a_prod.digrams[index - 1]
         if all_digrams.include? a_digram.key
           msg = "Digram #{a_digram.symbols} occurs twice!"
           colliding = all_digrams[a_digram.key]
-          msg << "\nOnce in production #{colliding.production_id}"
+          msg << "\nOnce in production #{colliding.production.object_id}"
           msg << "\nSecond in production #{a_prod.object_id}"
           msg << "\n#{to_string}"
-          fail StandardError, msg unless colliding.production_id == a_prod.object_id
+          fail StandardError, msg unless colliding == a_prod
         else
           all_digrams[a_digram.key] = a_digram
         end
@@ -55,8 +56,8 @@ class SequiturGrammar < DynamicGrammar
   # Assumption: last digram of production isn't yet registered.
   def add_production(aProduction)
     super # Call original method from superclass...
-    
-    # ... then add this behaviour 
+
+    # ... then add this behaviour
     last_digram = aProduction.last_digram
     digrams[last_digram.key] = last_digram
   end
@@ -67,7 +68,7 @@ class SequiturGrammar < DynamicGrammar
 
     # Retrieve in the Hash all registered digrams from the removed production
     digrams_subset = digrams.select do |_, digr|
-      digr.production_id == prod.object_id
+      digr.production == prod
     end
 
     # Remove them...
@@ -76,10 +77,10 @@ class SequiturGrammar < DynamicGrammar
   end
 
   def append_symbol_to(aProduction, aSymbol)
-    prod_digrams = aProduction.calc_append_symbol(aSymbol)
     check_digrams # TODO: remove this
-    check_backrefs # TODO: remove this
     super
+
+    prod_digrams = aProduction.digrams
     unless prod_digrams.empty?
       last_digram = prod_digrams.last
       matching_digram = digrams[last_digram.key]
@@ -105,32 +106,19 @@ class SequiturGrammar < DynamicGrammar
   def preserve_unicity(aProduction)
     last_digram = aProduction.last_digram
     matching_digram = digrams[last_digram.key]
-    if last_digram.production_id == matching_digram.production_id
+    if aProduction == matching_digram.production
       # Rule: no other production distinct from aProduction should have
       # the matching digram
       productions.each do |prod|
         its_digrams = prod.digrams
         its_keys = its_digrams.map(&:key)
-        if prod.object_id == last_digram.production_id
-          # TODO: check that digram really occurs twice in the production.
-          # occurrences = its_keys.select { |a_key| a_key == last_digram.key }
-          # if occurrences.size != 2
-          #   msg = "Digram #{last_digram.symbols} should occur twice"
-          #   msg << "\nin production #{aProduction.object_id}"
-          #   msg << "\nBut occurs #{occurrences.size}"
-          #   msg << "\n#{self.to_string}"
-          #   fail StandardError, msg
-          # end
-
-        else
-          if its_keys.include? last_digram.key
-            msg = "Digram #{last_digram.symbols} occurs three times!"
-            msg << "\nTwice in production #{aProduction.object_id}"
-            msg << "\nThird in production #{prod.object_id}"
-            msg << "\n#{to_string}"
-            fail StandardError, msg
-          end
-        end
+        next if prod == last_digram.production
+        next unless its_keys.include? last_digram.key
+        msg = "Digram #{last_digram.symbols} occurs three times!"
+        msg << "\nTwice in production #{aProduction.object_id}"
+        msg << "\nThird in production #{prod.object_id}"
+        msg << "\n#{to_string}"
+        fail StandardError, msg
       end
 
       # Digram appears twice in given production...
@@ -148,17 +136,18 @@ class SequiturGrammar < DynamicGrammar
     else
       # Duplicate digram used in distinct production
       # Two cases: other production is a single digram one or a multi-digram
-      other_prod = ObjectSpace._id2ref(matching_digram.production_id)
+      other_prod = matching_digram.production
       if other_prod.single_digram?
         # ... replace duplicate digram by reference to other production
         aProduction.replace_digram(other_prod)
         update_digrams_from(aProduction)
 
-        # Special case a: replacement causes another digram duplication 
+        # Special case a: replacement causes another digram duplication
         #   in the given production
-        # Special case b: replacement causes another digram duplication 
+        # Special case b: replacement causes another digram duplication
         #   with other production
-        if aProduction.repeated_digram? || digrams[aProduction.last_digram.key]
+        if aProduction.repeated_digram? ||
+          (digrams[aProduction.last_digram.key].production != aProduction)
           preserve_unicity(aProduction)
         end
 
@@ -178,7 +167,6 @@ class SequiturGrammar < DynamicGrammar
 
         # TODO: Check when aProduction and other_prod have same preceding symbol
         update_digrams_from(other_prod)
-        check_backrefs # TODO: remove this
       end
       check_unicity
     end
@@ -205,16 +193,17 @@ class SequiturGrammar < DynamicGrammar
     loop do
       all_refcount_ok = true
       (1...productions.size).to_a.reverse.each do |index|
-        next unless productions[index].refcount == 1
+        curr_production = productions[index]
+        next unless curr_production.refcount == 1
 
         all_refcount_ok = false
-        other_id = productions[index].backrefs.keys.first
-        dependent = ObjectSpace._id2ref(other_id)
+        dependent = productions.find do |a_prod|
+          !a_prod.references_of(curr_production).empty?
+        end
         dependent.replace_production(productions[index])
         delete_production(index)
         update_digrams_from(dependent)
         check_references
-        check_backrefs
       end
 
       break if all_refcount_ok
@@ -226,14 +215,14 @@ class SequiturGrammar < DynamicGrammar
   def update_digrams_from(aProduction)
     current_digrams = aProduction.digrams
 
-    # Add new digrams
+    # Add new digrams only if they don't collide
     current_digrams.each do |digr|
       digrams[digr.key] = digr unless digrams.include? digr.key
     end
 
     # Retrieve all registered digrams from the production
     digrams_subset = digrams.select do |_, digr|
-      digr.production_id == aProduction.object_id
+      digr.production == aProduction
     end
 
     # Remove obsolete digrams
@@ -244,16 +233,18 @@ class SequiturGrammar < DynamicGrammar
   end
 
   # Check the invariant:
-  # Every production reference in a rhs must point
+  # Every reference in a rhs that is bound must point
   # to a production of the grammar.
   def check_references()
     productions.each do |a_prod|
       rhs_prods = a_prod.references
-      rhs_prods.each do |referenced_prod|
+      rhs_prods.each do |a_reference|
+        next if a_reference.unbound?
+        referenced_prod = a_reference.production
         next if productions.include? referenced_prod
 
-        msg = "Production #{a_prod.object_id} references the "
-        msg << "unknown production #{referenced_prod.object_id}"
+        msg = "Production #{a_prod.object_id} #{a_prod.to_string}"
+        msg << " references the unknown production #{referenced_prod.object_id}"
         msg << "\nOrphan production: #{referenced_prod.to_string}"
         msg << "\n#{to_string}"
         fail StandardError, msg
@@ -265,13 +256,11 @@ class SequiturGrammar < DynamicGrammar
   # Every registered digram must reference a production from the grammar
   def check_registered()
     digrams.each do |_key, digr|
-      found = productions.find do |a_prod|
-        digr.production_id == a_prod.object_id
-      end
+      found = productions.find { |a_prod| digr.production == a_prod }
       next if found
 
       msg = "Digram #{digr.symbols} references the unknown "
-      msg << "production (#{digr.production_id})."
+      msg << "production (#{digr.production.object_id})."
       msg << "\n#{to_string}"
       fail StandardError, msg
     end
@@ -283,7 +272,7 @@ class SequiturGrammar < DynamicGrammar
     # Control that every registered digram refers
     # to a production that really has that digram
     digrams.each do |key, digr|
-      its_prod = ObjectSpace._id2ref(digr.production_id)
+      its_prod = digr.production
       prod_digrams = its_prod.digrams
       prod_keys = prod_digrams.map(&:key)
       next if prod_keys.include? key
@@ -307,15 +296,15 @@ class SequiturGrammar < DynamicGrammar
     all_digrams.each do |key, digr|
       registered = digrams[key]
       if registered
-        if registered.production_id != digr.production_id
-          msg = "Production #{digr.production_id} has "
+        if registered != digr
+          msg = "Production #{digr.production.object_id} has "
           msg << "the digram #{digr.symbols} that collides"
-          msg << "\n with same digram from #{registered.production_id}"
+          msg << "\n with same digram from #{registered.production.object_id}"
           msg << "\n#{to_string}"
           fail StandardError, msg
         end
       else
-        its_prod = ObjectSpace._id2ref(digr.production_id)
+        its_prod = digr.production
         msg = "Production #{its_prod.object_id} (#{its_prod.rhs}) "
         msg << "has the digram #{digr.symbols} that isn't registered."
         msg << "\n#{to_string}"

data/spec/sequitur/digram_spec.rb

@@ -7,24 +7,39 @@ module Sequitur # Re-open the module to get rid of qualified names
 
 describe Digram do
   let(:two_symbols) { [:b, :c] }
+  let(:production) { double('sample-production') }
 
   context 'Standard creation & initialization:' do
   
     it 'should be created with 3 arguments' do
-      production = double('sample-production')
       instance = Digram.new(:b, :c, production)
       
       expect(instance.symbols).to eq(two_symbols)
-      expect(instance.production_id).to eq(production.object_id)
+      expect(instance.production).to eq(production)
     end
     
     it 'should return the production that it refers to' do
-      production = double('sample-production')
       instance = Digram.new(:b, :c, production)
       expect(instance.production).to eq(production)
     end
 
-  end # context 
+  end # context
+
+  context 'Standard creation & initialization:' 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)
+      
+      expect(instance1).to eq(instance1)
+      expect(instance1).to eq(same)
+      expect(instance1).not_to eq(different)
+      expect(same).not_to eq(different)       
+    end
+  
+  end # context
+  
 
 end # describe
 

data/spec/sequitur/production_ref_spec.rb

@@ -0,0 +1,95 @@
+require_relative '../spec_helper'
+
+# Load the class under test
+require_relative '../../lib/sequitur/production'
+require_relative '../../lib/sequitur/production_ref'
+
+module Sequitur # Re-open the module to get rid of qualified names
+
+describe ProductionRef do
+ 
+  let(:target) { Production.new }
+  let(:another_target) { Production.new }
+  
+  subject { ProductionRef.new(target) }
+
+  context 'Creation & initialization:' do
+
+    it 'should be created with a production argument' do 
+      expect { ProductionRef.new(target) }.not_to raise_error
+      expect(target.refcount).to eq(1)
+    end
+    
+    it 'should clone with reference count incrementing' do
+      expect(target.refcount).to eq(0)
+      expect(subject.production.refcount).to eq(1)
+      klone = subject.clone
+      expect(klone.production.refcount).to eq(2)
+      duplicate = subject.dup
+      expect(duplicate.production.refcount).to eq(3)
+    end
+    
+    it 'should know its referenced production' do   
+      instance = ProductionRef.new(target)
+      expect(instance.production).to eq(target)
+    end
+    
+    
+  end # context
+  
+  context 'Provided services:' do 
+    
+    it 'should render its referenced production' do
+      expect(subject.to_s).to eq(target.object_id.to_s)
+    end
+    
+    it 'should unbind itself from its production' do
+      expect(target.refcount).to eq(0)
+      expect(subject).not_to be_unbound
+      expect(target.refcount).to eq(1)
+      subject.unbind
+      expect(target.refcount).to eq(0)
+      expect(subject.production).to be_nil
+      expect(subject).to be_unbound
+    end
+    
+    it 'should bind to a production' do
+      expect(target.refcount).to eq(0)
+      
+      expect(subject).not_to be_unbound
+      expect(target.refcount).to eq(1)
+      
+      # Case: bind again to same production
+      expect { subject.bind_to(target) }.not_to raise_error
+      expect(target.refcount).to eq(1)
+
+      # Case: bind to another production
+      expect(another_target.refcount).to eq(0)
+      subject.bind_to(another_target)
+      expect(target.refcount).to eq(0)      
+      expect(another_target.refcount).to eq(1)
+    end
+  
+    it 'should compare to other production (reference)' do
+      same = ProductionRef.new(target)
+      expect(subject).to eq(subject)  # Strict identity
+      expect(subject).to eq(same)   # 2 references pointing to same production
+      expect(subject).to eq(target)
+    end
+    
+    it 'should return the hash value of its production' do
+      expectation = target.hash
+      expect(subject.hash).to eq(expectation)
+    end
+    
+    it 'should complain when requested for a hash and unbound' do
+      subject.unbind
+      expect { subject.hash }.to raise_error(StandardError)
+    end
+  end
+
+end # describe
+
+end # module
+
+# End of file

data/spec/sequitur/production_spec.rb

@@ -43,33 +43,52 @@ describe Production do
       expect(subject.last_digram).to be_nil
     end
   end # context
-  
+
   context 'Knowing its rhs:' do
-    
+
     it 'should know the productions in its rhs' do
       # Case 1: empty production
       expect(subject.references).to be_empty
-      
+
       # Case 2: production without references
       symbols = [:a, :b, :c]
       symbols.each { |symb| subject.append_symbol(symb) }
       expect(subject.references).to be_empty
+      expect(subject.references_of(p_a)).to be_empty
 
       # 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])
 
       # 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).to eq([p_a, p_a])
+      expect(subject.references_of(p_a)).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).to eq([p_a, p_a, p_bc])
+      expect(subject.references_of(p_bc)).to eq([p_bc])
     end
-  
+
+    it 'should know the position(s) of a given digram' do
+      sequence1 = [:a, :b, :c, :a, :b, :a, :b, :d]
+      sequence1.each { |symb| subject.append_symbol(symb) }
+      positions = [0, 3, 5]
+      expect(subject.positions_of(:a, :b)).to eq(positions)
+
+      subject.clear_rhs
+      # Case of overlapping digrams
+      sequence2 = [:a, :a, :b, :a, :a, :a, :c, :d]
+      sequence2.each { |symb| subject.append_symbol(symb) }
+      positions = [0, 3]
+      expect(subject.positions_of(:a, :a)).to eq(positions)
+    end
+
   end # context
-  
+
   context 'Appending a symbol:' do
 
     it 'should append a symbol when empty' do
@@ -92,31 +111,48 @@ describe Production do
       expect(subject.last_digram.symbols).to eq([:e, :f])
     end
 
-    it 'should increment the refcount for each production in the rhs' do
+    it 'should append a production in its rhs' do
+      # Side-effect: refcount of production to append is incremented
       expect(p_a.refcount).to be(0)
 
       input = [p_a, :b, :c, :d, p_a, :e, :f]  # p_a appears twice
       input.each { |symb| subject.append_symbol(symb) }
       expect(p_a.refcount).to be(2)
     end
-
-    it 'should calculate the digrams before appending:' do
-      # Case: empty production
-      expect(subject.calc_append_symbol(:a)).to be_empty
-
-      # Case: single-symbol rhs
-      subject.append_symbol(:a)
-      expect(to_symbols(subject.calc_append_symbol(:b))).to eq([[:a, :b]])
-
-      # Case: two-symbols rhs
-      subject.append_symbol(:b)
-      expectation = [[:a, :b], [:b, :c]]
-      expect(to_symbols(subject.calc_append_symbol(:c))).to eq(expectation)
+    
+    it 'should append a production ref in its rhs' do
+      # Side-effect: refcount of production to append is incremented
+      ref_a = ProductionRef.new(p_a)
+      expect(p_a.refcount).to be(1)
+      
+      input = [ref_a, :b, :c, :d, ref_a]  # ref_a appears twice
+      input.each { |symb| subject.append_symbol(symb) }
+      
+      # References in rhs should point to p_a...
+      # ...but should be distinct reference objects
+      expect(subject.rhs[0]).to eq(p_a)
+      expect(subject.rhs[0].object_id).not_to eq(ref_a.object_id)
+      expect(subject.rhs[-1]).to eq(p_a)
+      expect(subject.rhs[-1].object_id).not_to eq(ref_a.object_id)
+      
+      # Reference count should be updated
+      expect(p_a.refcount).to be(3)
+    end
+    
+    it 'should complain when appending ref to nil production' do
+      # Side-effect: refcount of production to append is incremented
+      ref_a = ProductionRef.new(p_a)
+      expect(p_a.refcount).to be(1)
+      
+      # Unbind the reference
+      ref_a.unbind
+      
+      expect { subject.append_symbol(ref_a) }.to raise_error(StandardError)
     end
 
   end # context
-  
-  
+
+
   context 'Text representation of a production rule:' do
 
     it 'should emit minimal text when empty' do
@@ -128,7 +164,8 @@ describe Production do
       instance = Production.new
       symbols = [:a, :b, 'c', :d, :e, 1000, instance]
       symbols.each { |symb| subject.append_symbol(symb) }
-      expectation = "#{subject.object_id} : a b 'c' d e 1000 #{instance.object_id}."
+      expectation = "#{subject.object_id} : " 
+      expectation << "a b 'c' d e 1000 #{instance.object_id}."
       expect(subject.to_string).to eq(expectation)
     end
 
@@ -138,19 +175,19 @@ describe Production do
     it 'should report no repetition when empty' do
       expect(subject.repeated_digram?).to be_falsey
     end
-    
+
     it 'should report no repetition when rhs has less than 3 symbols' do
       subject.append_symbol(:a)
       expect(subject.repeated_digram?).to be_falsey
-      
+
       subject.append_symbol(:a)
-      expect(subject.repeated_digram?).to be_falsey      
+      expect(subject.repeated_digram?).to be_falsey
     end
-    
+
     it 'should detect shortest repetition' do
       'aaa'.each_char { |symb| subject.append_symbol(symb) }
-      expect(subject.repeated_digram?).to be_truthy      
-    end 
+      expect(subject.repeated_digram?).to be_truthy
+    end
 
     it 'should detect any repetition pattern' do
       # Positive cases
@@ -160,15 +197,15 @@ describe Production do
         word.each_char { |symb| instance.append_symbol(symb) }
         expect(instance.repeated_digram?).to be_truthy
       end
-      
+
       # Negative cases
       cases = %w(abc abb abba abcdef)
       cases.each do |word|
         instance = Production.new
         word.each_char { |symb| instance.append_symbol(symb) }
         expect(instance.repeated_digram?).to be_falsey
-      end      
-    end   
+      end
+    end
   end # context
 
   context 'Replacing a digram by a production:' do
@@ -182,12 +219,13 @@ describe Production do
 
     it 'should replace two-symbol sequence' do
       %w(a b c d e b c e).each { |symb| subject.append_symbol(symb) }
+      p_bc_before = p_bc.to_string
       subject.replace_digram(p_bc)
 
       expect(subject.rhs.size).to eq(6)
       expect(subject.rhs).to eq(['a', p_bc, 'd', 'e', p_bc, 'e'])
       expect(p_bc.refcount).to eq(2)
-      expect(p_bc.backrefs[subject.object_id]).to eq(2)
+      expect(p_bc.to_string).to eq(p_bc_before)
     end
 
 
@@ -198,7 +236,6 @@ describe Production do
       expect(subject.rhs.size).to eq(5)
       expect(subject.rhs).to eq([p_bc, 'd', 'e', p_bc, 'e'])
       expect(p_bc.refcount).to eq(2)
-      expect(p_bc.backrefs[subject.object_id]).to eq(2)
     end
 
 
@@ -209,7 +246,6 @@ describe Production do
       expect(subject.rhs.size).to eq(5)
       expect(subject.rhs).to eq(['a', p_bc, 'd', 'e', p_bc])
       expect(p_bc.refcount).to eq(2)
-      expect(p_bc.backrefs[subject.object_id]).to eq(2)
     end
 
     it 'should replace two consecutive two-symbol sequences' do
@@ -219,7 +255,6 @@ describe Production do
       expect(subject.rhs.size).to eq(4)
       expect(subject.rhs).to eq(['a', p_bc, p_bc, 'd'])
       expect(p_bc.refcount).to eq(2)
-      expect(p_bc.backrefs[subject.object_id]).to eq(2)
     end
 
   end # context
@@ -233,18 +268,23 @@ describe Production do
 
     it 'should replace a production at the start' do
       [p_bc, 'd'].each { |symb| subject.append_symbol(symb) }
+      expect(p_bc.refcount).to eq(1)
+      
       subject.replace_production(p_bc)
       expect(subject.rhs.size).to eq(3)
       expect(subject.rhs).to eq(%w(b c d))
+      expect(p_bc.refcount).to eq(0)
     end
 
 
     it 'should replace a production at the end' do
       ['d', p_bc].each { |symb| subject.append_symbol(symb) }
+      expect(p_bc.refcount).to eq(1)
       subject.replace_production(p_bc)
 
       expect(subject.rhs.size).to eq(3)
       expect(subject.rhs).to eq(%w(d b c))
+      expect(p_bc.refcount).to eq(0)
     end
 
     it 'should replace a production as sole symbol' do

data/spec/sequitur/sequitur_grammar_spec.rb

@@ -79,7 +79,7 @@ describe SequiturGrammar do
       input = 'aaac'  # This sequence raised an exception
 
       # Creation
-      expect {SequiturGrammar.new(input.chars)}.not_to raise_error
+      expect { SequiturGrammar.new(input.chars) }.not_to raise_error
     end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-26 00:00:00.000000000 Z
+date: 2014-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -90,9 +90,11 @@ files:
 - lib/sequitur/digram.rb
 - lib/sequitur/dynamic_grammar.rb
 - lib/sequitur/production.rb
+- lib/sequitur/production_ref.rb
 - lib/sequitur/sequitur_grammar.rb
 - spec/sequitur/digram_spec.rb
 - spec/sequitur/dynamic_grammar_spec.rb
+- spec/sequitur/production_ref_spec.rb
 - spec/sequitur/production_spec.rb
 - spec/sequitur/sequitur_grammar_spec.rb
 - spec/spec_helper.rb
@@ -130,5 +132,6 @@ summary: Ruby implementation of the Sequitur algorithm
 test_files:
 - spec/sequitur/digram_spec.rb
 - spec/sequitur/dynamic_grammar_spec.rb
+- spec/sequitur/production_ref_spec.rb
 - spec/sequitur/production_spec.rb
 - spec/sequitur/sequitur_grammar_spec.rb