html-dom-diff 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c64fe7c87ae9884bf398b8c8699ee352deaa766ef92c078a1a8789badf0ad8ac
+  data.tar.gz: cebe07112a9f6ec7b2e573d59e95037bbec4af6fc8937afac112124730fa9bbe
+SHA512:
+  metadata.gz: 76f6659021fbdf482dcf640c9211fbd814a6c21cb92aba508ab24a20e6be79af5b9fd1dbe349a46dec00a198e8aeacb8ed74a5ec1e8362df1e8a16c4dc027c8a
+  data.tar.gz: 97222b9c82eff526515ce3e2040478e0890202c3fb91d45678461ae58ebd331825109276b8dff33eec971032a00a5d8e6b21ea3ca7606becbff151890d2879b5

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Frederik Fix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,8 @@
+# html-diff
+
+A library for providing useful diffs between related HTML documents. Algorithm based on:
+
+> G. Cobena, S. Abiteboul, and A. Marian, “Detecting changes in XML
+> documents,” in International Conference on Data Engineering, 2002,
+> pp. 41–52.
+> http://gregory.cobena.free.fr/www/Publications/%5BICDE2002%5D%20XyDiff%20-%20published%20version.pdf

data/lib/html-dom-diff.rb

@@ -0,0 +1,8 @@
+require 'html-dom-diff/version'
+require 'html-dom-diff/delta_tree_builder'
+require 'html-dom-diff/differ'
+require 'html-dom-diff/node'
+
+module HTMLDOMDiff
+
+end

data/lib/html-dom-diff/delta_tree_builder.rb

@@ -0,0 +1,41 @@
+module HTMLDOMDiff
+  class DeltaTreeBuilder
+    attr_reader :ldoc, :rdoc
+    def initialize(ldoc, rdoc, weights, forward, backward)
+      @ldoc     = ldoc
+      @rdoc     = rdoc
+      @weights  = weights
+      @forward  = forward
+      @backward = backward
+    end
+
+    def build
+      wrap @rdoc
+    end
+
+    private
+
+    def wrap(rnode, parent=nil)
+      result = Node.new rnode, @backward[rnode], parent
+      rnode.children.each do |child|
+        wrap child, result
+      end
+      if parent
+        parent.add_child result
+      end
+      if @backward[rnode]
+        @backward[rnode].children.each do |child|
+          reverse_wrap(child, result)
+        end
+      end
+      result
+    end
+
+    def reverse_wrap(lnode, parent)
+      return if @forward[lnode]
+      result = Node.new nil, lnode
+      lnode.children.each { |c| reverse_wrap c, result }
+      parent.add_child result
+    end
+  end
+end

data/lib/html-dom-diff/differ.rb

@@ -0,0 +1,196 @@
+require 'nokogiri'
+require 'digest'
+require 'pqueue'
+
+module HTMLDOMDiff
+  class Differ
+    def diff_strings(left, right)
+      diff parse(left).root, parse(right).root
+    end
+
+    def diff_fragments(left, right)
+      diff parse_fragments(left).child, parse_fragments(right).child
+    end
+
+    def diff(ldoc, rdoc)
+      reset
+
+      match_by_ids ldoc, rdoc
+      prep_with @lsignatures, ldoc
+      prep_with @rsignatures, rdoc
+
+      perform_initial_top_down_matching [ldoc], [rdoc]
+
+      @matchqueue.push(rdoc)
+      perform_initial_matching
+
+      match_bottom_up ldoc
+      match_top_down  ldoc
+
+      DeltaTreeBuilder.new(ldoc, rdoc, @weights, @forward, @backward).build
+    end
+
+    private
+
+    def parse(string)
+      Nokogiri::HTML(string, nil, nil, (Nokogiri::XML::ParseOptions::DEFAULT_HTML & Nokogiri::XML::ParseOptions::NOBLANKS))
+    end
+
+    def parse_fragments(string)
+      Nokogiri::HTML::DocumentFragment.parse(string)
+    end
+
+    def reset
+      @forward     = {}
+      @backward    = {}
+      @weights     = {}
+      @depths      = {}
+      @lsignatures = {}
+      @rsignatures = {}
+      @matchqueue  = PQueue.new() { |a, b| @weights[a] > @weights[b] }
+    end
+
+    def match_by_ids(ldoc, rdoc)
+      rightside = rdoc.css("[id]").to_a
+      ldoc.css("[id]").each do |element|
+        rindex = rightside.find_index { |e| e[:id] == element[:id] }
+        if rindex
+          record_matching element, rightside[rindex]
+          rightside.delete_at(rindex)
+        end
+      end
+    end
+
+    def prep_with(sig_hash, element, level=0)
+      weights    = weight_for(element)
+      signatures = [signature_part_for(element)]
+      element.children.each do |child|
+        weight, signature = prep_with(sig_hash, child, level+1)
+        weights += weight
+        signatures << signature
+      end
+
+      @weights[element] = weights
+      sig_hash[element] = hash_for(signatures)
+      @depths[element]  = level
+
+      [ @weights[element], sig_hash[element] ]
+    end
+
+    def weight_for(element)
+      if element.text? or element.cdata?
+        1 + Math.log(element.text.size)
+      else
+        1
+      end
+    end
+
+    def signature_part_for(element)
+      if element.text? or element.cdata?
+        element.text
+      else
+        element.name
+      end
+    end
+
+    def hash_for(array)
+      Digest::SHA256.digest array.join(";")
+    end
+
+    def record_matching(left, right)
+      @forward[left]   = right
+      @backward[right] = left
+    end
+
+    def perform_initial_top_down_matching(lnodes, rnodes)
+      _lnodes = lnodes.reject(&:text?)
+      _rnodes = rnodes.reject(&:text?)
+
+      _lnodes.each do |lnode|
+        lcounts    = _lnodes.count  { |c| c.name == lnode.name }
+        candidates = _rnodes.select { |c| c.name == lnode.name }
+        if lcounts == 1 && candidates.size == 1
+          record_matching lnode, candidates.first
+          perform_initial_top_down_matching lnode.children, candidates.first.children
+        end
+      end
+    end
+
+    def perform_initial_matching
+      while @matchqueue.size > 0
+        element = @matchqueue.pop
+        if @backward[element].nil? && (match = find_best_match(element))
+          match_all_children match, element
+          match_parents match, element
+        else
+          element.children.each { |c| @matchqueue.push c }
+        end
+      end
+    end
+
+    def find_best_match(element)
+      candidates = []
+      @lsignatures.each do |left, sig|
+        if @forward[left].nil? && sig == @rsignatures[element]
+          candidates << left
+        end
+      end
+
+      if candidates.size == 0
+        return
+      elsif candidates.size == 1
+        return candidates.first
+      else
+        matching_parents = candidates.select do |left|
+          @forward[left.parent] == element.parent
+        end
+
+        if matching_parents.size == 1
+          return matching_parents.first
+        else
+          return
+        end
+      end
+    end
+
+    def match_all_children(left, right)
+      record_matching left, right
+      left.children.zip(right.children).each do |a, b|
+        match_all_children a, b
+      end
+    end
+
+    def match_parents(left, right)
+      # TODO implement multi-ancestor matching
+      return if @forward[left.parent] || @backward[right.parent]
+      if left.parent.name == right.parent.name
+        record_matching left, right
+      end
+    end
+
+    def match_bottom_up(element)
+      element.children.each do |child|
+        match_bottom_up child
+      end
+
+      if element.respond_to?(:parent) && @forward[element.parent]
+        match = @forward[element.parent].children.find { |c| @backward[c].nil? && c.name == element.name }
+        record_matching(element, match) if match
+      end
+    end
+
+    def match_top_down(element)
+      if @forward[element].nil?
+        childmatches = element.children.map { |c| @forward[c] && @forward[c].parent }.compact.uniq
+        childmatches.reject! { |e| @backward[e] }
+        if childmatches.size == 1 && childmatches.first.name == element.name
+          record_matching(element, childmatches.first)
+        end
+      end
+
+      element.children.each do |child|
+        match_top_down child
+      end
+    end
+  end
+end

data/lib/html-dom-diff/node.rb

@@ -0,0 +1,122 @@
+module HTMLDOMDiff
+  class Node
+    attr_reader :parent, :children
+
+    attr_reader :rnode
+
+    def initialize(rnode, lnode, parent=nil)
+      @rnode    = rnode
+      @lnode    = lnode
+      @parent   = parent
+      @children = []
+    end
+
+    def add_child(child)
+      @children << child
+    end
+
+    def self_and_all_children
+      [self] + @children.map(&:self_and_all_children).flatten
+    end
+
+    # attributes
+    def attributes
+      @rnode.attributes if @rnode
+    end
+
+    def original_attributes
+      @lnode.attributes if @lnode
+    end
+
+    def changed_attribute_names
+      result = []
+      attributes.each do |k, v|
+        result << k if original_attributes[k].nil? || (v.value != original_attributes[k].value)
+      end
+      original_attributes.each do |k, v|
+        result << k if attributes[k].nil? || (v.value != attributes[k].value)
+      end
+      result.uniq
+    end
+
+    def text
+      @rnode.text
+    end
+
+    def original_text
+      @lnode&.text
+    end
+
+    def name
+      if @rnode
+        @rnode.name
+      else
+        @lnode.name
+      end
+    end
+
+    def text?
+      (@rnode||@lnode).text?
+    end
+
+    def to_html
+      @rnode.to_html
+    end
+
+    def as_tree_string(level=0)
+      result  = [(" "*level) + "#{name} - :#{state}"]
+      result += children.map { |c| c.as_tree_string(level+1) }
+      result.join("\n")
+    end
+
+    # states
+    def changed?
+      if @rnode.text?
+        text != original_text
+      else
+        attributes_changed?
+      end
+    end
+
+    def state
+      [:moved, :inserted, :removed, :matched].each do |_state|
+        return _state if send("#{_state}?")
+      end
+    end
+
+    def matched?
+      ! (inserted? || removed? || moved?)
+    end
+
+    def inserted?
+      @lnode.nil?
+    end
+
+    def removed?
+      @rnode.nil?
+    end
+
+    def moved?
+      return false if inserted? || removed? || @parent.nil?
+      !@parent.parent_of? @lnode, @rnode
+    end
+
+    protected
+
+    def attributes_changed?
+      return true if attributes.size != original_attributes.size
+      attributes.each do |k, v|
+        if original_attributes[k].nil? || v.value != original_attributes[k].value
+          return true
+        end
+      end
+      false
+    end
+
+    def parent_of?(lchild, rchild)
+      return false if @lnode.nil? || @rnode.nil?
+      return false unless @lnode.children.include?(lchild)
+      @rnode.children.include?(rchild)
+    end
+  end
+end

data/lib/html-dom-diff/version.rb

@@ -0,0 +1,3 @@
+module HTMLDOMDiff
+  VERSION = "0.1"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: html-dom-diff
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Frederik Fix
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pqueue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Given two closely related HTML documents find a useful diff
+
+'
+email:
+- ich@derfred.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/html-dom-diff.rb
+- lib/html-dom-diff/delta_tree_builder.rb
+- lib/html-dom-diff/differ.rb
+- lib/html-dom-diff/node.rb
+- lib/html-dom-diff/version.rb
+homepage: https://github.com/derfred/html-dom-diff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Diff between HTML documents
+test_files: []