lorax 0.1.0

data/spec/integration/lorax_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Lorax do
+  def round_trip_should_succeed(doc1, doc2)
+    delta_set = Lorax.diff(doc1, doc2)
+    new_doc   = delta_set.apply(doc1)
+
+    unless Lorax::Signature.new(new_doc.root).signature == Lorax::Signature.new(doc2.root).signature
+      errmsg = []
+      errmsg << "Documents are not identical after a round-trip diff and patch:"
+      errmsg << doc1.root.to_xml
+      errmsg << "-----"
+      errmsg << doc2.root.to_xml
+      errmsg << "=> patch: #{delta_set.deltas.inspect}"
+      errmsg << new_doc.root.to_xml
+      fail errmsg.join("\n")
+    end
+  end
+
+  context "inserted nodes" do
+    it "handles appends to matching siblings" do
+      doc1 = xml { root {
+          a1 "hello"
+        } }
+      doc2 = xml { root {
+          a1 "hello"
+          a2 "goodbye"
+        } }
+      round_trip_should_succeed doc1, doc2
+    end
+
+    it "inserts into matching siblings" do
+      doc1 = xml { root {
+          a1 "hello"
+          a3 "goodbye"
+        } }
+      doc2 = xml { root {
+          a1 "hello"
+          a2
+          a3 "goodbye"
+        } }
+      round_trip_should_succeed doc1, doc2
+    end
+
+    it "inserts under an existing sibling node" do
+      doc1 = xml { root {
+          a1 "hello"
+          a2
+        } }
+      doc2 = xml { root {
+          a1 "hello"
+          a2 { b1 "subnode" }
+        } }
+      round_trip_should_succeed doc1, doc2
+    end
+  end
+
+  context "deleted nodes" do
+    it "handles deleting nodes" do
+      doc1 = xml { root {
+          a1 "hello"
+          a2 "goodbye"
+          a3 "natch"
+        } }
+      doc2 = xml { root {
+          a1 "hello"
+          a3 "natch"
+        } }
+      round_trip_should_succeed doc1, doc2
+    end
+  end
+
+  context "modified nodes" do
+    it "handles modifying nodes" do
+      doc1 = xml { root {
+          a1 "hello"
+          a2 "goodbye"
+          a3 "natch"
+        } }
+      doc2 = xml { root {
+          a1 "hello"
+          a2 "good buy"
+          a3 "natch"
+        } }
+      round_trip_should_succeed doc1, doc2
+    end
+  end
+
+  context "mixed operations" do
+    it "handles mixed deletions and modifications" do
+      doc1 = xml { root {
+          a1 "hello"
+          a2 "goodbye"
+          a3 "natch"
+          a4 "jimmy"
+        } }
+      doc2 = xml { root {
+          a1 "hello"
+          a3 "not"
+          a4 "jimmy"
+        } }
+      round_trip_should_succeed doc1, doc2
+    end
+  end
+
+  context "with whitespace interleaved" do
+    it "handles whitespace nodes" do
+      doc1 = xml { root {
+          a1
+          text "\n\n"
+          a4
+          text "\n\n"
+          a5
+        } }
+      doc2 = xml { root {
+          a1
+          text "\n\n"
+          a2
+          text "\n\n"
+          a3
+          text "\n\n"
+          a4
+          text "\n\n"
+          a5
+        } }
+      round_trip_should_succeed doc1, doc2
+    end
+  end
+
+end

data/spec/match_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Lorax::Match do
+  before do
+    @doc1 = xml { root }
+    @doc2 = xml { root }
+  end
+
+  describe "#new" do
+    it "takes two nodes as arguments" do
+      proc { Lorax::Match.new(@doc1.root, @doc2.root) }.should_not raise_error
+    end
+
+    it "takes optional options" do
+      proc { Lorax::Match.new(@doc1.root, @doc2.root, {:perfect => true}) }.should_not raise_error
+    end
+  end
+
+  describe "#perfect" do
+    it "returns true if {:perfect => true} option was passed to #new" do
+      Lorax::Match.new(@doc1.root, @doc2.root, {:perfect => true}).should be_perfect      
+    end
+
+    it "returns false if {:perfect => false} option was passed to #new" do
+      Lorax::Match.new(@doc1.root, @doc2.root, {:perfect => false}).should_not be_perfect      
+    end
+
+    it "returns false if no :perfect option was passed to #new" do
+      Lorax::Match.new(@doc1.root, @doc2.root).should_not be_perfect      
+    end
+  end
+
+  describe "#pair" do
+    it "returns the two nodes in an array" do
+      Lorax::Match.new(@doc1.root, @doc2.root).pair.should == [@doc1.root, @doc2.root]
+    end
+  end
+
+  describe "#other" do
+    context "the node is in the pair" do
+      it "returns the other node" do
+        match = Lorax::Match.new :a, :b
+        match.other(:a).should == :b
+        match.other(:b).should == :a
+      end
+    end
+
+    context "the node is not in the pair" do
+      it "returns nil" do
+        Lorax::Match.new(:a, :b).other(:c).should be_nil
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'lorax'
+
+require 'spec'
+require 'spec/autorun'
+require 'rr'
+require 'pp'
+
+warn "#{__FILE__}:#{__LINE__}: libxml version info: #{Nokogiri::VERSION_INFO.inspect}"
+
+module XmlBuilderHelper
+  def xml(&block)
+    Nokogiri::XML::Builder.new(&block).doc
+  end
+
+  def assert_no_match_exists(match_set, node1, node2)
+    match_set.match(node1).should be_nil
+    match_set.match(node2).should be_nil
+  end
+
+  def assert_perfect_match_exists(match_set, node1, node2)
+    match = match_set.match(node1)
+    fail "#{node1.inspect} was not matched" if match.nil?
+    match.other(node1).should == node2
+    match.should be_perfect
+  end
+
+  def assert_forced_match_exists(match_set, node1, node2)
+    match = match_set.match(node1)
+    fail "#{node1.inspect} was not matched" if match.nil?
+    match.other(node1).should == node2
+    match.should_not be_perfect
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+  config.include XmlBuilderHelper
+end

data/spec/unit/delta/delete_delta_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Lorax::DeleteDelta do
+  describe ".new" do
+    it "takes one argument" do
+      proc { Lorax::DeleteDelta.new(:foo)      }.should_not raise_error(ArgumentError)
+      proc { Lorax::DeleteDelta.new(:foo, :bar)}.should     raise_error(ArgumentError)
+    end
+  end
+
+  describe "#node" do
+    it "returns the initalizer argument" do
+      Lorax::DeleteDelta.new(:foo).node.should == :foo
+    end
+  end
+
+  describe "#apply!" do
+    context "for an atomic node delta" do
+      it "should delete the node" do
+        doc1 = xml { root { a1 } }
+        doc2 = xml { root }
+        node = doc1.at_css("a1")
+        delta = Lorax::DeleteDelta.new node
+
+        delta.apply!(doc1)
+
+        doc1.at_css("a1").should be_nil
+        node.parent.should == nil
+      end
+    end
+
+    context "for a subtree delta" do
+      it "should delete the subtree" do
+        doc1 = xml { root { a1 { b1 ; b2 "hello" } } }
+        doc2 = xml { root }
+        node = doc1.at_css("a1")
+        delta = Lorax::DeleteDelta.new node
+
+        delta.apply!(doc1)
+
+        doc1.at_css("a1,b1,b2").should be_nil
+        node.parent.should == nil
+      end
+    end
+  end
+
+  describe "#descriptor" do
+    it "needs a spec"
+  end
+end

data/spec/unit/delta/insert_delta_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Lorax::InsertDelta do
+  describe ".new" do
+    it "takes three arguments" do
+      proc { Lorax::InsertDelta.new(:foo, :bar)              }.should     raise_error(ArgumentError)
+      proc { Lorax::InsertDelta.new(:foo, :bar, :quux)       }.should_not raise_error(ArgumentError)
+      proc { Lorax::InsertDelta.new(:foo, :bar, :quux, :fuzz)}.should     raise_error(ArgumentError)
+    end
+  end
+
+  describe "#node" do
+    it "returns the first argument to #new" do
+      Lorax::InsertDelta.new(:foo, :bar, :quux).node.should == :foo
+    end
+  end
+
+  describe "#xpath" do
+    it "returns the second argument to #new" do
+      Lorax::InsertDelta.new(:foo, :bar, :quux).xpath.should == :bar
+    end
+  end
+
+  describe "#position" do
+    it "returns the third argument to #new" do
+      Lorax::InsertDelta.new(:foo, :bar, :quux).position.should == :quux
+    end
+  end
+
+  describe "#apply!" do
+    context "for an atomic node delta" do
+      it "should insert a copy into the document" do
+        doc1 = xml { root }
+        doc2 = xml { root { a1 } }
+        node = doc2.at_css("a1")
+        delta = Lorax::InsertDelta.new node, node.parent.path, 0
+
+        delta.apply!(doc1)
+
+        doc1.at_css("a1").should_not be_nil
+        node.parent.should == doc2.root
+      end
+    end
+
+    context "for a subtree node delta" do
+      it "should insert a copy into the document" do
+        doc1 = xml { root }
+        doc2 = xml { root { a1 { b1 ; b2 "hello" } } }
+        node = doc2.at_css("a1")
+        delta = Lorax::InsertDelta.new node, node.parent.path, 0
+
+        delta.apply!(doc1)
+
+        doc1.at_css("a1").should_not be_nil
+        node.parent.should == doc2.root
+      end
+    end
+
+    context "sibling node insertions" do
+      it "should insert at the front" do
+        doc1 = xml { root { a2 } }
+        doc2 = xml { root { a1 ; a2 } }
+        node = doc2.at_css("a1")
+        delta = Lorax::InsertDelta.new node, node.parent.path, 0
+
+        delta.apply! doc1
+
+        doc1.root.children.map {|child| child.name}.should == %w[a1 a2]
+      end
+
+      it "should insert at the middle" do
+        doc1 = xml { root { a1 ; a3 } }
+        doc2 = xml { root { a1 ; a2 ; a3 } }
+        node = doc2.at_css("a2")
+        delta = Lorax::InsertDelta.new node, node.parent.path, 1
+
+        delta.apply! doc1
+
+        doc1.root.children.map {|child| child.name}.should == %w[a1 a2 a3]
+      end
+
+      it "should insert at the end" do
+        doc1 = xml { root { a1 } }
+        doc2 = xml { root { a1 ; a2 } }
+        node = doc2.at_css("a2")
+        delta = Lorax::InsertDelta.new node, node.parent.path, 1
+
+        delta.apply! doc1
+
+        doc1.root.children.map {|child| child.name}.should == %w[a1 a2]
+      end
+    end
+
+    context "delta with unresolvable xpath" do
+      it "should raise a Conflict exception" do
+        doc1 = xml { root }
+        doc2 = xml { root { a1 } }
+        node = doc2.at_css("a1")
+        delta = Lorax::InsertDelta.new node, "/foo/bar/quux", 0
+
+        proc { delta.apply!(doc1) }.should raise_error(Lorax::Delta::NodeNotFoundError)
+      end
+    end
+  end
+
+  describe "#descriptor" do
+    it "needs a spec"
+  end
+end

data/spec/unit/delta/modify_delta_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Lorax::ModifyDelta do
+  describe ".new" do
+    it "takes two arguments" do
+      proc { Lorax::ModifyDelta.new(:foo)             }.should     raise_error(ArgumentError)
+      proc { Lorax::ModifyDelta.new(:foo, :bar)       }.should_not raise_error(ArgumentError)
+      proc { Lorax::ModifyDelta.new(:foo, :bar, :quux)}.should     raise_error(ArgumentError)
+    end
+  end
+
+  describe "#node1" do
+    it "returns the first initializer parameter" do
+      Lorax::ModifyDelta.new(:foo, :bar).node1.should == :foo
+    end
+  end
+
+  describe "#node2" do
+    it "returns the first initializer parameter" do
+      Lorax::ModifyDelta.new(:foo, :bar).node2.should == :bar
+    end
+  end
+
+  describe "#apply!" do
+    context "element node" do
+      context "when attributes differ" do
+        it "should set the attributes properly" do
+          doc1 = xml { root { a1(:foo => :bar) } }
+          doc2 = xml { root { a1(:bazz => :quux, :once => :twice) } }
+          doc3 = doc1.dup
+          node1 = doc1.at_css("a1")
+          node2 = doc2.at_css("a1")
+          node3 = doc3.at_css("a1")
+
+          delta = Lorax::ModifyDelta.new(node1, node2)
+          delta.apply!(doc3)
+          
+          node3["foo"].should be_nil
+          node3["bazz"].should == "quux"
+          node3["once"].should == "twice"
+        end
+      end
+    end
+
+    context "text node" do
+      it "should set the content properly" do
+        doc1 = xml { root "hello" }
+        doc2 = xml { root "goodbye" }
+        doc3 = doc1.dup
+
+        delta = Lorax::ModifyDelta.new(doc1.root.children.first, doc2.root.children.first)
+        delta.apply!(doc3)
+
+        doc3.root.content.should == "goodbye"
+      end
+    end
+
+    context "when positions differ" do
+      it "should move the node" do
+        doc1 = xml { root {
+            a1 { b1 }
+            a2
+          } }
+        doc2 = xml { root {
+            a1
+            a2 { b1 }
+          } }
+        delta = Lorax::ModifyDelta.new(doc1.at_css("b1"), doc2.at_css("b1"))
+        doc3 = doc1.dup
+        delta.apply!(doc3)
+        doc3.at_xpath("/root/a2/b1").should_not be_nil
+      end
+
+      it "should move the node to the correct position" do
+        doc1 = xml { root {
+            a1 { b2 }
+            a2 { b1 ; b3 }
+          } }
+        doc2 = xml { root {
+            a1
+            a2 { b1 ; b2 ; b3 }
+          } }
+        delta = Lorax::ModifyDelta.new(doc1.at_css("b2"), doc2.at_css("b2"))
+        doc3 = doc1.dup
+        delta.apply!(doc3)
+        doc3.at_xpath("/root/a2/*[2]").name.should == "b2"
+      end
+    end
+  end
+
+  describe "#descriptor" do
+    it "needs a spec"
+  end
+end