patience_diff 1.0.1

data/History.txt

@@ -0,0 +1,10 @@
+=== 1.0.1 / 2012-06-19
+
+* Renamed gem from 'ruby_patience_diff' to just 'patience_diff'
+* Fixed basically everything
+* Added command-line options
+* A little bit of documentation
+
+=== 1.0.0 / 2012-06-16
+
+* First release

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.md
+Rakefile
+bin/patience_diff
+lib/patience_diff.rb
+lib/patience_diff/card.rb
+lib/patience_diff/sequence_matcher.rb
+lib/patience_diff/unified_differ.rb
+lib/patience_diff/usage_error.rb

data/README.md

@@ -0,0 +1,61 @@
+# ruby_patience_diff
+
+* http://github.com/watt/ruby_patience_diff
+
+## DESCRIPTION:
+
+A Ruby implementation of the Patience diff algorithm.
+
+Patience Diff creates more readable diffs than other algorithms in some cases, particularly when much of the content has changed between the documents being compared. There's a great explanation and example [here][example].
+
+Patience diff was originally written by Bram Cohen and is used in the [Bazaar][bazaar] version control system. This version is loosely based off the Python implementation in Bazaar.
+
+[example]: http://alfedenzo.livejournal.com/170301.html
+[bazaar]: http://bazaar.canonical.com/
+
+## INSTALL:
+
+    $ gem install patience_diff
+
+## USAGE:
+
+### Command line:
+
+    $ patience_diff [options] file-a file-b
+
+Run with `--help` to see available options.
+
+### Programmatically:
+
+    left = File.read("/path/to/old").split($RS)
+    left_timestamp = File.mtime("/path/to/old")
+    right = File.read("/path/to/new").split($RS)
+    right_timestamp = File.mtime("/path/to/new")
+
+    differ = PatienceDiff::UnifiedDiffer.new(:context => 10)
+    puts differ.diff(left, right, left_file, right_file, left_timestamp, right_timestamp)
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 Andrew Watt
+
+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/Rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :rubyforge
+
+Hoe.spec 'patience_diff' do
+  developer "Andrew Watt", "andrew@wattornot.com"
+  dependency "trollop", "~> 1.16"
+  self.rubyforge_name = 'patiencediff'
+end

data/bin/patience_diff

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+require 'English'
+require 'trollop'
+
+lib_path = File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+$LOAD_PATH.unshift(lib_path)
+require 'patience_diff'
+
+begin
+  opts = Trollop::options do
+    banner <<-EOF
+Usage: #{File.basename($0)} [options] left-file right-file
+Options:
+EOF
+    version "patience_diff #{PatienceDiff::VERSION}"
+    opt :debug, "Debugging mode"
+    opt :context, "Lines of context", :default => 3
+    opt :full_context, "Don't collapse common sections; output entire files"
+    opt :ignore_whitespace, 
+      "Ignore trailing whitespace, and treat leading whitespace as either present or not. This switch is for compatibility with diff's -b option.",
+      :short => '-b'
+  end
+  
+  raise PatienceDiff::UsageError unless ARGV.length == 2
+  
+  left_file, right_file = *ARGV
+  
+  left = File.read(left_file, :external_encoding => Encoding::BINARY).split($RS)
+  left_timestamp = File.mtime(left_file)
+  right = File.read(right_file, :external_encoding => Encoding::BINARY).split($RS)
+  right_timestamp = File.mtime(right_file)
+  
+  opts[:no_grouping] = opts[:full_context]
+  formatter = PatienceDiff::UnifiedDiffer.new(opts)
+  puts formatter.diff(left, right, left_file, right_file, left_timestamp, right_timestamp)
+  
+rescue PatienceDiff::UsageError => e
+  Trollop.module_eval do
+    @last_parser.educate($stderr)
+  end
+rescue StandardError => e
+  if opts[:debug]
+    raise
+  else
+    $stderr.puts "Error: #{e}"
+  end
+end

data/lib/patience_diff.rb

@@ -0,0 +1,8 @@
+require 'patience_diff/card'
+require 'patience_diff/sequence_matcher'
+require 'patience_diff/unified_differ'
+require 'patience_diff/usage_error'
+
+module PatienceDiff
+  VERSION = "1.0.1"
+end

data/lib/patience_diff/card.rb

@@ -0,0 +1,9 @@
+module PatienceDiff
+  class Card
+    attr_accessor :previous, :index, :value
+    def initialize(index, value)
+      @index = index
+      @value = value
+    end
+  end
+end

data/lib/patience_diff/sequence_matcher.rb

@@ -0,0 +1,253 @@
+require 'patience_diff/card'
+
+module PatienceDiff
+  class SequenceMatcher
+    attr_accessor :context
+    
+    def initialize(opts = {})
+      @context = opts[:context] || 3
+    end
+    
+    # Generate a diff of a and b using #diff_opcodes, and split the opcode into groups
+    # whenever an :equal range is encountered that is longer than @context * 2.
+    # Returns an array of arrays of 5-tuples as described for #diff_opcodes.
+    def grouped_opcodes(a, b)
+      groups = []
+      last_group = []
+      diff_opcodes(a, b).each do |opcode|
+        if opcode[0] == :equal
+          if @context.zero?
+            groups << last_group
+            last_group = []
+            next
+          end
+          
+          code, a_start, a_end, b_start, b_end = *opcode
+          
+          if (a_start.zero? and b_start.zero?) or (a_end == a.length-1 and b_end == b.length-1)
+            threshold = @context
+          else
+            threshold = @context * 2
+          end
+          
+          if (b_end - b_start + 1) > threshold
+            unless last_group.empty?
+              last_group << [
+                code,
+                a_start,
+                a_start + @context - 1,
+                b_start,
+                b_start + @context - 1
+              ]
+              groups << last_group
+              last_group = []
+            end
+            opcode = [
+              code, 
+              a_end - @context + 1,
+              a_end,
+              b_end - @context + 1,
+              b_end
+            ]
+          end
+        end
+        last_group << opcode
+      end
+      groups << last_group unless last_group.one? and last_group.first[0] == :equal
+      groups
+    end
+    
+    # Generate a diff of a and b, and return an array of opcodes describing that diff.
+    # Each opcode represents a range in a and b that is either equal, only in a,
+    # or only in b. Opcodes are 5-tuples, in the format:
+    #   0: code
+    #      A symbol indicating the diff operation. Can be :equal, :delete, or :insert.
+    #   1: a_start
+    #      Index in a where the range begins
+    #   2: a_end
+    #      Index in a where the range ends.
+    #   3: b_start
+    #      Index in b where the range begins
+    #   4: b_end
+    #      Index in b where the range ends.
+    #
+    # For :equal, (a_end - a_start) == (b_end - b_start).
+    # For :delete, a_start == a_end.
+    # For :insert, b_start == b_end.
+    def diff_opcodes(a, b)
+      sequences = collapse_matches(match(a, b))
+      sequences << [a.length, b.length, 0]
+  
+      a_pos = b_pos = 0
+      opcodes = []
+      sequences.each do |(i, j, len)|
+        if a_pos < i
+          opcodes << [:delete, a_pos, i-1, b_pos, b_pos]
+        end
+        if b_pos < j
+          opcodes << [:insert, a_pos, a_pos, b_pos, j-1]
+        end
+        if len > 0
+          opcodes << [:equal, i, i+len-1, j, j+len-1]
+        end
+        a_pos = i+len
+        b_pos = j+len
+      end
+      opcodes
+    end
+      
+    private
+    def match(a, b)
+      matches = []
+      recursively_match(a, b, 0, 0, a.length, b.length) do |match|
+        matches << match
+      end
+      matches
+    end
+    
+    def recursively_match(a, b, a_lo, b_lo, a_hi, b_hi)
+      return if a_lo == a_hi or b_lo == b_hi
+
+      last_a_pos = a_lo - 1
+      last_b_pos = b_lo - 1
+      
+      longest_unique_subsequence(a[a_lo...a_hi], b[b_lo...b_hi]).each do |(a_pos, b_pos)|
+        # recurse betwen unique lines
+        a_pos += a_lo
+        b_pos += b_lo
+        if (last_a_pos+1 != a_pos) or (last_b_pos+1 != b_pos)
+          recursively_match(a, b, last_a_pos+1, last_b_pos+1, a_pos, b_pos) { |match| yield match }
+        end
+        last_a_pos = a_pos
+        last_b_pos = b_pos
+        yield [a_pos, b_pos]
+      end
+      
+      if last_a_pos >= a_lo or last_b_pos >= b_lo
+        # there was at least one match
+        # recurse between last match and end
+        recursively_match(a, b, last_a_pos+1, last_b_pos+1, a_hi, b_hi) { |match| yield match }
+      elsif a[a_lo] == b[b_lo]
+        # no unique lines
+        # diff forward from beginning
+        while a_lo < a_hi and b_lo < b_hi and a[a_lo] == b[b_lo]
+          yield [a_lo, b_lo]
+          a_lo += 1
+          b_lo += 1
+        end
+        recursively_match(a, b, a_lo, b_lo, a_hi, b_hi) { |match| yield match }
+      elsif a[a_hi-1] == b[b_hi-1]
+        # no unique lines
+        # diff back from end
+        a_mid = a_hi - 1
+        b_mid = b_hi - 1
+        while a_mid > a_lo and b_mid > b_lo and a[a_mid-1] == b[b_mid-1]
+          a_mid -= 1
+          b_mid -= 1
+        end
+        recursively_match(a, b, a_lo, b_lo, a_mid, b_mid) { |match| yield match }
+        0...(a_hi-a_mid).each do |i|
+          yield [a_mid+i, b_mid+i]
+        end
+      end
+    end
+    
+    def collapse_matches(matches)
+      return [] if matches.empty?
+      sequences = []
+      start_a, start_b = *(matches.first)
+      len = 1
+      matches[1..-1].each do |(i_a, i_b)|
+        if i_a == start_a + len and i_b == start_b + len
+          len += 1
+        else
+          sequences << [start_a, start_b, len]
+          start_a = i_a
+          start_b = i_b
+          len = 1
+        end
+      end
+      sequences << [start_a, start_b, len]
+      sequences
+    end
+  
+    def longest_unique_subsequence(a, b)
+      deck = Array.new(b.length)
+      unique_a = {}
+      unique_b = {}
+      
+      a.each_with_index do |val, index|
+        if unique_a.has_key? val
+          unique_a[val] = nil
+        else
+          unique_a[val] = index
+        end
+      end
+      
+      b.each_with_index do |val, index|
+        a_index = unique_a[val]
+        next unless a_index
+        dupe_index = unique_b[val]
+        if dupe_index
+          deck[dupe_index] = nil
+          unique_a.delete(val)
+        else
+          unique_b[val] = index
+          deck[index] = a_index
+        end
+      end
+      
+      card = patience_sort(deck).last
+      result = []
+      while card
+        result.unshift [card.value, card.index]
+        card = card.previous
+      end
+      result
+    end
+  
+    def patience_sort(deck)
+      piles = []
+      pile = 0
+      deck.each_with_index do |card_value, index|
+        next if card_value.nil?
+        card = Card.new(index, card_value)
+        
+        if piles.any? and piles.last.value < card_value
+          pile = piles.size
+        elsif piles.any? and piles[pile].value < card_value and 
+              (pile == piles.size-1 or piles[pile+1].value > card_value)
+          pile += 1
+        else
+          pile = bisect(piles, card_value)
+        end
+        
+        card.previous = piles[pile-1] if pile > 0
+        
+        if pile < piles.size
+          #puts "putting card #{card.value} on pile #{pile}"
+          piles[pile] = card
+        else
+          #puts "putting card #{card.value} on new pile"
+          piles << card
+        end
+      end
+      
+      piles
+    end
+    
+    def bisect(piles, target)
+      low = 0
+      high = piles.size - 1
+      while (low <= high)
+        mid = (low + high)/2
+        if piles[mid].value < target
+          low = mid + 1
+        else
+          high = mid - 1
+        end
+      end
+      low
+    end
+  end
+end

data/lib/patience_diff/unified_differ.rb

@@ -0,0 +1,66 @@
+require 'English'
+
+module PatienceDiff
+  class UnifiedDiffer
+    attr_reader :matcher
+    attr_accessor :no_grouping, :line_ending, :ignore_whitespace
+    
+    def initialize(opts = {})
+      @no_grouping = opts.delete(:no_grouping)
+      @line_ending = opts.delete(:line_ending) || $RS
+      @ignore_whitespace = opts.delete(:ignore_whitespace)
+      @matcher = SequenceMatcher.new(opts)
+    end
+
+    def diff(left, right, left_name=nil, right_name=nil, left_timestamp=nil, right_timestamp=nil)
+      left_name ||= "Original"
+      right_name ||= "Current"
+      left_timestamp ||= right_timestamp || Time.now
+      right_timestamp ||= left_timestamp || Time.now
+      
+      if @ignore_whitespace
+        puts "ignoring whitespace"
+        a = left.map  { |line| line.rstrip.gsub(/^\s+/, ' ') }
+        b = right.map { |line| line.rstrip.gsub(/^\s+/, ' ') }
+      else
+        a = left
+        b = right
+      end
+      
+      if @no_grouping
+        groups = [@matcher.diff_opcodes(a, b)]
+      else
+        groups = @matcher.grouped_opcodes(a, b)
+      end
+      [
+        "--- %s\t%s" % [left_name, left_timestamp.strftime("%Y-%m-%d %H:%m:%S.%N %z")],
+        "+++ %s\t%s" % [right_name, right_timestamp.strftime("%Y-%m-%d %H:%m:%S.%N %z")],
+        groups.collect { |group| unified_diff_group(left, right, group) }.flatten.compact
+      ].join(@line_ending)
+    end
+    
+    private
+    def unified_diff_group(a, b, opcodes)
+      return nil if opcodes.empty?
+      
+      a_start = opcodes.first[1] + 1
+      a_end = opcodes.last[2] + 2
+      b_start = opcodes.first[3] + 1
+      b_end = opcodes.last[4] + 2
+      
+      lines = ["@@ -%d,%d +%d,%d @@" % [a_start, a_end-a_start, b_start, b_end-b_start]]
+      
+      lines << opcodes.collect do |(code, a_start, a_end, b_start, b_end)|
+        case code
+        when :equal
+          b[b_start..b_end].map { |line| ' ' + line }
+        when :delete
+          a[a_start..a_end].map { |line| '-' + line }
+        when :insert
+          b[b_start..b_end].map { |line| '+' + line }
+        end
+      end
+      lines
+    end
+  end
+end

data/lib/patience_diff/usage_error.rb

@@ -0,0 +1,3 @@
+module PatienceDiff
+  class UsageError < StandardError ; end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: patience_diff
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Watt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rubyforge
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: ! 'A Ruby implementation of the Patience diff algorithm.
+
+
+  Patience Diff creates more readable diffs than other algorithms in some cases, particularly
+  when much of the content has changed between the documents being compared. There''s
+  a great explanation and example [here][example].
+
+
+  Patience diff was originally written by Bram Cohen and is used in the [Bazaar][bazaar]
+  version control system. This version is loosely based off the Python implementation
+  in Bazaar.
+
+
+  [example]: http://alfedenzo.livejournal.com/170301.html
+
+  [bazaar]: http://bazaar.canonical.com/'
+email:
+- andrew@wattornot.com
+executables:
+- patience_diff
+extensions: []
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+files:
+- History.txt
+- Manifest.txt
+- README.md
+- Rakefile
+- bin/patience_diff
+- lib/patience_diff.rb
+- lib/patience_diff/card.rb
+- lib/patience_diff/sequence_matcher.rb
+- lib/patience_diff/unified_differ.rb
+- lib/patience_diff/usage_error.rb
+homepage: http://github.com/watt/ruby_patience_diff
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: patiencediff
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Ruby implementation of the Patience diff algorithm
+test_files: []