happymapper-differ 0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8762cf0e3b779fa85dad307850b73fff48980c87
-  data.tar.gz: 5d77b1d3cae7582cf841387ec3c98473a46866ff
+  metadata.gz: 89743c03e9ed823e1418688575aca74ecd06dae6
+  data.tar.gz: c0fe578b444d252316621c029b869f7ccf483196
 SHA512:
-  metadata.gz: e034ea0d0d7455438b6afe0cc6c60d870e78b85fe7afcc9c22a671a8af8e84546e222e64a51cad1d3223c1d3808250f52f78e48ea97dd8031923d69734dbfe1e
-  data.tar.gz: a1d3704b0af7d435e5625404f1ac4c847af7a72463b2304815e55fb9c6fd1fd1a1c496c34c67bd63abf112c51a45f26441e3219381e9db2a6b36c067e53cc612
+  metadata.gz: 6a95ada3cb154e6e150080a0f4d3b21e76e3da9b3745ef89107ea7ee7557c2bea81900dfbf395afc982f7f195954958ae6754e204c1066845edae9ef32d8d819
+  data.tar.gz: ea4b1f0be3929ea7cca84f3bd7ffdd0ae7a705a455bff4d86ffe2e3cd7c5a3321e73fe9fdcda9ce56dbae32f4740634a4098582576225198f72e7f8226d55fca

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## Unreleased
+### Changed
+- Removed cloning

data/lib/happymapper/differ.rb

@@ -1,132 +1,174 @@
+require 'delegate'
+
 module HappyMapper
-  class Differ 
-    VERSION = 0.1
+  # Differ compares the differences betwee two HappyMapper objects.
+  #
+  # Two step process
+  # First step is map all nodes into a DiffedItem
+  # Step two is present all the changes via DiffedItem.changes
+  class Differ
+    VERSION = "0.1.1"
 
     def initialize(left, right)
       @left = left
       @right = right
     end
 
-    def changed?
-      @left.to_xml == @right.to_xml
-    end
-
-    # Diff is a memory ineffecient and ugly method to find what elements and
-    # attributes have changed and how.
-    #
-    # It extends each element and attribute with the DiffedItem module
-    # and makes a clone of the original element for comparison.
+    # Diff is a method to find what elements and attributes have changed and
+    # how.It extends each element and attribute with the DiffedItem module
     def diff
-      out = @left
-      setup(@left, @right)
-
-      all = out.class.attributes + out.class.elements
+      @left = DiffedItem.create(@left, @right)
 
       # setup for each element (has_one and has_many) and attribute
-      all.map(&:name).compact.each do |name|
-        value = out.send(name)
-        if value.nil?
-          value = NilLike.new 
-          out.send("#{name}=", value)
-        end
+      all_items.each do |item|
+        lvalue = get_value(@left, item.name) 
+        rvalue = get_value(@right, item.name)
+
+        # skip if both sides are nil
+        next if rvalue.nil? && lvalue.nil?
 
-        if value.is_a?(Array)
-          # Find the side with the most items
-          # If the right has more, the left will be padded with NilLike instances
-          count = [value.size, (@right.send(name) || []).size].max
+        if ! item.options[:single]
+          setup_element(lvalue, rvalue)
+          # Find the side with the most items. If the right has more, the left
+          # will be padded with UnExtendable instances
+          count = [lvalue.size, (rvalue || []).size].max
 
           count.times do |i|
-            value[i] = NilLike.new if value[i].nil?
-            setup_element(value[i], @right.send(name)[i])
+            lvalue[i] = setup_element(lvalue[i], (rvalue || [])[i])
           end
         else
-          setup_element(value, @right.send(name))
+          lvalue = setup_element(lvalue, rvalue)
         end
+
+        @left.send("#{item.name}=", lvalue)
       end
 
-      out
+      @left
     end
 
-    def handle_nil(name)
-      out.send("#{name}=", NilLike.new)
+    protected
+
+    def get_value(side, name)
+      begin
+        side.send(name)
+      rescue
+        nil
+      end
     end
 
-    def setup(item, compared)
-      n = item.clone
-      item.extend(DiffedItem)
-      item.compared = compared 
-      item.original = n
+    # returns all the elements and attributes for the left class
+    def all_items
+      @left.class.attributes + @left.class.elements
     end
 
     def setup_element(item, compared)
-      if(item.is_a?(HappyMapper))
+      if item.is_a?(HappyMapper)
         Differ.new(item, compared).diff
       else
-        setup(item, compared)
+        DiffedItem.create(item, compared)
       end
     end
+  end
 
-    # nil can't be cloned or extended
-    # so this object behaves like nil
-    class NilLike
-      def nil?
-        true
-      end
-
-      def to_s
-        "nil"
-      end
-
-      def inspect
-        nil.inspect
-      end
+  # nil, Float, and other classes can't be extended
+  # so this object acts as wrapper
+  class UnExtendable < SimpleDelegator
+    def class
+      __getobj__.class
     end
   end
 
+  # DiffedItem is an extension which allows tracking changes between two
+  # HappyMapper objects.
   module DiffedItem
-    attr_accessor :original
-
     # The object this item is being compared to
     attr_accessor :compared
-    alias :was :compared
+    alias_method :was, :compared
+
+    def self.create(item, compared)
+      begin
+        # if the item can not be cloned, it will raise an exception
+        # do not extend objects which can not be cloned
+        item.clone
+        item.extend(DiffedItem)
+      rescue
+        # this item is a Float, Nil or other class that can not be extended
+        item = UnExtendable.new(item)
+        item.extend(DiffedItem)
+      end
+
+      item.compared = compared
+      item
+    end
 
     def changed?
-      original != compared
+      if self.is_a?(HappyMapper)
+        ! changes.empty?
+      else
+        self != compared
+      end
     end
 
     def changes
-      cs = {} # the changes
+      @changes ||= ChangeLister.new(self, compared).find_changes
+    end
+  end
 
-      original.class.attributes.map(&:name).each do |attr|
-        other_value = compared.send(attr)
-        if original.send(attr) != other_value
-          cs[attr] = other_value
-        end
+  # ChangeLister creates a hash of all changes between the two objects
+  class ChangeLister
+    def initialize(current, compared)
+      @current = current
+      @compared = compared
+      @changes = {}
+    end
+
+    def eq(a,b)
+      if a.respond_to?(:to_xml) && b.respond_to?(:to_xml)
+        a.to_xml == b.to_xml
+      else
+        a == b
       end
+    end
 
-      original.class.elements.map(&:name).each do |name|
-        other_els = compared.send(name)
-        this_els  = original.send(name)
+    def find_changes
+      elements_and_attributes.map(&:name).each do |name|
+        el  = @current.send(name)
 
-        if this_els.is_a?(Array)
-          this_els.each_with_index do |el, i|
-            if el != other_els[i]
-              cs[name] ||= []
-              cs[name] << other_els[i]
-            end
-          end
+        if el.is_a?(Array)
+          many_changes(el, key: name)
         else
-          if this_els != other_els
-            cs[name] = other_els
+          other_el = get_compared_value(name)
+          if ! eq(el, other_el)
+            @changes[name] = other_el
           end
         end
       end
 
-      cs
+      @changes
+    end
+
+    # Handle change for has_many elements
+    def many_changes(els, key:)
+      other_els = get_compared_value(key) || []
+
+      els.each_with_index do |el, i|
+        if ! eq(el, other_els[i])
+          @changes[key] ||= []
+          @changes[key] << other_els[i]
+        end
+      end
+    end
+
+    def get_compared_value(key)
+      if @compared.respond_to?(key)
+        @compared.send(key)
+      else
+        nil
+      end
     end
 
-    def ==(other)
-      original == other
+    def elements_and_attributes
+      @current.class.attributes + @current.class.elements
     end
   end
 end

data/lib/happymapper_differ.rb

@@ -1,11 +1,7 @@
 require 'happymapper'
 
+# HappyMapper module imported from the nokogiri-happymapper gem
 module HappyMapper
   require 'happymapper/differ'
-
-  # equality based on the underlying XML
-  def ==(other)
-    self.to_xml == other.to_xml
-  end
 end
 

data/test/happymapper/change_lister_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+describe HappyMapper::ChangeLister do
+  it "should find now changes between two equal objects" do
+    a = TParent.parse(sample_a)
+    b = TParent.parse(sample_a)
+
+    d = HappyMapper::ChangeLister.new(a,b).find_changes
+
+    assert_equal({}, d)
+  end
+
+  it "should find the changes between two simple objects" do
+    a = TParent.parse(sample_a)
+    b = TParent.parse(sample_b)
+
+    d = HappyMapper::ChangeLister.new(a,b).find_changes
+    
+    assert_equal ["name", "children"], d.keys
+    assert_equal "Vlad", d["name"]
+    assert_equal [b.children[2]], d["children"]
+  end
+
+  it "should find changes in nested objects" do
+    a = TParent.parse(sample_a)
+    b = TParent.parse(sample_a)
+
+    b.children.first.address = TAddress.new
+    b.children.first.address.street = "123 Maple"
+
+    d = HappyMapper::ChangeLister.new(a,b).find_changes
+
+    assert_equal [b.children.first], d["children"]
+  end
+
+  def sample_a
+    <<-XML
+<parent name="Roz">
+  <child name="Joe"/>
+  <child name="Jane"/>
+  <child name="Jason"/>
+</parent>
+    XML
+  end
+
+  def sample_b
+    <<-XML
+<parent name="Vlad">
+  <child name="Joe"/>
+  <child name="Jane"/>
+  <child name="Alex"/>
+</parent>
+    XML
+  end
+end

data/test/happymapper/diffed_item_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class DIPerson
+  include HappyMapper
+  tag 'person'
+
+  attribute 'name', String
+  has_one :child, DIPerson
+end
+
+describe HappyMapper::DiffedItem do
+  describe "HappyMapper objects" do
+    let(:a) { TAddress.parse("<address><street>Maple</street></address>") }
+    let(:b) { TAddress.parse("<address><street>Main</street></address>") }
+
+    describe "changed" do
+      it "is true when the values are not equal" do
+        di = HappyMapper::DiffedItem.create(a,b)
+        assert_equal true, di.changed?
+      end
+
+      it "is false when the objects are the same" do
+        di = HappyMapper::DiffedItem.create(a,a)
+        assert_equal false, di.changed?
+      end
+    end
+  end
+
+  describe "non HappyMapper Objects" do
+    describe "changed" do
+      it "is true when the values are note equal" do
+        di = HappyMapper::DiffedItem.create("A","B")
+        assert_equal true, di.changed?
+        assert_equal "B", di.was
+
+        di = HappyMapper::DiffedItem.create(1,2)
+        assert_equal true, di.changed?
+        assert_equal 2, di.was
+
+        di = HappyMapper::DiffedItem.create(1,1)
+        assert_equal false, di.changed?
+        assert_equal 1, di.was
+      end
+    end
+  end
+
+  describe "with nil objects" do
+    # BUG: When there are two nil objects, the second replaces the first.
+    it "should keep the correct state" do
+      a = HappyMapper::DiffedItem.create(nil, 'A')
+      b = HappyMapper::DiffedItem.create(nil, 'B')
+
+      assert_equal 'A', a.was
+      assert_equal 'B', b.was
+    end
+  end
+end
+
+

data/test/happymapper_differ_test.rb

@@ -4,17 +4,20 @@ describe "HappyMapper with Comparable" do
   let(:left) { TParent.parse(sample_a) }
   let(:right) { TParent.parse(sample_b) }
 
-  it "sez two identical documents should be equal" do
-    assert_equal left, TParent.parse(sample_a)
-  end
-
-  it "sez two different documents should not be equal" do
-    refute_equal left, right
-  end
-
   describe HappyMapper::Differ do
     let(:result) { HappyMapper::Differ.new(left, right).diff }
 
+    it "finds no changes for identical documents" do
+      result = HappyMapper::Differ.new(
+        left,
+        TParent.parse(sample_a)
+      ).diff
+
+      assert ! result.changed?
+      assert ! result.name.changed?
+      assert_equal({}, result.changes)
+    end
+
     it "finds attribute changes" do
       result = HappyMapper::Differ.new(
         TParent.parse("<parent name='Roz'/>"),
@@ -35,20 +38,26 @@ describe "HappyMapper with Comparable" do
     end
 
     it "finds changes to has_many elements" do
+      assert result.children.changed?
       assert ! result.children[0].changed?
       assert ! result.children[1].changed?
       assert result.children[2].changed?
+
+
       assert_equal({"name" => "Vlad", "children" => [right.children[2]]}, result.changes)
       assert_equal({}, result.children[1].changes)
       assert_equal({"name" => "Alex"}, result.children[2].changes)
     end
 
-    it "finds changes to  nested data" do
+    it "finds changes to nested data" do
       result = HappyMapper::Differ.new(
         TParent.parse(nested_a),
         TParent.parse(nested_b),
       ).diff
 
+      # why is the name being injected
+      assert_equal result.children.last.address.to_xml, result.children.last.address.was.to_xml
+
       assert result.changed?
       assert result.children[0].changed?
       assert result.children[0].address.changed?
@@ -59,15 +68,15 @@ describe "HappyMapper with Comparable" do
       assert_equal("789 Maple St", result.children[0].address.street.compared)
     end
 
-    it "find changes when the value is nil" do
+    it "find changes when the value is nil XX" do
       result = HappyMapper::Differ.new(
         TParent.parse("<parent/>"),
-        TParent.parse("<parent name='Alex'/>"),
+        TParent.parse("<parent name='Justin'/>"),
       ).diff
 
       assert result.changed?
       assert result.name.changed?
-      assert_equal 'Alex', result.name.compared
+      assert_equal 'Justin', result.name.compared
     end
 
     it "finds changes when the left side element count is less than the right" do
@@ -79,6 +88,46 @@ describe "HappyMapper with Comparable" do
       assert result.changed?
       assert result.children[3].changed?
     end
+
+    it "handles a variet of types" do
+      result = HappyMapper::Differ.new(
+        TTypes.parse(types_a),
+        TTypes.parse(types_b)
+      ).diff
+
+      assert result.changed?
+      assert_equal Float, result.float.class
+      assert_equal 1.1, result.float
+      assert_equal 11.1, result.float.was
+    end
+
+    it "gracefully handles mismatched objects" do
+      result = HappyMapper::Differ.new(
+        TParent.parse(sample_a),
+        TParent.parse("<parent/>"),
+      ).diff
+
+      assert result.changed?
+      assert result.changes
+    end
+
+    it "handles nil right side" do
+      di = HappyMapper::Differ.new(left,nil).diff
+      assert_equal true, di.changed?
+      assert_equal ["name","children"], di.changes.keys
+
+      p = TParent.parse("<parent><child/><child/></parent>")
+      di = HappyMapper::Differ.new(p,nil).diff
+      assert_equal true, di.changed?
+      assert_equal ["children"], di.changes.keys
+    end
+
+    it "errors if the left is nil" do
+      assert_raises NoMethodError do
+        di = HappyMapper::Differ.new(nil,right).diff
+        assert_equal false, di.changed?
+      end
+    end
   end
 
   def sample_a
@@ -143,7 +192,7 @@ describe "HappyMapper with Comparable" do
   </child>
   <child name="Jane">
     <address>
-      <street>567 Olice St</street>
+      <street>567 Olive St</street>
       <city>Brooklyn</city>
     </address>
   </child>
@@ -151,6 +200,14 @@ describe "HappyMapper with Comparable" do
     XML
   end
 
+  def addy
+    <<-XML
+    <address>
+      <street>567 Olive St</street>
+      <city>Brooklyn</city>
+    </address>
+    XML
+  end
   # Joe's address changed
   def nested_b
     <<-XML
@@ -163,11 +220,31 @@ describe "HappyMapper with Comparable" do
   </child>
   <child name="Jane">
     <address>
-      <street>567 Olice St</street>
+      <street>567 Olive St</street>
       <city>Brooklyn</city>
     </address>
   </child>
 </parent>
     XML
   end
+
+  def types_a
+    <<-XML
+    <types
+      float="1.1"
+      int="2"
+      bool="true"
+    />
+    XML
+  end
+
+  def types_b
+    <<-XML
+    <types
+      float="11.1"
+      int="12"
+      bool="false"
+    />
+    XML
+  end
 end

data/test/test_helper.rb

@@ -9,6 +9,10 @@ class TParent
   tag 'parent'
 
   attribute :name, String
+
+  # always nil, never used
+  has_one :address, "TAddress", tag: 'pAddress'
+
   has_many :children, "TChild", tag: 'child'
 end
 
@@ -28,3 +32,11 @@ class TAddress
   has_one :street, String
   has_one :city, String
 end
+
+class TTypes
+  include HappyMapper
+  tag 'types'
+
+  attribute :float, Float
+  attribute :int, Integer
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: happymapper-differ
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.1.1
 platform: ruby
 authors:
 - John Weir
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-06 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri-happymapper
@@ -77,6 +77,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -85,6 +86,8 @@ files:
 - happymapper-differ.gemspec
 - lib/happymapper/differ.rb
 - lib/happymapper_differ.rb
+- test/happymapper/change_lister_test.rb
+- test/happymapper/diffed_item_test.rb
 - test/happymapper_differ_test.rb
 - test/test_helper.rb
 homepage: https://github.com/pharos-ei/happymapper-differ
@@ -112,5 +115,7 @@ signing_key:
 specification_version: 4
 summary: Find changes between two like HappyMapper objects
 test_files:
+- test/happymapper/change_lister_test.rb
+- test/happymapper/diffed_item_test.rb
 - test/happymapper_differ_test.rb
 - test/test_helper.rb