patience_diff 1.0.1 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d37dfbd16df805a3d8b286765fe5ea12c665c156
+  data.tar.gz: f3df94dd269cba9149197be6ea584fa3c8f3f103
+SHA512:
+  metadata.gz: c82eb37da25cbecb994d98fba1de7e355887a4576c7a50afa688d0e62f76c4887cc6d9f5a014d303fbfc92a1e17e6e999f7989ea17fcba6a06810885d786a212
+  data.tar.gz: 3c1fc29891874a7de6fcd510c466ec9c6088bff9ce6f8695f5c44b2a8035b52e708344c266b3f36b0b25cfc56d0534d1b2286da1109f49502e61b745d5c9b2ff

data/History.txt

@@ -1,3 +1,8 @@
+=== 1.1.0 / 2012-08-12
+
+* Introduced HTML output
+* Fixed some major bugs in the diffing algorithm
+
 === 1.0.1 / 2012-06-19
 
 * Renamed gem from 'ruby_patience_diff' to just 'patience_diff'

data/Manifest.txt

@@ -4,7 +4,15 @@ README.md
 Rakefile
 bin/patience_diff
 lib/patience_diff.rb
-lib/patience_diff/card.rb
+lib/patience_diff/differ.rb
+lib/patience_diff/formatter.rb
+lib/patience_diff/formatting_context.rb
 lib/patience_diff/sequence_matcher.rb
-lib/patience_diff/unified_differ.rb
 lib/patience_diff/usage_error.rb
+lib/patience_diff/html/escaping.rb
+lib/patience_diff/html/formatter.rb
+lib/patience_diff/html/header_helper.rb
+lib/patience_diff/html/hunk_helper.rb
+templates/html.erb
+templates/html_header.erb
+templates/html_hunk.erb

data/Rakefile

@@ -6,5 +6,4 @@ 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

@@ -1,38 +1,50 @@
 #!/usr/bin/env ruby
 require 'English'
+require 'pathname'
 require 'trollop'
 
-lib_path = File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+lib_path = Pathname(File.join(File.dirname(__FILE__),"..","lib")).realpath
 $LOAD_PATH.unshift(lib_path)
 require 'patience_diff'
 
 begin
+  program_name = File.basename($PROGRAM_NAME)
   opts = Trollop::options do
-    banner <<-EOF
-Usage: #{File.basename($0)} [options] left-file right-file
-Options:
-EOF
-    version "patience_diff #{PatienceDiff::VERSION}"
+    banner <<-EOF.gsub(/^\s*/, '')
+      Usage: #{program_name} [options] left-file right-file (left-file-2 right-file-2 ...)
+      Options:
+    EOF
+    
+    version "#{program_name} #{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 :all_context, "Don't collapse common sections; output entire files. Ignored in html format."
+    opt :format, "Specify output format. Currently 'text' and 'html' are supported.", :default => "text"
     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
+  raise PatienceDiff::UsageError unless ARGV.length and ARGV.length % 2 == 0
   
-  left_file, right_file = *ARGV
+  differ = PatienceDiff::Differ.new(opts)
+  formatter = case opts.delete(:format)
+    when 'text'
+      PatienceDiff::Formatter
+    when 'html'
+      PatienceDiff::Html::Formatter
+    else
+      raise PatienceDiff::UsageError
+    end.new(differ)
   
-  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)
+  formatter.format do |diff|
+    ARGV.each_slice(2) do |(left_file, right_file)|
+      diff.files left_file, right_file
+    end
+  end.tap do |result|
+    print result
+  end
   
 rescue PatienceDiff::UsageError => e
   Trollop.module_eval do

data/lib/patience_diff.rb

@@ -1,8 +1,12 @@
-require 'patience_diff/card'
+require 'pathname'
+require 'patience_diff/differ'
+require 'patience_diff/formatter'
+require 'patience_diff/formatting_context'
 require 'patience_diff/sequence_matcher'
-require 'patience_diff/unified_differ'
 require 'patience_diff/usage_error'
+PatienceDiff.autoload(:Html, 'patience_diff/html/formatter')
 
 module PatienceDiff
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
+  TEMPLATE_PATH = Pathname(File.join(File.dirname(__FILE__),'..','templates')).realpath
 end

data/lib/patience_diff/differ.rb

@@ -0,0 +1,63 @@
+require 'English'
+require 'patience_diff/formatter'
+require 'patience_diff/sequence_matcher'
+
+module PatienceDiff
+  class Differ
+    attr_reader :matcher
+    attr_accessor :all_context, :line_ending, :ignore_whitespace
+    
+    # Options:
+    #   * :all_context: Output the entirety of each file. This overrides the sequence matcher's context setting.
+    #   * :line_ending: Delimiter to use when joining diff output. Defaults to $RS.
+    #   * :ignore_whitespace: Before comparing lines, strip trailing whitespace, and treat leading whitespace 
+    #     as either present or not. Does not affect output.
+    # Any additional options (e.g. :context) are passed on to the sequence matcher.
+    def initialize(opts = {})
+      @all_context = opts.delete(:all_context)
+      @line_ending = opts.delete(:line_ending) || $RS
+      @ignore_whitespace = opts.delete(:ignore_whitespace)
+      @matcher = SequenceMatcher.new(opts)
+    end
+    
+    # Generates a unified diff from the contents of the files at the paths specified.
+    def diff_files(left_file, right_file, formatter=Formatter.new)
+      (left_data, left_timestamp), (right_data, right_timestamp) = [left_file, right_file].map do |filename|
+        # Read in binary encoding, so that we can diff any encoding and split() won't complain
+        File.open(filename, :external_encoding => Encoding::BINARY) do |file|
+          [file.read.split($RS), file.mtime]
+        end
+      end
+      diff_sequences(left_data, right_data, left_file, right_file, left_timestamp, right_timestamp, formatter)
+    end
+    
+    # Generate a unified diff of the data specified. The left and right values should be strings, or any other indexable, sortable data.
+    # File names and timestamps do not affect the diff algorithm, but are used in the header text.
+    def diff_sequences(left, right, left_name=nil, right_name=nil, left_timestamp=nil, right_timestamp=nil, formatter=Formatter.new)
+      if @ignore_whitespace
+        a = left.map  { |line| line.rstrip.gsub(/^\s+/, ' ') }
+        b = right.map { |line| line.rstrip.gsub(/^\s+/, ' ') }
+      else
+        a = left
+        b = right
+      end
+      
+      if @all_context
+        hunks = [@matcher.diff_opcodes(a, b)]
+      else
+        hunks = @matcher.grouped_opcodes(a, b)
+      end
+      
+      return nil unless hunks.any?
+      
+      lines = []
+      lines << formatter.render_header(left_name, right_name, left_timestamp, right_timestamp)
+      last_hunk_end = -1
+      hunks.each do |opcodes|
+        lines << formatter.render_hunk(a, b, opcodes, last_hunk_end)
+        last_hunk_end = opcodes.last[4]
+      end
+      lines.flatten.compact.join(@line_ending) + @line_ending
+    end
+  end
+end

data/lib/patience_diff/formatter.rb

@@ -0,0 +1,66 @@
+require 'patience_diff/formatting_context'
+
+module PatienceDiff
+  # Formats a plaintext unified diff.
+  class Formatter
+    attr_reader :names
+    attr_accessor :left_name, :right_name, :left_timestamp, :right_timestamp, :title
+    
+    def initialize(differ, title = nil)
+      @differ = differ
+      @names = []
+      @title = title || "Diff generated on #{Time.now.strftime('%c')}"
+    end
+        
+    def format
+      context = FormattingContext.new(@differ, self)
+      yield context
+      context.format
+    end
+    
+    def render_header(left_name=nil, right_name=nil, left_timestamp=nil, right_timestamp=nil)
+      @names << right_name
+      @left_name = left_name || "Original"
+      @right_name = right_name || "Current"
+      @left_timestamp = left_timestamp || Time.now
+      @right_timestamp = right_timestamp || Time.now
+      [
+        left_header_line(@left_name, @left_timestamp),
+        right_header_line(@right_name, @right_timestamp)
+      ]
+    end
+    
+    def render_hunk_marker(opcodes)
+      a_start = opcodes.first[1] + 1
+      a_end = opcodes.last[2] + 2
+      b_start = opcodes.first[3] + 1
+      b_end = opcodes.last[4] + 2
+      
+      "@@ -%d,%d +%d,%d @@" % [a_start, a_end-a_start, b_start, b_end-b_start]
+    end
+    
+    def render_hunk(a, b, opcodes, last_line_shown)
+      lines = [render_hunk_marker(opcodes)]
+      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
+    
+    private
+    def left_header_line(name, timestamp)
+      "--- %s\t%s" % [name, timestamp.strftime("%Y-%m-%d %H:%m:%S.%N %z")]
+    end
+    
+    def right_header_line(name, timestamp)
+      "+++ %s\t%s" % [name, timestamp.strftime("%Y-%m-%d %H:%m:%S.%N %z")]
+    end
+  end
+end

data/lib/patience_diff/formatting_context.rb

@@ -0,0 +1,36 @@
+require 'stringio'
+
+module PatienceDiff
+  # Delegate object yielded by the #format method.
+  class FormattingContext
+    def initialize(differ, formatter)
+      @differ = differ
+      @formatter = formatter
+      @out = StringIO.new
+    end
+    
+    def files(left_file, right_file)
+      @out.print @differ.diff_files(left_file, right_file, @formatter)
+    end
+    
+    def sequences(left, right, left_name=nil, right_name=nil, left_timestamp=nil, right_timestamp=nil)
+      @out.print @differ.diff_sequences(left, right, left_name, right_name, left_timestamp, right_timestamp, @formatter)
+    end
+    
+    def orphan(sequence, name=nil, timestamp=nil)
+      @out.print @formatter.render_orphan(sequence, name, timestamp)
+    end
+    
+    def format
+      @out.string
+    end
+    
+    def title
+      @formatter.title
+    end
+    
+    def names
+      @formatter.names
+    end
+  end
+end

data/lib/patience_diff/html/escaping.rb

@@ -0,0 +1,12 @@
+require 'cgi'
+
+module PatienceDiff
+  module Html
+    module Escaping
+      # Escapes text for HTML output
+      def escape(raw)
+        CGI::escape_html(raw.to_s)
+      end
+    end
+  end
+end

data/lib/patience_diff/html/formatter.rb

@@ -0,0 +1,71 @@
+require 'patience_diff/formatter'
+require 'patience_diff/formatting_context'
+require 'patience_diff/html/header_helper'
+require 'patience_diff/html/hunk_helper'
+
+require 'erubis'
+
+module PatienceDiff
+  module Html
+    
+    # Produces a fancy HTML-formatted unified diff. All your friends will be jealous.
+    class Formatter < PatienceDiff::Formatter
+      def initialize(*args)
+        super(*args)
+        @erbs = Hash.new do |hash, key|
+          hash[key] = Erubis::Eruby.new(File.read(key))
+        end
+        @hunk_count = 0
+      end
+      
+      def format
+        context = FormattingContext.new(@differ, self)
+        yield context
+        template.evaluate(context)
+      end
+            
+      def render_header(*args)
+        left_header, right_header = *super(*args)
+        helper = HeaderHelper.new(left_header, right_header, @names.count - 1)
+        template("html_header.erb").evaluate(helper)
+      end
+      
+      def render_hunk(a, b, opcodes, last_hunk_end)
+        helper = hunk_context(a, b, render_hunk_marker(opcodes), opcodes, last_hunk_end)
+        template("html_hunk.erb").evaluate(helper)
+      end
+      
+      # Render a single file as if it were a diff with no changes & full context
+      def render_orphan(sequence, name, timestamp)
+        @names << name
+        left_header = "--- New file"
+        right_header = right_header_line(name, timestamp)
+        helper = HeaderHelper.new(left_header, right_header, @names.count - 1)
+        result = template("html_header.erb").evaluate(helper)
+        
+        # create one opcode with the entire content
+        opcodes = [
+          [:equal, 0, sequence.length-1, 0, sequence.length-1]
+        ]
+        helper = hunk_context(sequence, sequence, nil, opcodes, 0)
+        result << template("html_hunk.erb").evaluate(helper)
+        result
+      end
+      
+      private
+      def template(filename = "html.erb")
+        @erbs[template_path(filename)]
+      end
+      
+      # override to add/change templates
+      def template_path(filename)
+        File.join(PatienceDiff::TEMPLATE_PATH, filename)
+      end
+      
+      def hunk_context(a, b, hunk_marker, opcodes, last_hunk_end)
+        @hunk_count += 1
+        HunkHelper.new(a, b, render_hunk_marker(opcodes), opcodes, last_hunk_end, @hunk_count)
+      end
+    end
+  end
+end

data/lib/patience_diff/html/header_helper.rb

@@ -0,0 +1,16 @@
+require 'patience_diff/html/escaping'
+
+module PatienceDiff
+  module Html
+    class HeaderHelper
+      include Escaping
+      attr_accessor :left_header, :right_header, :header_id
+      
+      def initialize(left_header, right_header, header_id)
+        @left_header = left_header
+        @right_header = right_header
+        @header_id = header_id
+      end
+    end
+  end
+end

data/lib/patience_diff/html/hunk_helper.rb

@@ -0,0 +1,50 @@
+require 'patience_diff/html/escaping'
+
+module PatienceDiff
+  module Html
+    class HunkHelper
+      include Escaping
+      attr_accessor :a, :b, :hunk_marker, :opcodes, :last_hunk_end, :hunk_id
+      
+      def initialize(a, b, hunk_marker, opcodes, last_hunk_end, hunk_id)
+        @a = a
+        @b = b
+        @hunk_marker = hunk_marker
+        @opcodes = opcodes
+        @last_hunk_end = last_hunk_end
+        @hunk_id = hunk_id
+      end
+      
+      def hunk_start
+        @opcodes.first[3]
+      end
+      
+      def hidden_line_count
+        hunk_start - @last_hunk_end - 1
+      end
+      
+      def lines
+        @b
+      end
+      
+      def each_line
+        opcodes.each do |(code, a_start, a_end, b_start, b_end)|
+          case code
+          when :delete
+            a[a_start..a_end].each { |line| yield 'delete', '-' + format_line(line) }
+          when :equal
+            b[b_start..b_end].each { |line| yield 'equal',  ' ' + format_line(line) }
+          when :insert
+            b[b_start..b_end].each { |line| yield 'insert', '+' + format_line(line) }
+          end
+        end
+      end
+      
+      private
+      # override for additional behavior, e.g. syntax highlighting
+      def format_line(line)
+        escape(line)
+      end
+    end
+  end
+end

data/lib/patience_diff/sequence_matcher.rb

@@ -1,9 +1,12 @@
-require 'patience_diff/card'
-
 module PatienceDiff
+  # Matches indexed data (generally text) using the Patience diff algorithm.
   class SequenceMatcher
     attr_accessor :context
     
+    Card = Struct.new(:index, :value, :previous)
+    
+    # Options:
+    #   * :context: number of lines of context to use when grouping
     def initialize(opts = {})
       @context = opts[:context] || 3
     end
@@ -146,7 +149,7 @@ module PatienceDiff
           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|
+        (0...(a_hi-a_mid)).each do |i|
           yield [a_mid+i, b_mid+i]
         end
       end

data/templates/html.erb

@@ -0,0 +1,307 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8" />
+	<title><%= title %></title>
+	<style>
+	body {
+		font-family: Consolas, Menlo, Monaco, monospace;
+		font-size: 8pt;
+	}
+	.diff, .marker { white-space: pre; }
+	.diff:hover    { background-color: #ff9; }
+	.delete        { background-color: #fdd; }
+	.insert        { background-color: #dfd; }
+	.divider {
+		position: relative;
+		background-color: #cce5ff; /* hsl(210, 100%, 90%) */
+		background-image: -webkit-linear-gradient(top, hsl(210, 100%, 95%) 0%, hsl(210, 100%, 90%) 100%);
+		background-image: -moz-linear-gradient(top, hsl(210, 100%, 95%) 0%, hsl(210, 100%, 90%) 100%);
+		background-image: -o-linear-gradient(top, hsl(210, 100%, 95%) 0%, hsl(210, 100%, 90%) 100%);
+		background-image: linear-gradient(top, hsl(210, 100%, 95%) 0%, hsl(210, 100%, 90%) 100%);
+		font-family: Calibri, "Lucida Grande", sans-serif;
+		border: solid 1px #b3cce6; /* hsl(210, 50%, 80%) */
+		padding: 0 2px;
+		border-radius: 3px;
+		cursor: default;
+	}
+	.toggle:hover {
+		background-image: -webkit-linear-gradient(top, hsl(210, 100%, 90%) 0%, hsl(210, 100%, 80%) 100%);
+		background-image: -moz-linear-gradient(top, hsl(210, 100%, 90%) 0%, hsl(210, 100%, 80%) 100%);
+		background-image: -o-linear-gradient(top, hsl(210, 100%, 90%) 0%, hsl(210, 100%, 80%) 100%);
+		background-image: linear-gradient(top, hsl(210, 100%, 90%) 0%, hsl(210, 100%, 80%) 100%);
+		border: solid 1px #39f; /* hsl(210, 100%, 60%) */
+	}
+	.marker { 
+		color: #000080; 
+		font-family: Consolas, Menlo, Monaco, monospace;
+		position: absolute;
+	}
+	.hint {
+		color: #999;
+		text-align: center;
+	}
+	.divider:hover .hint                  { color: black; }
+	.down_arrow, .up_arrow                { position: relative; }
+	.down_arrow:after, .down_arrow:before { top: 100%; }
+	.up_arrow:after, .up_arrow:before     { bottom: 100%; }
+	.down_arrow:after, .down_arrow:before, .up_arrow:after, .up_arrow:before {
+		border: solid transparent;
+		content: " ";
+		height: 0;
+		width: 0;
+		position: absolute;
+		left: 50%;
+	}
+	.down_arrow:after, .up_arrow:after   { border-width: 5px; margin-left: -5px; }
+	.down_arrow:before, .up_arrow:before { border-width: 6px; margin-left: -6px; }
+	.down_arrow:after                    { border-top-color:    hsl(210, 100%, 90%); }
+	.up_arrow:after                      { border-bottom-color: hsl(210, 100%, 95%); }
+	.down_arrow:before                   { border-top-color:    hsl(210,  50%, 80%); }
+	.up_arrow:before                     { border-bottom-color: hsl(210,  50%, 80%); }
+	.toggle:hover .down_arrow:after      { border-top-color:    hsl(210, 100%, 80%); }
+	.toggle:hover .down_arrow:before     { border-top-color:    hsl(210, 100%, 60%); }
+	.toggle:hover .up_arrow:after        { border-bottom-color: hsl(210, 100%, 90%); }
+	.toggle:hover .up_arrow:before       { border-bottom-color: hsl(210, 100%, 60%); }
+	.left_header                { page-break-before: always; }
+	.left_header, .right_header { background-color: #ddd; color: #222; }
+	#content .collapsed {
+		-webkit-transition: bottom .5s, height .5s;
+		-moz-transition:    bottom .5s, height .5s;
+		-o-transition:      bottom .5s, height .5s;
+		transition:         bottom .5s, height .5s;
+		height: 0;
+    overflow: hidden
+  }
+	#nav_container {
+		position: fixed;
+		top: 0;
+		right: 0;
+		border-radius: 4px 0 0 4px / 50% 0 0 50%;
+		box-shadow: 0 0 8px 0 rgba(0,0,0,.5);
+		-webkit-transition: opacity 1s, bottom .5s, height .5s;
+		-moz-transition:    opacity 1s, bottom .5s, height .5s;
+		-o-transition:      opacity 1s, bottom .5s, height .5s;
+		transition:         opacity 1s, bottom .5s, height .5s;
+	}
+	#nav {
+		position: absolute;
+		top: 0;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		border-left: solid 1px #999;
+		overflow: hidden;
+		background: #eee;
+		background-image: -webkit-linear-gradient(left, #e7e7e7 0%, #eee 25%, #eee 75%, #e7e7e7 100%);
+		background-image: -moz-linear-gradient(left, #e7e7e7 0%, #eee 25%, #eee 75%, #e7e7e7 100%);
+		background-image: -o-linear-gradient(left, #e7e7e7 0%, #eee 25%, #eee 75%, #e7e7e7 100%);
+		background-image: linear-gradient(left, #e7e7e7 0%, #eee 25%, #eee 75%, #e7e7e7 100%);
+		font-family: Calibri, "Lucida Grande", sans-serif;
+		font-size: 10pt;
+	}
+	#nav_scroll {
+		position: absolute;
+		top: 1.75em;
+		bottom: 0;
+		right: 0;
+		overflow-x: hidden;
+		overflow-y: auto;
+	}
+	#nav button {
+		height: 1.75em;
+		margin: 0;
+		width: 100%;
+		background: #ddd;
+		background-image: -webkit-linear-gradient(top, #eee 0%, #ccc 100%);
+		background-image: -moz-linear-gradient(top, #eee 0%, #ccc 100%);
+		background-image: -o-linear-gradient(top, #eee 0%, #ccc 100%);
+		background-image: linear-gradient(top, #eee 0%, #ccc 100%);
+		border: none;
+		border-top: solid white 1px;
+		border-bottom: solid #999 1px;
+		font-family: Calibri, "Lucida Grande", sans-serif;
+		font-size: 10pt;
+		text-shadow: 0 1px 0 white;
+	}
+	#nav button:hover {
+		background: #eee;
+		background-image: -webkit-linear-gradient(top, #fff 0%, #ddd 100%);
+		background-image: -moz-linear-gradient(top, #fff 0%, #ddd 100%);
+		background-image: -o-linear-gradient(top, #fff 0%, #ddd 100%);
+		background-image: linear-gradient(top, #fff 0%, #ddd 100%);
+	}
+	#nav button:active {
+		border-top: solid black 1px;
+		background: #333;
+		background-image: -webkit-linear-gradient(top, #333 0%, #666 100%);
+		background-image: -moz-linear-gradient(top, #333 0%, #666 100%);
+		background-image: -o-linear-gradient(top, #333 0%, #666 100%);
+		background-image: linear-gradient(top, #333 0%, #666 100%);
+		color: white;
+		text-shadow: 0 1px 0 black;
+	}
+	#nav_container.collapsed { opacity: 0.33; }
+	#nav_container.collapsed:hover {
+		opacity: 1;
+		-webkit-transition: opacity 0s, bottom .5s, height .5s;
+		-moz-transition:    opacity 0s, bottom .5s, height .5s;
+		-o-transition:      opacity 0s, bottom .5s, height .5s;
+		transition:         opacity 0s, bottom .5s, height .5s;
+	}
+	#nav ol      { margin: 0.5em; padding: 0 15px 0 30px; }
+	#nav a       { color: black; text-decoration: none; display: block; width: 100%; }
+	#nav a:hover { color: gray; }
+	#nav_container.no_animation {
+		-webkit-transition: none;
+		-moz-transition: none;
+		-o-transition: all 0 none;
+		transition: none;
+	}
+	</style>
+	<script>
+	function $(id) {
+		return document.getElementById(id);
+	}
+	function show(id) {
+		$(id).style.display = "";
+	}
+	function hide(id) {
+		$(id).style.display = "none";
+	}
+	function hasClass(el, classname) {
+		var classes = el.className.split(/\s+/);
+		for (var i = 0, len = classes.length; i < len; i++) {
+			if (classes[i] == classname)
+				return true;
+		}
+		return false;
+	}
+	function init() {
+		// Set nav container width to the natural width of its absolutely positioned content
+		var navWidth = $("nav_scroll").offsetWidth;
+		var container = $("nav_container");
+		container.style.width = navWidth + "px";
+		if (container.addEventListener) {
+			container.addEventListener("webkitTransitionEnd", page.navTransitioned);
+			container.addEventListener("transitionend", page.navTransitioned);
+			container.addEventListener("oTransitionEnd", page.navTransitioned);
+		}
+		$("nav_hide").onclick = page.hideNav;
+		$("nav_show").onclick = page.showNav;
+		
+		// set up nav links
+		function createJump(id) {
+			return function() {
+				page.jump(id);
+				return false;
+			}
+		}
+		var jumps = $("nav_list").getElementsByTagName("a");
+		for (var i = 0, len = jumps.length; i < len; i++) {
+			jumps[i].onclick = createJump("header_" + i);
+		}
+		
+		// set up toggling of collapsed lines
+		function createToggle(hunkStart) {
+			return function() {
+				page.toggleCollapse(hunkStart);
+				return false;
+			}
+		}
+		var divs = $("content").getElementsByTagName("div");
+		for (var i = 0, len = divs.length; i < len; i++) {
+			var div = divs[i];
+			if (hasClass(div, "toggle")) {
+				var hunkStart = parseInt(div.id.replace(/^[^\d]*/,""));
+				if (hunkStart) {
+					div.onclick = createToggle(hunkStart);
+				}
+			}
+		}
+	}
+	function windowHeight() {
+		return window.innerHeight || document.documentElement.clientHeight;
+	}
+	page = {
+		hideNav: function() {
+			hide("nav_hide");
+			show("nav_show");
+			var container = $("nav_container");
+			var buttonHeight = $("nav_buttons").offsetHeight + "px";
+			container.className = "no_animation";
+			// set a fixed height, and clear the bottom
+			container.style.height = windowHeight() + "px";
+			container.style.bottom = "auto";
+			// this is a hack to make sure the height is recalculated so that the transition animation triggers
+			setTimeout(function() {
+				container.className = "";
+				container.style.height = buttonHeight;
+			}, 10);
+		},
+		showNav: function() {
+			hide("nav_show");
+			show("nav_hide");
+			var container = $("nav_container");
+			container.className = "no_animation";
+			// set a fixed bottom, and clear the height
+			container.style.bottom = (windowHeight() - $("nav_buttons").offsetHeight) + "px";
+			container.style.height = "auto";
+			setTimeout(function() {
+				container.className = "";
+				container.style.bottom = "0";
+			}, 10);
+		},
+		navTransitioned: function() {
+			var container = $("nav_container");
+			if (!container.classList)
+				return;
+			if (container.style.bottom === "auto") {
+				container.classList.add("collapsed");
+			} else {
+				container.classList.remove("collapsed");
+			}
+		},
+		jump: function(id) {
+			scrollTo(0,$(id).offsetTop);
+		},
+		toggleCollapse: function(line) {
+			var growDiv = $("hunk_" + line);
+			if (growDiv.offsetHeight) {
+				growDiv.style.height = 0;
+				hide("collapse_" + line);
+				show("expand_" + line);
+			} else {
+				var wrapper = growDiv.getElementsByTagName("div")[0];
+				growDiv.style.height = wrapper.offsetHeight + "px";
+				hide("expand_" + line);
+				show("collapse_" + line);
+			}
+		}
+	}
+	</script>
+	<!--[if lte IE 7]>
+	<style>
+	.unicode { font-family: "Lucida Sans Unicode"; }
+	</style>
+	<![endif]-->
+</head>
+<body onload="init();">
+	<div id="content"><%= format %></div>
+	<% if names.count > 1 %>
+	<div id="nav_container" style="bottom: 0; height: 100%"><div id="nav">
+		<div id="nav_buttons">
+			<button id="nav_hide"><span class="unicode">&#x25be;</span> Navigation</button>
+			<button id="nav_show" style="display: none"><span class="unicode">&#x25b8;</span> Navigation</button>
+		</div>
+		<div id="nav_scroll">
+			<ol id="nav_list">
+			<% names.each_with_index do |name, i| %>
+				<li><a href="#header_<%= i %>"><%= name %></a></li>
+			<% end %>
+			</ol>
+		</div>
+	</div></div>
+	<% end %>
+</body>
+</html>

data/templates/html_header.erb

@@ -0,0 +1,4 @@
+<div id="header_<%= header_id %>">
+	<div class="left_header diff"><%= escape(left_header) %></div>
+	<div class="right_header diff"><%= escape(right_header) %></div>
+</div>

data/templates/html_hunk.erb

@@ -0,0 +1,30 @@
+<% if hidden_line_count > 0 %>
+	<div class="collapsed" id="hunk_<%= hunk_id %>">
+		<div>
+			<div class="divider toggle" id="toggle_collapse_<%= hunk_id %>">
+				<div class="hint down_arrow">Click to collapse <%= hidden_line_count %> lines</div>
+			</div>
+			<% lines[(last_hunk_end+1)...hunk_start].each do |line| %>
+				<div class="equal diff"> <%= format_line(line) %></div>
+			<% end %>
+		</div>
+	</div>
+	<div class="divider toggle" id="toggle_expand_<%= hunk_id %>">
+		<span class="marker"><%= escape(hunk_marker) %></span>
+		<div class="hint down_arrow" id="expand_<%= hunk_id %>">
+			Click to expand <%= hidden_line_count %> lines
+		</div>
+		<div class="hint up_arrow" id="collapse_<%= hunk_id %>" style="display: none">
+			Click to collapse <%= hidden_line_count %> lines
+		</div>
+	</div>
+<% elsif hunk_marker.to_s == "" %>
+	<div class="divider">
+		<span class="marker"><%= escape(hunk_marker) %></span>
+		&nbsp;
+	</div>
+<% end %>
+
+<% each_line do |code, formatted_line| %>
+	<div class="<%= code %> diff"><%= formatted_line %></div>
+<% end %>

metadata

@@ -1,96 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: patience_diff
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrew Watt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-21 00:00:00.000000000 Z
+date: 2014-10-23 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'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.13'
   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].
+        version: '3.13'
+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.
-
+  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/'
+  [bazaar]: http://bazaar.canonical.com/
 email:
 - andrew@wattornot.com
 executables:
@@ -99,6 +69,7 @@ extensions: []
 extra_rdoc_files:
 - History.txt
 - Manifest.txt
+- README.md
 files:
 - History.txt
 - Manifest.txt
@@ -106,34 +77,42 @@ files:
 - Rakefile
 - bin/patience_diff
 - lib/patience_diff.rb
-- lib/patience_diff/card.rb
+- lib/patience_diff/differ.rb
+- lib/patience_diff/formatter.rb
+- lib/patience_diff/formatting_context.rb
+- lib/patience_diff/html/escaping.rb
+- lib/patience_diff/html/formatter.rb
+- lib/patience_diff/html/header_helper.rb
+- lib/patience_diff/html/hunk_helper.rb
 - lib/patience_diff/sequence_matcher.rb
-- lib/patience_diff/unified_differ.rb
 - lib/patience_diff/usage_error.rb
+- templates/html.erb
+- templates/html_header.erb
+- templates/html_hunk.erb
 homepage: http://github.com/watt/ruby_patience_diff
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--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
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A Ruby implementation of the Patience diff algorithm
 test_files: []

data/lib/patience_diff/card.rb

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

data/lib/patience_diff/unified_differ.rb

@@ -1,66 +0,0 @@
-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