tdiff 0.1.0 → 0.2.0

data/ChangeLog.md

@@ -1,3 +1,7 @@
+### 0.2.0 / 2010-11-14
+
+* Added {TDiff::Unordered}.
+
 ### 0.1.0 / 2010-11-13
 
 * Initial release:

data/README.md

@@ -13,9 +13,10 @@ module.
 ## Features
 
 * Provides the {TDiff} mixin.
+* Provides the {TDiff::Unordered} mixin for unordered diffing.
 * Allows custom node equality and traversal logic by overriding the
   {TDiff#tdiff_equal} and {TDiff#tdiff_each_child} methods.
-* Implements the [Longest Common Subsequence (LCS)](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem).
+* Implements the [Longest Common Subsequence (LCS)](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem) algorithm.
 
 ## Examples
 

data/gemspec.yml

@@ -1,5 +1,5 @@
 name: tdiff
-version: 0.1.0
+version: 0.2.0
 summary: Calculates the differences between two tree-like structures.
 description:
   Calculates the differences between two tree-like structures. Similar to

data/lib/tdiff.rb

@@ -1,133 +1,2 @@
-#
-# {TDiff} adds the ability to calculate the differences between two tree-like
-# objects. Simply include {TDiff} into the class which represents the tree
-# nodes and define the {#tdiff_each_child} and {#tdiff_equal} methods.
-#
-module TDiff
-  #
-  # Default method which will enumerate over every child of a parent node.
-  #
-  # @param [Object] node
-  #   The parent node.
-  #
-  # @yield [child]
-  #   The given block will be passed each child of the parent node.
-  #
-  def tdiff_each_child(node,&block)
-    node.each(&block) if node.kind_of?(Enumerable)
-  end
-
-  #
-  # Default method which compares two nodes.
-  #
-  # @param [Object] original_node
-  #   A node from the original tree.
-  #
-  # @param [Object] new_node
-  #   A node from the new tree.
-  #
-  # @return [Boolean]
-  #   Specifies whether the two nodes are equal.
-  #
-  def tdiff_equal(original_node,new_node)
-    original_node == new_node
-  end
-
-  #
-  # Finds the differences between `self` and another tree.
-  #
-  # @param [#tdiff_each_child] tree
-  #   The other tree.
-  #
-  # @yield [change, node]
-  #   The given block will be passed the added or removed nodes.
-  #
-  # @yieldparam [' ', '+', '-'] change
-  #   The state-change of the node.
-  #
-  # @yieldparam [Object] node
-  #   A node from one of the two trees.
-  #
-  # @return [Enumerator]
-  #   If no block is given, an Enumerator object will be returned.
-  #
-  def tdiff(tree,&block)
-    return enum_for(:tdiff,tree) unless block
-
-    # check if the nodes differ
-    unless tdiff_equal(self,tree)
-      yield '-', self
-      yield '+', tree
-      return self
-    end
-
-    c = Hash.new { |hash,key| hash[key] = Hash.new(0) }
-    x = enum_for(:tdiff_each_child,self)
-    y = enum_for(:tdiff_each_child,tree)
-
-    x.each_with_index do |xi,i|
-      y.each_with_index do |yi,j|
-        c[i][j] = if tdiff_equal(xi,yi)
-                    c[i-1][j-1] + 1
-                  else
-                    if c[i][j-1] > c[i-1][j]
-                      c[i][j-1]
-                    else
-                      c[i-1][j]
-                    end
-                  end
-      end
-    end
-
-    unchanged = []
-    changes = []
-
-    x_backtrack = x.each_with_index.reverse_each
-    y_backtrack = y.each_with_index.reverse_each
-
-    next_child = lambda { |children|
-      begin
-        children.next
-      rescue StopIteration
-        # end of iteration, return a -1 index
-        [nil, -1]
-      end
-    }
-
-    xi, i = next_child[x_backtrack]
-    yi, j = next_child[y_backtrack]
-
-    until (i == -1 && j == -1)
-      if (i != -1 && j != -1 && tdiff_equal(xi,yi))
-        changes.unshift [' ', xi]
-        unchanged.unshift [xi, yi]
-
-        xi, i = next_child[x_backtrack]
-        yi, j = next_child[y_backtrack]
-      else
-        if (j >= 0 && (i == -1 || c[i][j-1] >= c[i-1][j]))
-          changes.unshift ['+', yi]
-
-          yi, j = next_child[y_backtrack]
-        elsif (i >= 0 && (j == -1 || c[i][j-1] < c[i-1][j]))
-          changes.unshift ['-', xi]
-
-          xi, i = next_child[x_backtrack]
-        end
-      end
-    end
-
-    # explicitly discard the c matrix
-    c = nil
-
-    # sequentially iterate over the changed nodes
-    changes.each(&block)
-    changes = nil
-
-    # recurse down through unchanged nodes
-    unchanged.each { |x,y| x.tdiff(y,&block) }
-    unchanged = nil
-
-    return self
-  end
-end
+require 'tdiff/tdiff'
+require 'tdiff/unordered'

data/lib/tdiff/tdiff.rb

@@ -0,0 +1,133 @@
+#
+# {TDiff} adds the ability to calculate the differences between two tree-like
+# objects. Simply include {TDiff} into the class which represents the tree
+# nodes and define the {#tdiff_each_child} and {#tdiff_equal} methods.
+#
+module TDiff
+  #
+  # Default method which will enumerate over every child of a parent node.
+  #
+  # @param [Object] node
+  #   The parent node.
+  #
+  # @yield [child]
+  #   The given block will be passed each child of the parent node.
+  #
+  def tdiff_each_child(node,&block)
+    node.each(&block) if node.kind_of?(Enumerable)
+  end
+
+  #
+  # Default method which compares two nodes.
+  #
+  # @param [Object] original_node
+  #   A node from the original tree.
+  #
+  # @param [Object] new_node
+  #   A node from the new tree.
+  #
+  # @return [Boolean]
+  #   Specifies whether the two nodes are equal.
+  #
+  def tdiff_equal(original_node,new_node)
+    original_node == new_node
+  end
+
+  #
+  # Finds the differences between `self` and another tree.
+  #
+  # @param [#tdiff_each_child] tree
+  #   The other tree.
+  #
+  # @yield [change, node]
+  #   The given block will be passed the added or removed nodes.
+  #
+  # @yieldparam [' ', '+', '-'] change
+  #   The state-change of the node.
+  #
+  # @yieldparam [Object] node
+  #   A node from one of the two trees.
+  #
+  # @return [Enumerator]
+  #   If no block is given, an Enumerator object will be returned.
+  #
+  def tdiff(tree,&block)
+    return enum_for(:tdiff,tree) unless block
+
+    # check if the nodes differ
+    unless tdiff_equal(self,tree)
+      yield '-', self
+      yield '+', tree
+      return self
+    end
+
+    c = Hash.new { |hash,key| hash[key] = Hash.new(0) }
+    x = enum_for(:tdiff_each_child,self)
+    y = enum_for(:tdiff_each_child,tree)
+
+    x.each_with_index do |xi,i|
+      y.each_with_index do |yj,j|
+        c[i][j] = if tdiff_equal(xi,yj)
+                    c[i-1][j-1] + 1
+                  else
+                    if c[i][j-1] > c[i-1][j]
+                      c[i][j-1]
+                    else
+                      c[i-1][j]
+                    end
+                  end
+      end
+    end
+
+    unchanged = []
+    changes = []
+
+    x_backtrack = x.each_with_index.reverse_each
+    y_backtrack = y.each_with_index.reverse_each
+
+    next_child = lambda { |children|
+      begin
+        children.next
+      rescue StopIteration
+        # end of iteration, return a -1 index
+        [nil, -1]
+      end
+    }
+
+    xi, i = next_child[x_backtrack]
+    yj, j = next_child[y_backtrack]
+
+    until (i == -1 && j == -1)
+      if (i != -1 && j != -1 && tdiff_equal(xi,yj))
+        changes.unshift [' ', xi]
+        unchanged.unshift [xi, yj]
+
+        xi, i = next_child[x_backtrack]
+        yj, j = next_child[y_backtrack]
+      else
+        if (j >= 0 && (i == -1 || c[i][j-1] >= c[i-1][j]))
+          changes.unshift ['+', yj]
+
+          yj, j = next_child[y_backtrack]
+        elsif (i >= 0 && (j == -1 || c[i][j-1] < c[i-1][j]))
+          changes.unshift ['-', xi]
+
+          xi, i = next_child[x_backtrack]
+        end
+      end
+    end
+
+    # explicitly discard the c matrix
+    c = nil
+
+    # sequentially iterate over the changed nodes
+    changes.each(&block)
+    changes = nil
+
+    # recurse down through unchanged nodes
+    unchanged.each { |x,y| x.tdiff(y,&block) }
+    unchanged = nil
+
+    return self
+  end
+end

data/lib/tdiff/unordered.rb

@@ -0,0 +1,88 @@
+require 'tdiff/tdiff'
+
+module TDiff
+  #
+  # Calculates the differences between two trees, without respecting the
+  # order of children nodes.
+  #
+  module Unordered
+    #
+    # Includes {TDiff}.
+    #
+    def self.included(base)
+      base.send :include, TDiff
+    end
+
+    #
+    # Finds the differences between `self` and another tree, not respecting
+    # the ordering of children.
+    #
+    # @param [#tdiff_each_child] tree
+    #   The other tree.
+    #
+    # @yield [change, node]
+    #   The given block will be passed the added or removed nodes.
+    #
+    # @yieldparam [' ', '+', '-'] change
+    #   The state-change of the node.
+    #
+    # @yieldparam [Object] node
+    #   A node from one of the two trees.
+    #
+    # @return [Enumerator]
+    #   If no block is given, an Enumerator object will be returned.
+    #
+    # @since 0.2.0
+    #
+    def tdiff_unordered(tree,&block)
+      return enum_for(:tdiff_unordered,tree) unless block
+
+      # check if the nodes differ
+      unless tdiff_equal(self,tree)
+        yield '-', self
+        yield '+', tree
+        return self
+      end
+
+      x = enum_for(:tdiff_each_child,self)
+      y = enum_for(:tdiff_each_child,tree)
+
+      unchanged = {}
+      changes = []
+
+      x.each_with_index do |xi,i|
+        y.each_with_index do |yj,j|
+          if (!unchanged.has_value?(yj) && tdiff_equal(xi,yj))
+            unchanged[xi] = yj
+            changes << [i, ' ', xi]
+            break
+          end
+        end
+
+        unless unchanged.has_key?(xi)
+          changes << [i, '-', xi]
+        end
+      end
+
+      y.each_with_index do |yj,j|
+        unless unchanged.has_key?(yj)
+          changes << [j, '+', yj]
+        end
+      end
+
+      # order the changes by index to match the behavior of `tdiff`
+      changes.sort_by { |change| change[0] }.each do |index,change,node|
+        yield change, node
+      end
+
+      # explicitly release the changes variable
+      changes = nil
+
+      # recurse down the unchanged nodes
+      unchanged.each { |xi,yj| xi.tdiff_unordered(yj,&block) }
+      unchanged = nil
+
+      return self
+    end
+  end
+end

data/spec/classes/node.rb

@@ -3,6 +3,7 @@ require 'tdiff'
 class Node < Struct.new(:name, :children)
 
   include TDiff
+  include TDiff::Unordered
 
   def tdiff_each_child(node,&block)
     node.children.each(&block)

data/spec/helpers/trees.rb

@@ -0,0 +1,61 @@
+require 'classes/node'
+
+module Helpers
+  module Trees
+    def self.included(base)
+      base.module_eval do
+        before(:all) do
+          @tree = Node.new('root', [
+                    Node.new('leaf1', [
+                      Node.new('subleaf1', []),
+                      Node.new('subleaf2', [])
+                    ]),
+
+                    Node.new('leaf2', [
+                      Node.new('subleaf1', []),
+                      Node.new('subleaf2', [])
+                    ])
+                  ])
+
+          @different_root = Node.new('wrong', [])
+
+          @added = Node.new('root', [
+                     Node.new('leaf1', [
+                       Node.new('subleaf1', []),
+                       Node.new('subleaf3', []),
+                       Node.new('subleaf2', [])
+                     ]),
+
+                     Node.new('leaf2', [
+                       Node.new('subleaf1', []),
+                       Node.new('subleaf2', [])
+                     ])
+                   ])
+
+          @removed = Node.new('root', [
+                       Node.new('leaf1', [
+                         Node.new('subleaf1', [])
+                       ]),
+
+                       Node.new('leaf2', [
+                         Node.new('subleaf1', []),
+                         Node.new('subleaf2', [])
+                       ])
+                     ])
+
+          @changed_order = Node.new('root', [
+                             Node.new('leaf2', [
+                               Node.new('subleaf1', []),
+                               Node.new('subleaf2', [])
+                             ]),
+
+                             Node.new('leaf1', [
+                               Node.new('subleaf1', []),
+                               Node.new('subleaf2', [])
+                             ])
+                           ])
+        end
+      end
+    end
+  end
+end

data/spec/tdiff_examples.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'helpers/trees'
+
+shared_examples_for 'TDiff' do |method|
+  include Helpers::Trees
+
+  it "should tell if two trees are identical" do
+    @tree.send(method,@tree).all? { |change,node|
+      change == ' '
+    }.should == true
+  end
+
+  it "should stop if the root nodes have changed" do
+    changes = @tree.send(method,@different_root).to_a
+
+    changes.length.should == 2
+
+    changes[0][0].should == '-'
+    changes[0][1].should == @tree
+
+    changes[1][0].should == '+'
+    changes[1][1].should == @different_root
+  end
+
+  it "should tell when sub-nodes are added" do
+    changes = @tree.tdiff(@added).select { |change,node| change == '+' }
+
+    changes.length.should == 1
+    changes[0][0].should == '+'
+    changes[0][1].should == @added.children[0].children[1]
+  end
+
+  it "should tell when sub-nodes are removed" do
+    changes = @tree.tdiff(@removed).select { |change,node| change == '-' }
+
+    changes.length.should == 1
+    changes[0][0].should == '-'
+    changes[0][1].should == @tree.children[0].children[1]
+  end
+end

data/spec/tdiff_spec.rb

@@ -1,93 +1,12 @@
 require 'spec_helper'
-require 'classes/node'
-require 'tdiff'
+require 'helpers/trees'
+require 'tdiff_examples'
+require 'tdiff/tdiff'
 
 describe TDiff do
-  before(:all) do
-    @tree = Node.new('root', [
-      Node.new('leaf1', [
-        Node.new('subleaf1', []),
-        Node.new('subleaf2', [])
-      ]),
+  include Helpers::Trees
 
-      Node.new('leaf2', [
-        Node.new('subleaf1', []),
-        Node.new('subleaf2', [])
-      ])
-    ])
-
-    @different_root = Node.new('wrong', [])
-
-    @added = Node.new('root', [
-      Node.new('leaf1', [
-        Node.new('subleaf1', []),
-        Node.new('subleaf3', []),
-        Node.new('subleaf2', [])
-      ]),
-
-      Node.new('leaf2', [
-        Node.new('subleaf1', []),
-        Node.new('subleaf2', [])
-      ])
-    ])
-
-    @removed = Node.new('root', [
-      Node.new('leaf1', [
-        Node.new('subleaf1', [])
-      ]),
-
-      Node.new('leaf2', [
-        Node.new('subleaf1', []),
-        Node.new('subleaf2', [])
-      ])
-    ])
-
-    @changed_order = Node.new('root', [
-      Node.new('leaf2', [
-        Node.new('subleaf1', []),
-        Node.new('subleaf2', [])
-      ]),
-
-      Node.new('leaf1', [
-        Node.new('subleaf1', []),
-        Node.new('subleaf2', [])
-      ])
-    ])
-  end
-
-  it "should tell if two trees are identical" do
-    @tree.tdiff(@tree).all? { |change,node|
-      change == ' '
-    }.should == true
-  end
-
-  it "should stop if the root nodes have changed" do
-    changes = @tree.tdiff(@different_root).to_a
-
-    changes.length.should == 2
-
-    changes[0][0].should == '-'
-    changes[0][1].should == @tree
-
-    changes[1][0].should == '+'
-    changes[1][1].should == @different_root
-  end
-
-  it "should tell when sub-nodes are added" do
-    changes = @tree.tdiff(@added).select { |change,node| change == '+' }
-
-    changes.length.should == 1
-    changes[0][0].should == '+'
-    changes[0][1].should == @added.children[0].children[1]
-  end
-
-  it "should tell when sub-nodes are removed" do
-    changes = @tree.tdiff(@removed).select { |change,node| change == '-' }
-
-    changes.length.should == 1
-    changes[0][0].should == '-'
-    changes[0][1].should == @tree.children[0].children[1]
-  end
+  it_should_behave_like 'TDiff', :tdiff
 
   it "should detect when the order of children has changed" do
     changes = @tree.tdiff(@changed_order).to_a

data/spec/unordered_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'helpers/trees'
+require 'tdiff/unordered'
+
+describe TDiff::Unordered do
+  include Helpers::Trees
+
+  it "should include TDiff when included" do
+    base = Class.new do
+      include TDiff::Unordered
+    end
+
+    base.should include(TDiff)
+  end
+
+  it_should_behave_like 'TDiff', :tdiff_unordered
+
+  it "should not detect when the order of children has changed" do
+    changes = @tree.tdiff_unordered(@changed_order).select do |change,node|
+      change != ' '
+    end
+
+    changes.should be_empty
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Postmodern
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-13 00:00:00 -08:00
+date: 2010-11-14 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -82,9 +82,14 @@ files:
 - Rakefile
 - gemspec.yml
 - lib/tdiff.rb
+- lib/tdiff/tdiff.rb
+- lib/tdiff/unordered.rb
 - spec/classes/node.rb
+- spec/helpers/trees.rb
 - spec/spec_helper.rb
+- spec/tdiff_examples.rb
 - spec/tdiff_spec.rb
+- spec/unordered_spec.rb
 - tdiff.gemspec
 has_rdoc: yard
 homepage: http://github.com/postmodern/tdiff
@@ -120,3 +125,4 @@ specification_version: 3
 summary: Calculates the differences between two tree-like structures.
 test_files: 
 - spec/tdiff_spec.rb
+- spec/unordered_spec.rb