RubyGems - purdypatch - Versions diffs - 0.0.1 - Mend

purdypatch 0.0.1

Files changed (14) hide show

data/.gitignore +17 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +18 -0
data/Rakefile +1 -0
data/bin/purdypatch +5 -0
data/lib/prettypatch/PrettyPatch.rb +818 -0
data/lib/prettypatch/PrettyPatch_test.rb +99 -0
data/lib/prettypatch/diff.rb +164 -0
data/lib/prettypatch/prettify.rb +37 -0
data/lib/purdypatch/version.rb +3 -0
data/lib/purdypatch.rb +44 -0
data/purdypatch.gemspec +20 -0
metadata +77 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in purdypatch.gemspec
+gemspec

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+Copyright (c) 2013, Nathan de Vries
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md ADDED Viewed

@@ -0,0 +1,18 @@
+Purdy Patch
+===========
+This gem provides a `purdypatch` tool for improving the format of `git-format-patch` emails, making them easier for reviewers to read and reply to in a decentralized, email-based review system.
+It uses the incredibly useful [PrettyPatch formatter](http://svn.webkit.org/repository/webkit/trunk/Websites/bugs.webkit.org/PrettyPatch/), which is used by the patch review system on [bugs.webkit.org](https://bugs.webkit.org).
+To get started, simply run `gem install purdypatch` to install the tool.
+Once you have `purdypatch` installed, here's a simple workflow for sending out a patch for review:
+    $ git format-patch --to="Doge <sohip@suchclass.com>" --attach HEAD~1
+    $ purdypatch *.patch
+    $ git send-email *.purdypatch
+According to [Devil’s Dictionary of Programming](http://programmingisterrible.com/post/65781074112/devils-dictionary-of-programming), `purdypatch` is simple, opinionated *and* lightweight.
+Enjoy.

data/Rakefile ADDED Viewed

	@@ -0,0 +1 @@
1	+ require "bundler/gem_tasks"

data/bin/purdypatch ADDED Viewed

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'purdypatch'
+PurdyPatch::CLI.start(*ARGV)

data/lib/prettypatch/PrettyPatch.rb ADDED Viewed

@@ -0,0 +1,818 @@
+require 'cgi'
+require 'diff'
+require 'open3'
+require 'open-uri'
+require 'pp'
+require 'set'
+require 'tempfile'
+module PrettyPatch
+public
+    GIT_PATH = "git"
+    def self.prettify(string)
+        $last_prettify_file_count = -1
+        $last_prettify_part_count = { "remove" => 0, "add" => 0, "shared" => 0, "binary" => 0, "extract-error" => 0 }
+        string = normalize_line_ending(string)
+        str = "#{HEADER}<body>\n"
+        # Just look at the first line to see if it is an SVN revision number as added
+        # by webkit-patch for git checkouts.
+        $svn_revision = 0
+        string.each_line do |line|
+            match = /^Subversion\ Revision: (\d*)$/.match(line)
+            unless match.nil?
+                str << "<span class='revision'>#{match[1]}</span>\n"
+                $svn_revision = match[1].to_i;
+            end
+            break
+        end
+        fileDiffs = FileDiff.parse(string)
+        $last_prettify_file_count = fileDiffs.length
+        str << fileDiffs.collect{ |diff| diff.to_html }.join
+        str << "</body></html>"
+    end
+    def self.filename_from_diff_header(line)
+        DIFF_HEADER_FORMATS.each do |format|
+            match = format.match(line)
+            return match[1] unless match.nil?
+        end
+        nil
+    end
+    def self.diff_header?(line)
+        RELAXED_DIFF_HEADER_FORMATS.any? { |format| line =~ format }
+    end
+private
+    DIFF_HEADER_FORMATS = [
+        /^Index: (.*)\r?$/,
+        /^diff --git "?a\/.+"? "?b\/(.+)"?\r?$/,
+        /^\+\+\+ ([^\t]+)(\t.*)?\r?$/
+    ]
+    RELAXED_DIFF_HEADER_FORMATS = [
+        /^Index:/,
+        /^diff/
+    ]
+    BINARY_FILE_MARKER_FORMAT = /^Cannot display: file marked as a binary type.$/
+    IMAGE_FILE_MARKER_FORMAT = /^svn:mime-type = image\/png$/
+    GIT_INDEX_MARKER_FORMAT = /^index ([0-9a-f]{40})\.\.([0-9a-f]{40})/
+    GIT_BINARY_FILE_MARKER_FORMAT = /^GIT binary patch$/
+    GIT_BINARY_PATCH_FORMAT = /^(literal|delta) \d+$/
+    GIT_LITERAL_FORMAT = /^literal \d+$/
+    GIT_DELTA_FORMAT = /^delta \d+$/
+    START_OF_BINARY_DATA_FORMAT = /^[0-9a-zA-Z\+\/=]{20,}/ # Assume 20 chars without a space is base64 binary data.
+    START_OF_SECTION_FORMAT = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@\s*(.*)/
+    START_OF_EXTENT_STRING = "%c" % 0
+    END_OF_EXTENT_STRING = "%c" % 1
+    # We won't search for intra-line diffs in lines longer than this length, to avoid hangs. See <http://webkit.org/b/56109>.
+    MAXIMUM_INTRALINE_DIFF_LINE_LENGTH = 10000
+    SMALLEST_EQUAL_OPERATION = 3
+    OPENSOURCE_TRAC_URL = "http://trac.webkit.org/"
+    OPENSOURCE_DIRS = Set.new %w[
+        Examples
+        LayoutTests
+        PerformanceTests
+        Source
+        Tools
+        WebKitLibraries
+        Websites
+    ]
+    IMAGE_CHECKSUM_ERROR = "INVALID: Image lacks a checksum. This will fail with a MISSING error in run-webkit-tests. Always generate new png files using run-webkit-tests."
+    def self.normalize_line_ending(s)
+        if RUBY_VERSION >= "1.9"
+            # Transliteration table from http://stackoverflow.com/a/6609998
+            transliteration_table = { '\xc2\x82' => ',',        # High code comma
+                                      '\xc2\x84' => ',,',       # High code double comma
+                                      '\xc2\x85' => '...',      # Tripple dot
+                                      '\xc2\x88' => '^',        # High carat
+                                      '\xc2\x91' => '\x27',     # Forward single quote
+                                      '\xc2\x92' => '\x27',     # Reverse single quote
+                                      '\xc2\x93' => '\x22',     # Forward double quote
+                                      '\xc2\x94' => '\x22',     # Reverse double quote
+                                      '\xc2\x95' => ' ',
+                                      '\xc2\x96' => '-',        # High hyphen
+                                      '\xc2\x97' => '--',       # Double hyphen
+                                      '\xc2\x99' => ' ',
+                                      '\xc2\xa0' => ' ',
+                                      '\xc2\xa6' => '|',        # Split vertical bar
+                                      '\xc2\xab' => '<<',       # Double less than
+                                      '\xc2\xbb' => '>>',       # Double greater than
+                                      '\xc2\xbc' => '1/4',      # one quarter
+                                      '\xc2\xbd' => '1/2',      # one half
+                                      '\xc2\xbe' => '3/4',      # three quarters
+                                      '\xca\xbf' => '\x27',     # c-single quote
+                                      '\xcc\xa8' => '',         # modifier - under curve
+                                      '\xcc\xb1' => ''          # modifier - under line
+                                   }
+            encoded_string = s.force_encoding('UTF-8').encode('UTF-16', :invalid => :replace, :replace => '', :fallback => transliteration_table).encode('UTF-8')
+            encoded_string.gsub /\r\n?/, "\n"
+        else
+            s.gsub /\r\n?/, "\n"
+        end
+    end
+    def self.find_url_and_path(file_path)
+        # Search file_path from the bottom up, at each level checking whether
+        # we've found a directory we know exists in the source tree.
+        dirname, basename = File.split(file_path)
+        dirname.split(/\//).reverse.inject(basename) do |path, directory|
+            path = directory + "/" + path
+            return [OPENSOURCE_TRAC_URL, path] if OPENSOURCE_DIRS.include?(directory)
+            path
+        end
+        [nil, file_path]
+    end
+    def self.linkifyFilename(filename)
+        url, pathBeneathTrunk = find_url_and_path(filename)
+        url.nil? ? filename : "<a href='#{url}browser/trunk/#{pathBeneathTrunk}'>#{filename}</a>"
+    end
+    HEADER =<<EOF
+<html>
+<head>
+<meta charset='utf-8'>
+<style>
+:link, :visited {
+    text-decoration: none;
+    border-bottom: 1px dotted;
+}
+:link {
+    color: #039;
+}
+.FileDiff {
+    background-color: #f8f8f8;
+    border: 1px solid #ddd;
+    font-family: monospace;
+    margin: 1em 0;
+    position: relative;
+}
+h1 {
+    color: #333;
+    font-family: sans-serif;
+    font-size: 1em;
+    margin-left: 0.5em;
+    display: table-cell;
+    width: 100%;
+    padding: 0.5em;
+}
+h1 :link, h1 :visited {
+    color: inherit;
+}
+h1 :hover {
+    color: #555;
+    background-color: #eee;
+}
+.DiffLinks {
+    float: right;
+}
+.FileDiffLinkContainer {
+    opacity: 0;
+    display: table-cell;
+    padding-right: 0.5em;
+    white-space: nowrap;
+}
+.DiffSection {
+    background-color: white;
+    border: solid #ddd;
+    border-width: 1px 0px;
+}
+.ExpansionLine, .LineContainer {
+    white-space: nowrap;
+}
+.sidebyside .DiffBlockPart.add:first-child {
+    float: right;
+}
+.LineSide,
+.sidebyside .DiffBlockPart.remove,
+.sidebyside .DiffBlockPart.add {
+    display:inline-block;
+    width: 50%;
+    vertical-align: top;
+}
+.sidebyside .resizeHandle {
+    width: 5px;
+    height: 100%;
+    cursor: move;
+    position: absolute;
+    top: 0;
+    left: 50%;
+}
+.sidebyside .resizeHandle:hover {
+    background-color: grey;
+    opacity: 0.5;
+}
+.sidebyside .DiffBlockPart.remove .to,
+.sidebyside .DiffBlockPart.add .from {
+    display: none;
+}
+.lineNumber, .expansionLineNumber {
+    border-bottom: 1px solid #998;
+    border-right: 1px solid #ddd;
+    color: #444;
+    display: inline-block;
+    padding: 1px 5px 0px 0px;
+    text-align: right;
+    vertical-align: bottom;
+    width: 3em;
+}
+.lineNumber {
+  background-color: #eed;
+}
+.expansionLineNumber {
+  background-color: #eee;
+}
+pre, .text {
+    padding-left: 5px;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+}
+.image {
+    border: 2px solid black;
+}
+.context, .context .lineNumber {
+    color: #849;
+    background-color: #fef;
+}
+.Line.add, .FileDiff .add {
+    background-color: #dfd;
+}
+.Line.add ins {
+    background-color: #9e9;
+    text-decoration: none;
+}
+.Line.remove, .FileDiff .remove {
+    background-color: #fdd;
+}
+.Line.remove del {
+    background-color: #e99;
+    text-decoration: none;
+}
+div:focus {
+  outline: 1px solid blue;
+  outline-offset: -1px;
+}
+.revision {
+  display: none;
+}
+.clear_float {
+    clear: both;
+}
+</style>
+</head>
+EOF
+    def self.revisionOrDescription(string)
+        case string
+        when /\(revision \d+\)/
+            /\(revision (\d+)\)/.match(string)[1]
+        when /\(.*\)/
+            /\((.*)\)/.match(string)[1]
+        end
+    end
+    def self.has_image_suffix(filename)
+        filename =~ /\.(png|jpg|gif)$/
+    end
+    class FileDiff
+        def initialize(lines)
+            @filename = PrettyPatch.filename_from_diff_header(lines[0].chomp)
+            startOfSections = 1
+            for i in 0...lines.length
+                case lines[i]
+                when /^--- /
+                    @from = PrettyPatch.revisionOrDescription(lines[i])
+                when /^\+\+\+ /
+                    @filename = PrettyPatch.filename_from_diff_header(lines[i].chomp) if @filename.nil?
+                    @to = PrettyPatch.revisionOrDescription(lines[i])
+                    startOfSections = i + 1
+                    break
+                when BINARY_FILE_MARKER_FORMAT
+                    @binary = true
+                    if (IMAGE_FILE_MARKER_FORMAT.match(lines[i + 1]) or PrettyPatch.has_image_suffix(@filename)) then
+                        @image = true
+                        startOfSections = i + 2
+                        for x in startOfSections...lines.length
+                            # Binary diffs often have property changes listed before the actual binary data.  Skip them.
+                            if START_OF_BINARY_DATA_FORMAT.match(lines[x]) then
+                                startOfSections = x
+                                break
+                            end
+                        end
+                    end
+                    break
+                when GIT_INDEX_MARKER_FORMAT
+                    @git_indexes = [$1, $2]
+                when GIT_BINARY_FILE_MARKER_FORMAT
+                    @binary = true
+                    if (GIT_BINARY_PATCH_FORMAT.match(lines[i + 1]) and PrettyPatch.has_image_suffix(@filename)) then
+                        @git_image = true
+                        startOfSections = i + 1
+                    end
+                    break
+                end
+            end
+            lines_with_contents = lines[startOfSections...lines.length]
+            @sections = DiffSection.parse(lines_with_contents) unless @binary
+            if @image and not lines_with_contents.empty?
+                @image_url = "data:image/png;base64," + lines_with_contents.join
+                @image_checksum = FileDiff.read_checksum_from_png(lines_with_contents.join.unpack("m").join)
+            elsif @git_image
+                begin
+                    raise "index line is missing" unless @git_indexes
+                    chunks = nil
+                    for i in 0...lines_with_contents.length
+                        if lines_with_contents[i] =~ /^$/
+                            chunks = [lines_with_contents[i + 1 .. -1], lines_with_contents[0 .. i]]
+                            break
+                        end
+                    end
+                    raise "no binary chunks" unless chunks
+                    from_filepath = FileDiff.extract_contents_of_from_revision(@filename, chunks[0], @git_indexes[0])
+                    to_filepath = FileDiff.extract_contents_of_to_revision(@filename, chunks[1], @git_indexes[1], from_filepath, @git_indexes[0])
+                    filepaths = from_filepath, to_filepath
+                    binary_contents = filepaths.collect { |filepath| File.exists?(filepath) ? File.read(filepath) : nil }
+                    @image_urls = binary_contents.collect { |content| (content and not content.empty?) ? "data:image/png;base64," + [content].pack("m") : nil }
+                    @image_checksums = binary_contents.collect { |content| FileDiff.read_checksum_from_png(content) }
+                rescue
+                    $last_prettify_part_count["extract-error"] += 1
+                    @image_error = "Exception raised during decoding git binary patch:<pre>#{CGI.escapeHTML($!.to_s + "\n" + $!.backtrace.join("\n"))}</pre>"
+                ensure
+                    File.unlink(from_filepath) if (from_filepath and File.exists?(from_filepath))
+                    File.unlink(to_filepath) if (to_filepath and File.exists?(to_filepath))
+                end
+            end
+            nil
+        end
+        def image_to_html
+            if not @image_url then
+                return "<span class='text'>Image file removed</span>"
+            end
+            image_checksum = ""
+            if @image_checksum
+                image_checksum = @image_checksum
+            elsif @filename.include? "-expected.png" and @image_url
+                image_checksum = IMAGE_CHECKSUM_ERROR
+            end
+            return "<p>" + image_checksum + "</p><img class='image' src='" + @image_url + "' />"
+        end
+        def to_html
+            str = "<div class='FileDiff'>\n"
+            str += "<h1>#{PrettyPatch.linkifyFilename(@filename)}</h1>\n"
+            if @image then
+                str += self.image_to_html
+            elsif @git_image then
+                if @image_error
+                    str += @image_error
+                else
+                    for i in (0...2)
+                        image_url = @image_urls[i]
+                        image_checksum = @image_checksums[i]
+                        style = ["remove", "add"][i]
+                        str += "<p class=\"#{style}\">"
+                        if image_checksum
+                            str += image_checksum
+                        elsif @filename.include? "-expected.png" and image_url
+                            str += IMAGE_CHECKSUM_ERROR
+                        end
+                        str += "<br>"
+                        if image_url
+                            str += "<img class='image' src='" + image_url + "' />"
+                        else
+                            str += ["</p>Added", "</p>Removed"][i]
+                        end
+                    end
+                end
+            elsif @binary then
+                $last_prettify_part_count["binary"] += 1
+                str += "<span class='text'>Binary file, nothing to see here</span>"
+            else
+                str += @sections.collect{ |section| section.to_html }.join("<br>\n") unless @sections.nil?
+            end
+            if @from then
+                str += "<span class='revision'>" + @from + "</span>"
+            end
+            str += "</div>\n"
+        end
+        def self.parse(string)
+            haveSeenDiffHeader = false
+            linesForDiffs = []
+            string.each_line do |line|
+                if (PrettyPatch.diff_header?(line))
+                    linesForDiffs << []
+                    haveSeenDiffHeader = true
+                elsif (!haveSeenDiffHeader && line =~ /^--- /)
+                    linesForDiffs << []
+                    haveSeenDiffHeader = false
+                end
+                linesForDiffs.last << line unless linesForDiffs.last.nil?
+            end
+            linesForDiffs.collect { |lines| FileDiff.new(lines) }
+        end
+        def self.read_checksum_from_png(png_bytes)
+            # Ruby 1.9 added the concept of string encodings, so to avoid treating binary data as UTF-8,
+            # we can force the encoding to binary at this point.
+            if RUBY_VERSION >= "1.9"
+                png_bytes.force_encoding('binary')
+            end
+            match = png_bytes && png_bytes.match(/tEXtchecksum\0([a-fA-F0-9]{32})/)
+            match ? match[1] : nil
+        end
+        def self.git_new_file_binary_patch(filename, encoded_chunk, git_index)
+            return <<END
+diff --git a/#{filename} b/#{filename}
+new file mode 100644
+index 0000000000000000000000000000000000000000..#{git_index}
+GIT binary patch
+#{encoded_chunk.join("")}literal 0
+HcmV?d00001
+END
+        end
+        def self.git_changed_file_binary_patch(to_filename, from_filename, encoded_chunk, to_git_index, from_git_index)
+            return <<END
+diff --git a/#{from_filename} b/#{to_filename}
+copy from #{from_filename}
++++ b/#{to_filename}
+index #{from_git_index}..#{to_git_index}
+GIT binary patch
+#{encoded_chunk.join("")}literal 0
+HcmV?d00001
+END
+        end
+        def self.get_svn_uri(repository_path)
+            "http://svn.webkit.org/repository/webkit/!svn/bc/" + $svn_revision.to_s + "/trunk/" + (repository_path)
+        end
+        def self.get_new_temp_filepath_and_name
+            tempfile = Tempfile.new("PrettyPatch")
+            filepath = tempfile.path + '.bin'
+            filename = File.basename(filepath)
+            return filepath, filename
+        end
+        def self.download_from_revision_from_svn(repository_path)
+            filepath, filename = get_new_temp_filepath_and_name
+            svn_uri = get_svn_uri(repository_path)
+            open(filepath, 'wb') do |to_file|
+                to_file << open(svn_uri) { |from_file| from_file.read }
+            end
+            return filepath
+        end
+        def self.run_git_apply_on_patch(output_filepath, patch)
+            # Apply the git binary patch using git-apply.
+            cmd = GIT_PATH + " apply --directory=" + File.dirname(output_filepath)
+            stdin, stdout, stderr = *Open3.popen3(cmd)
+            begin
+                stdin.puts(patch)
+                stdin.close
+                error = stderr.read
+                if error != ""
+                    error = "Error running " + cmd + "\n" + "with patch:\n" + patch[0..500] + "...\n" + error
+                end
+                raise error if error != ""
+            ensure
+                stdin.close unless stdin.closed?
+                stdout.close
+                stderr.close
+            end
+        end
+        def self.extract_contents_from_git_binary_literal_chunk(encoded_chunk, git_index)
+            filepath, filename = get_new_temp_filepath_and_name
+            patch = FileDiff.git_new_file_binary_patch(filename, encoded_chunk, git_index)
+            run_git_apply_on_patch(filepath, patch)
+            return filepath
+        end
+        def self.extract_contents_from_git_binary_delta_chunk(from_filepath, from_git_index, encoded_chunk, to_git_index)
+            to_filepath, to_filename = get_new_temp_filepath_and_name
+            from_filename = File.basename(from_filepath)
+            patch = FileDiff.git_changed_file_binary_patch(to_filename, from_filename, encoded_chunk, to_git_index, from_git_index)
+            run_git_apply_on_patch(to_filepath, patch)
+            return to_filepath
+        end
+        def self.extract_contents_of_from_revision(repository_path, encoded_chunk, git_index)
+            # For literal encoded, simply reconstruct.
+            if GIT_LITERAL_FORMAT.match(encoded_chunk[0])
+                return extract_contents_from_git_binary_literal_chunk(encoded_chunk, git_index)
+            end
+            #  For delta encoded, download from svn.
+            if GIT_DELTA_FORMAT.match(encoded_chunk[0])
+                return download_from_revision_from_svn(repository_path)
+            end
+            raise "Error: unknown git patch encoding"
+        end
+        def self.extract_contents_of_to_revision(repository_path, encoded_chunk, git_index, from_filepath, from_git_index)
+            # For literal encoded, simply reconstruct.
+            if GIT_LITERAL_FORMAT.match(encoded_chunk[0])
+                return extract_contents_from_git_binary_literal_chunk(encoded_chunk, git_index)
+            end
+            # For delta encoded, reconstruct using delta and previously constructed 'from' revision.
+            if GIT_DELTA_FORMAT.match(encoded_chunk[0])
+                return extract_contents_from_git_binary_delta_chunk(from_filepath, from_git_index, encoded_chunk, git_index)
+            end
+            raise "Error: unknown git patch encoding"
+        end
+    end
+    class DiffBlock
+        attr_accessor :parts
+        def initialize(container)
+            @parts = []
+            container << self
+        end
+        def to_html
+            str = "<div class='DiffBlock'>\n"
+            str += @parts.collect{ |part| part.to_html }.join
+            str += "<div class='clear_float'></div></div>\n"
+        end
+    end
+    class DiffBlockPart
+        attr_reader :className
+        attr :lines
+        def initialize(className, container)
+            $last_prettify_part_count[className] += 1
+            @className = className
+            @lines = []
+            container.parts << self
+        end
+        def to_html
+            str = "<div class='DiffBlockPart %s'>\n" % @className
+            str += @lines.collect{ |line| line.to_html }.join
+            # Don't put white-space after this so adjacent inline-block DiffBlockParts will not wrap.
+            str += "</div>"
+        end
+    end
+    class DiffSection
+        def initialize(lines)
+            lines.length >= 1 or raise "DiffSection.parse only received %d lines" % lines.length
+            matches = START_OF_SECTION_FORMAT.match(lines[0])
+            if matches
+                from, to = [matches[1].to_i, matches[3].to_i]
+                if matches[2] and matches[4]
+                    from_end = from + matches[2].to_i
+                    to_end = to + matches[4].to_i
+                end
+            end
+            @blocks = []
+            diff_block = nil
+            diff_block_part = nil
+            for line in lines[1...lines.length]
+                startOfLine = line =~ /^[-\+ ]/ ? 1 : 0
+                text = line[startOfLine...line.length].chomp
+                case line[0]
+                when ?-
+                    if (diff_block_part.nil? or diff_block_part.className != 'remove')
+                        diff_block = DiffBlock.new(@blocks)
+                        diff_block_part = DiffBlockPart.new('remove', diff_block)
+                    end
+                    diff_block_part.lines << CodeLine.new(from, nil, text)
+                    from += 1 unless from.nil?
+                when ?+
+                    if (diff_block_part.nil? or diff_block_part.className != 'add')
+                        # Put add lines that immediately follow remove lines into the same DiffBlock.
+                        if (diff_block.nil? or diff_block_part.className != 'remove')
+                            diff_block = DiffBlock.new(@blocks)
+                        end
+                        diff_block_part = DiffBlockPart.new('add', diff_block)
+                    end
+                    diff_block_part.lines << CodeLine.new(nil, to, text)
+                    to += 1 unless to.nil?
+                else
+                    if (diff_block_part.nil? or diff_block_part.className != 'shared')
+                        diff_block = DiffBlock.new(@blocks)
+                        diff_block_part = DiffBlockPart.new('shared', diff_block)
+                    end
+                    diff_block_part.lines << CodeLine.new(from, to, text)
+                    from += 1 unless from.nil?
+                    to += 1 unless to.nil?
+                end
+                break if from_end and to_end and from == from_end and to == to_end
+            end
+            changes = [ [ [], [] ] ]
+            for block in @blocks
+                for block_part in block.parts
+                    for line in block_part.lines
+                        if (!line.fromLineNumber.nil? and !line.toLineNumber.nil?) then
+                            changes << [ [], [] ]
+                            next
+                        end
+                        changes.last.first << line if line.toLineNumber.nil?
+                        changes.last.last << line if line.fromLineNumber.nil?
+                    end
+                end
+            end
+            for change in changes
+                next unless change.first.length == change.last.length
+                for i in (0...change.first.length)
+                    from_text = change.first[i].text
+                    to_text = change.last[i].text
+                    next if from_text.length > MAXIMUM_INTRALINE_DIFF_LINE_LENGTH or to_text.length > MAXIMUM_INTRALINE_DIFF_LINE_LENGTH
+                    raw_operations = HTMLDiff::DiffBuilder.new(from_text, to_text).operations
+                    operations = []
+                    back = 0
+                    raw_operations.each_with_index do |operation, j|
+                        if operation.action == :equal and j < raw_operations.length - 1
+                           length = operation.end_in_new - operation.start_in_new
+                           if length < SMALLEST_EQUAL_OPERATION
+                               back = length
+                               next
+                           end
+                        end
+                        operation.start_in_old -= back
+                        operation.start_in_new -= back
+                        back = 0
+                        operations << operation
+                    end
+                    change.first[i].operations = operations
+                    change.last[i].operations = operations
+                end
+            end
+            @blocks.unshift(ContextLine.new(matches[5])) unless matches.nil? || matches[5].empty?
+        end
+        def to_html
+            str = "<div class='DiffSection'>\n"
+            str += @blocks.collect{ |block| block.to_html }.join
+            str += "</div>\n"
+        end
+        def self.parse(lines)
+            linesForSections = lines.inject([[]]) do |sections, line|
+                sections << [] if line =~ /^@@/
+                sections.last << line
+                sections
+            end
+            linesForSections.delete_if { |lines| lines.nil? or lines.empty? }
+            linesForSections.collect { |lines| DiffSection.new(lines) }
+        end
+    end
+    class Line
+        attr_reader :fromLineNumber
+        attr_reader :toLineNumber
+        attr_reader :text
+        def initialize(from, to, text)
+            @fromLineNumber = from
+            @toLineNumber = to
+            @text = text
+        end
+        def text_as_html
+            CGI.escapeHTML(text)
+        end
+        def classes
+            lineClasses = ["Line", "LineContainer"]
+            lineClasses << ["add"] unless @toLineNumber.nil? or !@fromLineNumber.nil?
+            lineClasses << ["remove"] unless @fromLineNumber.nil? or !@toLineNumber.nil?
+            lineClasses
+        end
+        def to_html
+            markedUpText = self.text_as_html
+            str = "<div class='%s'>\n" % self.classes.join(' ')
+            str += "<span class='from lineNumber'>%s</span><span class='to lineNumber'>%s</span>" %
+                   [@fromLineNumber.nil? ? '&nbsp;' : @fromLineNumber,
+                    @toLineNumber.nil? ? '&nbsp;' : @toLineNumber] unless @fromLineNumber.nil? and @toLineNumber.nil?
+            str += "<span class='text'>%s</span>\n" % markedUpText
+            str += "</div>\n"
+        end
+    end
+    class CodeLine < Line
+        attr :operations, true
+        def text_as_html
+            html = []
+            tag = @fromLineNumber.nil? ? "ins" : "del"
+            if @operations.nil? or @operations.empty?
+                return CGI.escapeHTML(@text)
+            end
+            @operations.each do |operation|
+                start = @fromLineNumber.nil? ? operation.start_in_new : operation.start_in_old
+                eend = @fromLineNumber.nil? ? operation.end_in_new : operation.end_in_old
+                escaped_text = CGI.escapeHTML(@text[start...eend])
+                if eend - start === 0 or operation.action === :equal
+                    html << escaped_text
+                else
+                    html << "<#{tag}>#{escaped_text}</#{tag}>"
+                end
+            end
+            html.join
+        end
+    end
+    class ContextLine < Line
+        def initialize(context)
+            super("@", "@", context)
+        end
+        def classes
+            super << "context"
+        end
+    end
+end

data/lib/prettypatch/PrettyPatch_test.rb ADDED Viewed

@@ -0,0 +1,99 @@
+#!/usr/bin/ruby
+require 'test/unit'
+require 'open-uri'
+require 'PrettyPatch'
+# Note: internet connection is needed to run this test suite.
+class PrettyPatch_test < Test::Unit::TestCase
+    class Info
+        TITLE = 0
+        FILE = 1
+        ADD = 2
+        REMOVE = 3
+        SHARED = 4
+    end
+    PATCHES = {
+        20510 => ["Single change", 1, 1, 0, 2],
+        20528 => ["No 'Index' or 'diff' in patch header", 1, 4, 3, 7],
+        21151 => ["Leading '/' in the path of files", 4, 9, 1, 16],
+        # Binary files use shared blocks, there are three in 30488.
+        30488 => ["Quoted filenames in git diff", 23, 28, 25, 64 + 3],
+        23920 => ["Mac line ending", 3, 3, 0, 5],
+        39615 => ["Git signature", 2, 2, 0, 3],
+        80852 => ["Changes one line plus ChangeLog", 2, 2, 1, 4],
+        83127 => ["Only add stuff", 2, 2, 0, 3],
+        85071 => ["Adds and removes from a file plus git signature", 2, 5, 3, 9],
+        106368 => ["Images with git delta binary patch", 69, 8, 23, 10],
+    }
+    def get_patch_uri(id)
+        "https://bugs.webkit.org/attachment.cgi?id=" + id.to_s
+    end
+    def get_patch(id)
+        result = nil
+        patch_uri = get_patch_uri(id)
+        begin
+            result = open(patch_uri) { |f| result = f.read }
+        rescue => exception
+            assert(false, "Fail to get patch " + patch_uri)
+        end
+        result
+    end
+    def check_one_patch(id, info)
+        patch = get_patch(id)
+        description = get_patch_uri(id)
+        description +=  " (" + info[Info::TITLE] + ")" unless info[Info::TITLE].nil?
+        puts "Testing " + description
+        pretty = nil
+        assert_nothing_raised("Crash while prettifying " + description) {
+            pretty = PrettyPatch.prettify(patch)
+        }
+        assert(pretty, "Empty result while prettifying " + description)
+        assert_equal(info[Info::FILE], $last_prettify_file_count, "Wrong number of files changed in " + description)
+        assert_equal(info[Info::ADD], $last_prettify_part_count["add"], "Wrong number of 'add' parts in " + description)
+        assert_equal(info[Info::REMOVE], $last_prettify_part_count["remove"], "Wrong number of 'remove' parts in " + description)
+        assert_equal(info[Info::SHARED], $last_prettify_part_count["shared"], "Wrong number of 'shared' parts in " + description)
+        assert_equal(0, $last_prettify_part_count["binary"], "Wrong number of 'binary' parts in " + description)
+        assert_equal(0, $last_prettify_part_count["extract-error"], "Wrong number of 'extract-error' parts in " + description)
+        return pretty
+    end
+    def test_patches
+        PATCHES.each { |id, info| check_one_patch(id, info) }
+    end
+    def test_images_without_checksum
+        pretty = check_one_patch(144064, ["Images without checksums", 10, 5, 4, 8])
+        matches = pretty.match("INVALID: Image lacks a checksum.")
+        # FIXME: This should match, but there's a bug when running the tests where the image data
+        # doesn't get properly written out to the temp files, so there is no image and we don't print
+        # the warning that the image is missing its checksum.
+        assert(!matches, "Should have invalid checksums")
+        # FIXME: This should only have 4 invalid images, but due to the above tempfile issue, there are 0.
+        assert_equal(0, pretty.scan(/INVALID\: Image lacks a checksum\./).size)
+    end
+    def test_new_image
+        pretty = check_one_patch(145881, ["New image", 19, 36, 19, 56])
+        matches = pretty.match("INVALID: Image lacks a checksum.")
+        assert(!matches, "Should not have invalid checksums")
+    end
+    def test_images_correctly_without_checksum_git
+        pretty = check_one_patch(101620, ["Images correctly without checksums git", 7, 15, 10, 26])
+        matches = pretty.match("INVALID: Image lacks a checksum.")
+        assert(!matches, "Png should lack a checksum without an error.")
+    end
+    def test_images_correctly_without_checksum_svn
+        pretty = check_one_patch(31202, ["Images correctly without checksums svn", 4, 4, 1, 4])
+        matches = pretty.match("INVALID: Image lacks a checksum.")
+        assert(!matches, "Png should lack a checksum without an error.")
+    end
+end

data/lib/prettypatch/diff.rb ADDED Viewed

@@ -0,0 +1,164 @@
+module HTMLDiff
+  Match = Struct.new(:start_in_old, :start_in_new, :size)
+  class Match
+    def end_in_old
+      self.start_in_old + self.size
+    end
+    def end_in_new
+      self.start_in_new + self.size
+    end
+  end
+  Operation = Struct.new(:action, :start_in_old, :end_in_old, :start_in_new, :end_in_new)
+  class DiffBuilder
+    def initialize(old_version, new_version)
+      @old_version, @new_version = old_version, new_version
+      split_inputs_to_words
+      index_new_words
+    end
+    def split_inputs_to_words
+      @old_words = explode(@old_version)
+      @new_words = explode(@new_version)
+    end
+    def index_new_words
+      @word_indices = Hash.new { |h, word| h[word] = [] }
+      @new_words.each_with_index { |word, i| @word_indices[word] << i }
+    end
+    def operations
+      position_in_old = position_in_new = 0
+      operations = []
+      matches = matching_blocks
+      # an empty match at the end forces the loop below to handle the unmatched tails
+      # I'm sure it can be done more gracefully, but not at 23:52
+      matches << Match.new(@old_words.length, @new_words.length, 0)
+      matches.each_with_index do |match, i|
+        match_starts_at_current_position_in_old = (position_in_old == match.start_in_old)
+        match_starts_at_current_position_in_new = (position_in_new == match.start_in_new)
+        action_upto_match_positions =
+          case [match_starts_at_current_position_in_old, match_starts_at_current_position_in_new]
+          when [false, false]
+            :replace
+          when [true, false]
+            :insert
+          when [false, true]
+            :delete
+          else
+            # this happens if the first few words are same in both versions
+            :none
+          end
+        if action_upto_match_positions != :none
+          operation_upto_match_positions =
+              Operation.new(action_upto_match_positions,
+                  position_in_old, match.start_in_old,
+                  position_in_new, match.start_in_new)
+          operations << operation_upto_match_positions
+        end
+        if match.size != 0
+          match_operation = Operation.new(:equal,
+              match.start_in_old, match.end_in_old,
+              match.start_in_new, match.end_in_new)
+          operations << match_operation
+        end
+        position_in_old = match.end_in_old
+        position_in_new = match.end_in_new
+      end
+      operations
+    end
+    def matching_blocks
+      matching_blocks = []
+      recursively_find_matching_blocks(0, @old_words.size, 0, @new_words.size, matching_blocks)
+      matching_blocks
+    end
+    def recursively_find_matching_blocks(start_in_old, end_in_old, start_in_new, end_in_new, matching_blocks)
+      match = find_match(start_in_old, end_in_old, start_in_new, end_in_new)
+      if match
+        if start_in_old < match.start_in_old and start_in_new < match.start_in_new
+          recursively_find_matching_blocks(
+              start_in_old, match.start_in_old, start_in_new, match.start_in_new, matching_blocks)
+        end
+        matching_blocks << match
+        if match.end_in_old < end_in_old and match.end_in_new < end_in_new
+          recursively_find_matching_blocks(
+              match.end_in_old, end_in_old, match.end_in_new, end_in_new, matching_blocks)
+        end
+      end
+    end
+    def find_match(start_in_old, end_in_old, start_in_new, end_in_new)
+      best_match_in_old = start_in_old
+      best_match_in_new = start_in_new
+      best_match_size = 0
+      match_length_at = Hash.new { |h, index| h[index] = 0 }
+      start_in_old.upto(end_in_old - 1) do |index_in_old|
+        new_match_length_at = Hash.new { |h, index| h[index] = 0 }
+        @word_indices[@old_words[index_in_old]].each do |index_in_new|
+          next  if index_in_new < start_in_new
+          break if index_in_new >= end_in_new
+          new_match_length = match_length_at[index_in_new - 1] + 1
+          new_match_length_at[index_in_new] = new_match_length
+          if new_match_length > best_match_size
+            best_match_in_old = index_in_old - new_match_length + 1
+            best_match_in_new = index_in_new - new_match_length + 1
+            best_match_size = new_match_length
+          end
+        end
+        match_length_at = new_match_length_at
+      end
+#      best_match_in_old, best_match_in_new, best_match_size = add_matching_words_left(
+#          best_match_in_old, best_match_in_new, best_match_size, start_in_old, start_in_new)
+#      best_match_in_old, best_match_in_new, match_size = add_matching_words_right(
+#          best_match_in_old, best_match_in_new, best_match_size, end_in_old, end_in_new)
+      return (best_match_size != 0 ? Match.new(best_match_in_old, best_match_in_new, best_match_size) : nil)
+    end
+    def add_matching_words_left(match_in_old, match_in_new, match_size, start_in_old, start_in_new)
+      while match_in_old > start_in_old and
+            match_in_new > start_in_new and
+            @old_words[match_in_old - 1] == @new_words[match_in_new - 1]
+        match_in_old -= 1
+        match_in_new -= 1
+        match_size += 1
+      end
+      [match_in_old, match_in_new, match_size]
+    end
+    def add_matching_words_right(match_in_old, match_in_new, match_size, end_in_old, end_in_new)
+      while match_in_old + match_size < end_in_old and
+            match_in_new + match_size < end_in_new and
+            @old_words[match_in_old + match_size] == @new_words[match_in_new + match_size]
+        match_size += 1
+      end
+      [match_in_old, match_in_new, match_size]
+    end
+    def explode(sequence)
+      sequence.is_a?(String) ? sequence.split(//) : sequence
+    end
+  end # of class Diff Builder
+end

data/lib/prettypatch/prettify.rb ADDED Viewed

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'pathname'
+require 'webrick/htmlutils'
+$LOAD_PATH << Pathname.new(__FILE__).dirname.realpath.to_s
+require 'PrettyPatch'
+BACKTRACE_SEPARATOR = "\n\tfrom "
+options = { :html_exceptions => false }
+OptionParser.new do |opts|
+    opts.banner = "Usage: #{File.basename($0)} [options] [patch-file]"
+    opts.separator ""
+    opts.on("--html-exceptions", "Print exceptions to stdout as HTML") { |h| options[:html_exceptions] = h }
+end.parse!
+patch_data = nil
+if ARGV.length == 0 || ARGV[0] == '-' then
+    patch_data = $stdin.read
+else
+    File.open(ARGV[0]) { |file| patch_data = file.read }
+end
+begin
+    puts PrettyPatch.prettify(patch_data)
+rescue => exception
+    raise unless options[:html_exceptions]
+    backtrace = exception.backtrace
+    backtrace[0] += ": " + exception + " (" + exception.class.to_s + ")"
+    print "<pre>\n", WEBrick::HTMLUtils::escape(backtrace.join(BACKTRACE_SEPARATOR)), "\n</pre>\n"
+end

data/lib/purdypatch/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module PurdyPatch
+  VERSION = "0.0.1"
+end

data/lib/purdypatch.rb ADDED Viewed

@@ -0,0 +1,44 @@
+require 'mail'
+require 'pathname'
+require 'purdypatch/version'
+require 'prettypatch/PrettyPatch'
+module PurdyPatch
+  class CLI
+    def self.start(*args)
+      if args.empty?
+        puts "purdypatch expects one or more files created via `git format-patch --attach [ <since> | <revision range> ]`."
+        exit
+      end
+      args.each do |arg|
+        patch_mail_path = Pathname.new(arg)
+        next unless patch_mail_path.exist?
+        mail = Mail.read(patch_mail_path)
+        parts = mail.parts.dup
+        purdified = false
+        parts.each_with_index do |part, i|
+          next unless part.attachment? && part.content_type =~ %r(text/x-patch)
+          purdy_part = Mail::Part.new do
+            content_type 'text/html; charset=UTF-8'
+            body PrettyPatch.prettify(part.body.decoded)
+          end
+          mail.parts.insert(i, purdy_part)
+          mail.header['X-Formatter'] = "PurdyPatch-#{PurdyPatch::VERSION}"
+          purdified = true
+        end
+        if purdified
+          purdy_patch_mail_path = patch_mail_path.sub_ext('.purdypatch')
+          File.open(purdy_patch_mail_path, File::CREAT | File::TRUNC | File::RDWR) do |f|
+            f.write mail.to_s
+          end
+          puts %Q(Purdified patch email saved to "#{purdy_patch_mail_path}".)
+        end
+      end
+    end
+  end
+end

data/purdypatch.gemspec ADDED Viewed

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'purdypatch/version'
+Gem::Specification.new do |gem|
+  gem.name          = "purdypatch"
+  gem.version       = PurdyPatch::VERSION
+  gem.authors       = ["Nathan de Vries"]
+  gem.email         = ["nathan@atnan.com"]
+  gem.description   = %q{A tool for improving the format of git-format-patch emails, making them easier to review.}
+  gem.summary       = %q{Make your git-format-patch emails all purdy like.}
+  gem.homepage      = "https://github.com/atnan/purdypatch"
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.require_paths = ["lib", "lib/prettypatch"]
+  gem.add_dependency "mail"
+end

metadata ADDED Viewed

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: purdypatch
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease:
+platform: ruby
+authors:
+- Nathan de Vries
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A tool for improving the format of git-format-patch emails, making them
+  easier to review.
+email:
+- nathan@atnan.com
+executables:
+- purdypatch
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/purdypatch
+- lib/prettypatch/PrettyPatch.rb
+- lib/prettypatch/PrettyPatch_test.rb
+- lib/prettypatch/diff.rb
+- lib/prettypatch/prettify.rb
+- lib/purdypatch.rb
+- lib/purdypatch/version.rb
+- purdypatch.gemspec
+homepage: https://github.com/atnan/purdypatch
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- lib/prettypatch
+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:
+rubygems_version: 1.8.23
+signing_key:
+specification_version: 3
+summary: Make your git-format-patch emails all purdy like.
+test_files: []