amp-pure 0.5.0

data/lib/amp/dependencies/zip/ziprequire.rb

@@ -0,0 +1,90 @@
+# With ziprequire you can load ruby modules from a zip file. This means
+# ruby's module include path can include zip-files.
+#
+# The following example creates a zip file with a single entry 
+# <code>log/simplelog.rb</code> that contains a single function 
+# <code>simpleLog</code>: 
+#
+#   require 'zip/zipfilesystem'
+#   
+#   Zip::ZipFile.open("my.zip", true) {
+#     |zf| 
+#     zf.file.open("log/simplelog.rb", "w") { 
+#       |f|
+#       f.puts "def simpleLog(v)"
+#       f.puts '  Kernel.puts "INFO: #{v}"'
+#       f.puts "end"
+#     }
+#   }
+#
+# To use the ruby module stored in the zip archive simply require
+# <code>zip/ziprequire</code> and include the <code>my.zip</code> zip 
+# file in the module search path. The following command shows one 
+# way to do this:
+#
+#   ruby -rzip/ziprequire -Imy.zip  -e " require 'log/simplelog'; simpleLog 'Hello world' "
+
+#$: << 'data/rubycode.zip' << 'data/rubycode2.zip'
+
+
+need{ 'zip' }
+
+class ZipList #:nodoc:all
+  def initialize(zipFileList)
+      @zipFileList = zipFileList
+  end
+
+  def get_input_stream(entry, &aProc)
+    @zipFileList.each {
+      |zfName|
+      Zip::ZipFile.open(zfName) {
+	|zf|
+	begin
+	  return zf.get_input_stream(entry, &aProc) 
+	rescue Errno::ENOENT
+	end
+      }
+    }
+    raise Errno::ENOENT,
+      "No matching entry found in zip files '#{@zipFileList.join(', ')}' "+
+      " for '#{entry}'"
+  end
+end
+
+
+module Kernel #:nodoc:all
+  alias :oldRequire :require
+
+  def require(moduleName)
+    zip_require(moduleName) || oldRequire(moduleName)
+  end
+
+  def zip_require(moduleName)
+    return false if already_loaded?(moduleName)
+    get_resource(ensure_rb_extension(moduleName)) { 
+      |zis| 
+      eval(zis.read); $" << moduleName 
+    }
+    return true
+  rescue Errno::ENOENT => ex
+    return false
+  end
+
+  def get_resource(resourceName, &aProc)
+    zl = ZipList.new($:.grep(/\.zip$/))
+    zl.get_input_stream(resourceName, &aProc)
+  end
+
+  def already_loaded?(moduleName)
+    moduleRE = Regexp.new("^"+moduleName+"(\.rb|\.so|\.dll|\.o)?$")
+    $".detect { |e| e =~ moduleRE } != nil
+  end
+
+  def ensure_rb_extension(aString)
+    aString.sub(/(\.rb)?$/i, ".rb")
+  end
+end
+
+# Copyright (C) 2002 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/amp/encoding/base85.rb

@@ -0,0 +1,97 @@
+# = Amp
+module Amp
+  # = Encoding
+  module Encoding
+    # This class provides methods for encoding and decoding to base85, a storage format used
+    # by Mercurial. Base85 is like base64, only with some extra characters to improve compression.
+    # This is a direct port of the python file base85.py in the Mercurial distribution.
+    class Base85
+      # The allowable Base 85 characters (encoding)
+      B85chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~'
+      # The lookup table to go from character -> decimal (decoding)
+      B85dec = {}
+      # Prepare the decoding table
+      B85chars.size.times do |i|
+        B85dec[B85chars[i,1]] = i
+      end
+      
+      ##
+      # Encodes the given string in Base85, and possibly pad it. This code makes sense to me. Fuck I hate
+      # python.
+      # 
+      # @param [String] str the string to be encoded
+      # @param [Boolean] pad whether or not to pad the resulting output
+      # @return [String] Base85 encoded string 
+      def self.encode str, pad=false
+        l = str.size
+        r = l % 4
+        str += "\0" * (4-r)
+        longs = str.size >> 2
+        out = []
+        words = str.unpack("N#{longs}")
+        
+        words.each do |word|
+          word, r = word.divmod 85
+          e = B85chars[r].chr
+          word, r = word.divmod 85
+          d = B85chars[r].chr
+          word, r = word.divmod 85
+          c = B85chars[r].chr
+          word, r = word.divmod 85
+          b = B85chars[r].chr
+          word, r = word.divmod 85
+          a = B85chars[r].chr
+          
+          out += [a,b,c,d,e]
+        end
+        
+        out = out.join("")
+        return out if pad
+        
+        olen = l % 4
+        olen += 1 if olen > 0
+        olen += l / 4 * 5
+        
+        out[0 .. olen-1]
+      end
+      
+      ##
+      # Decodes a base85 encoded string and returns it. This code sort of mystifies me.
+      # Slash looking at it I'm not sure why we don't just code it in C. Maybe we will eventually.
+      # Fucking python coders.
+      # 
+      # @param [String] text the base85 encoded string to decode
+      # @return [String] the decoded text
+      def self.decode text
+        l = text.size
+        out = []
+        i = 0
+        while i < text.size
+          chunk = text[i .. i+4]
+          acc = 0
+          chunk.size.times do |j|
+            acc = acc * 85 + B85dec[chunk[j].chr]
+          end
+          out << acc
+          i += 5
+        end
+        
+        cl = l % 5
+        if cl > 0
+          acc *= 85 ** (5 - cl)
+          if cl > 1
+            acc += 0xffffff >> (cl - 2) * 8
+          end
+          out[-1] = acc
+        end
+        
+        out = out.pack("N#{out.size}")
+        if cl > 0
+          out = out[0 .. (-1 * (5-cl) - 1)]
+        end
+        out
+      end
+      
+    end
+  end
+end

data/lib/amp/encoding/binary_diff.rb

@@ -0,0 +1,82 @@
+module Amp
+  ##
+  # Binary diffs
+  module Diffs
+    
+    ##
+    # Methods for producing a binary diff file for 2 input strings. Direct port
+    # from pure/bdiff.py in the mercurial source.
+    module BinaryDiff
+      
+      ##
+      # Produces a binary diff file from the input strings, str1 and str2. Works by
+      # getting the list of matching blocks (using {SequenceMatcher}) and filling in
+      # the gaps between them. Basically.
+      # 
+      # @param [String] str1 the source string/file
+      # @param [String] str2 the destination string/file
+      # @return [String] A binary string representing the diff between the two strings/files
+      def bdiff(str1, str2)
+        # break 'em up into lines
+        a = []
+        str1.each_line {|l| a << l}
+        b = []
+        str2.each_line {|l| b << l}
+
+        if a.nil? || a.empty?
+          s = b.join
+          return [0,0,s.size].pack("NNN") + s
+        end
+        
+        bin = []
+        byte_offsets = [0]
+        a.each {|line| byte_offsets << (byte_offsets.last + line.size) }
+        # Get all the sections of a and b that actually match each other.
+        matched_blocks = SequenceMatcher.new(a, b).get_matching_blocks
+        la = lb = 0
+        matched_blocks.each do |block|
+          am, bm, size = block[:start_a], block[:start_b], block[:length]
+          
+          # At this point, a[la..am-1] does NOT equal b[lb..bm-1]. We know this
+          # because the block we just got is a *matching* block. It tells us where
+          # the two strings are the *same*. So a[la..am-1] is the source text, and
+          # b[lb..bm-1] is the destination text of our diff. Thus, we say "replace
+          # the text in a from (la..am) with the following text we got from b".
+          # Since the array byte_offsets[] contains the actual byte offsets of each line,
+          # our diff is stored as [start_a_text_to_replace, end_a_text_to_replace,
+          # size_of_replacement_text, replacement_text]. 
+          s = b[lb .. (bm-1)].join unless lb == bm && lb == 0
+          s = ""                   if     lb == bm && lb == 0
+          bin << [byte_offsets[la], byte_offsets[am], s.size].pack("NNN") + s if am > la || s.any?
+          la = am + size
+          lb = bm + size
+        end
+        bin.join
+      end
+      module_function :bdiff
+      
+      ##
+      # Breaks the 2 input strings into blocks that match each other. Uses
+      # {SequenceMatcher} and just manipulates the output a little.
+      # 
+      # @param [String] str1 the source string
+      # @param [String] str2 the destination string
+      # @return [[Hash]] The matching blocks, with keys :start_a, :start_b, :end_a, :end_b
+      def blocks(str1, str2)
+        an = str1.split_lines_better
+        bn = str2.split_lines_better
+        
+        matches = Diffs::SequenceMatcher.new(an, bn).get_matching_blocks
+        matches.map do |match|
+          {:start_a => match[:start_a], :end_a => match[:start_a] + match[:length],
+           :start_b => match[:start_b], :end_b => match[:start_b] + match[:length] }
+        end
+      end
+      module_function :blocks
+      
+      def self.blocks_as_array(str1, str2)
+        blocks(str1,str2).map {|h| [h[:start_a], h[:end_a], h[:start_b], h[:end_b]]}
+      end
+    end
+  end
+end

data/lib/amp/encoding/difflib.rb

@@ -0,0 +1,166 @@
+module Amp
+  ##
+  # = Difflib
+  # Port of the Python Difflib. Only ports what is necessary. The cool part is that
+  # this works for anything that has []! So it'll find matches in an array of lines
+  # or just strings.
+  module Diffs
+    ##
+    # Port of the Python SequenceMatcher, leaving out parts that Mercurial doesn't use.
+    class SequenceMatcher
+      
+      ##
+      # Initializes the sequence matcher.
+      # 
+      # @param [String] seq1 The source data
+      # @param [String] seq2 The "destination" data
+      def initialize(seq1='', seq2='')
+        @a = @b = nil
+        set_seqs(seq1,seq2)
+      end
+      ##
+      # Initializes the 2 sequences and prepares the rest of the matcher
+      # 
+      # @param [#each] seq1 The source input sequence. Can be anything responding to #each. 
+      # @param [#each] seq2 The destination sequence - what we transform seq1 into.
+      def set_seqs(seq1,seq2); set_seq1(seq1); set_seq2(seq2); end
+      
+      ##
+      # Initializes the source sequence and resets the matching blocks.
+      # 
+      # @param [#each] seq1 The source input sequence.
+      def set_seq1(seq1)
+        return if @a == seq1
+        @a = seq1
+        @matching_blocks = nil
+      end
+      ##
+      # Initializes the destination sequence and resets the matching blocks. It also prepares
+      # some optimization data.
+      # 
+      # @param [#each] seq2 The destination input sequence.
+      def set_seq2(seq2)
+        return if @b == seq2
+        @b = seq2
+        @matching_blocks = nil
+        build_b2j
+      end
+      
+      ##
+      # Sets up some optimization stuff. internal use only. I fucking hate python but ok here's what it
+      # does... it goes through the destination sequence, setting the indices into the destination where
+      # you can find each line. So it'll save the fact that "return nil" appears on lines 3, 14, and 20.
+      # at the same time it's looking for "popular" entries, that are ignored to save runtime later. They
+      # get removed from the list.
+      # The original source respected a "junk" parameter, which was also removed from the list. But
+      # Mercurial doesn't use the junk parameter, so I stripped that code.
+      def build_b2j
+        n = @b.size
+        @b2j = {}
+        populardict = {}
+        n.times do |i|
+          elt = @b[i,1]
+          if @b2j[elt]
+            indices = @b2j[elt]
+            if n >= 2000 && (indices.size * 100 > n)
+              populardict[elt] = true
+              indices.clear
+            else
+              indices << i
+            end
+          else
+            @b2j[elt] = [i]
+          end
+        end
+        
+        populardict.each do |k,v|
+          @b2j.delete k
+        end
+      end
+      
+      ##
+      # Finds the longest match in the 2 sequences between the 2 ranges provided.
+      # 
+      # @param alo don't look at any part of the source before this
+      # @param ahi don't look at any part of the source after this
+      # @param blo don't look at any part of the destination before this
+      # @param bhi don't look at any part of the destination after this
+      # @return [[Integer,Integer,Integer]] The return is of the form 
+      #   [start_source, start_destination, length_of_common_sequence].
+      #   source[start_source + i] == destination[start_destination + i] for all 0 <= i < length_of_common_sequence
+      def find_longest_match(alo, ahi, blo, bhi)
+        j2len = {}
+        besti, bestj, bestsize = alo, blo, 0
+        alo.upto(ahi-1) do |i|
+          newj2len = {}
+          @b2j[@a[i,1]] && @b2j[@a[i,1]].each do |j|
+            next if j < blo
+            break if j >= bhi
+            k = newj2len[j] = j2len[j-1].to_i + 1
+            besti, bestj, bestsize = i-k+1, j-k+1, k if k > bestsize
+          end
+          j2len = newj2len
+        end
+        # we ignored popular elements before. they're being added here.
+        while besti > alo && bestj > blo && @a[besti-1,1] == @b[bestj-1,1]
+          besti, bestj, bestsize = besti-1, bestj-1, bestsize + 1
+        end
+        # we ignored popular elements before. they're being added here.
+        while besti+bestsize < ahi && bestj+bestsize < bhi && @a[besti+bestsize,1] == @b[bestj+bestsize,1]
+          bestsize += 1
+        end
+        return [besti, bestj, bestsize]
+      end
+      
+      ##
+      # This will go through and find all the matching blocks in the
+      # 2 sequences, picking out the best sequences using find_longest_match.
+      # 
+      # @return [[Hash]] A list of hashes, each of which represents 1 matching block. 
+      def get_matching_blocks
+        return @matching_blocks if @matching_blocks
+        la, lb = @a.size, @b.size
+        
+        # This is best done recursively, but if you have a large file it can blow
+        # the stack. We ignore popular lines here to speed things up. I guess.
+        queue = [[0, la, 0, lb]]
+        @matching_blocks = []
+        while queue.any?
+          alo, ahi, blo, bhi = queue.shift
+          i, j, k = x = find_longest_match(alo, ahi, blo, bhi)
+          if k > 0
+            @matching_blocks << x
+            if alo < i && blo < j
+              queue << [alo, i, blo, j]
+            end
+            if i+k < ahi && j+k < bhi
+              queue << [i+k, ahi, j+k, bhi]
+            end
+          end
+        end
+        # Sort 'em from beginning of the sequences to the end
+        @matching_blocks.sort!
+        i1 = j1 = k1 = 0
+        non_adjacent = []
+        # If any "popular" entries were ignored, let's add them to the sequence now.
+        @matching_blocks.each do |i2, j2, k2|
+          if i1 + k1 == i2 && j1 + k1 == j2
+            k1 += k2
+          else
+            non_adjacent << [i1, j1, k1] if k1 > 0
+            i1, j1, k1 = i2, j2, k2
+          end
+        end
+        # Add the last found sequence if there is one
+        non_adjacent << [i1, j1, k1] if k1 > 0
+        # Add the terminator sequence
+        non_adjacent << [la, lb, 0]
+        # Make the output ruby-like, we don't need fucking tuples
+        @matching_blocks = non_adjacent.map do |i, j, k|
+          {:start_a => i, :start_b => j, :length => k}
+        end
+        @matching_blocks
+      end
+    end
+  end
+end

data/lib/amp/encoding/mercurial_diff.rb

@@ -0,0 +1,378 @@
+module Amp
+  module Diffs
+    ##
+    # = MercurialDiff
+    # Mercurial has it's own implementation of the unified diff, because windows
+    # boxes don't have diff -u. Plus code is faster than the shell.
+    # Lame. That's ok, it's pretty easy to do. And we can also add flags and 
+    # change default settings.
+    #
+    # Mainly, you're only going to use MercurialDiff.unified_diff(). It's usage
+    # is described below.
+    module MercurialDiff
+      extend self
+      ##
+      # These are the default options you can modify. Grab them, clone them,
+      # change them. Notice: You have to *clone* this when you use it, or
+      # you will be changing the default options!
+      DEFAULT_OPTIONS = {:context => 3, :text => false, :show_func => false,
+                         :git => false, :no_dates => false, :ignore_ws => false,
+                         :ignore_ws_amount => false, :ignore_blank_lines => false,
+                         :pretty => false}
+      
+      ##
+      # Clear up whitespace in the text if we have any options relating
+      # to getting rid of whitespace.
+      # 
+      # @param [String] text the text to modify
+      # @param [Hash] options the options to use when deciding how to clean text
+      # @option [Boolean] options :ignore_ws (false) do we ignore all whitespace?
+      #   this has the net effect of removing all whitespace.
+      # @option [Boolean] options :ignore_ws_amount (false) when this option is
+      #   true, we only remove "excessive" whitespace - more than 1 space or tab.
+      #   we then substitute it all with 1 space.
+      # @option [Boolean] options :ignore_blank_lines (false) when this option
+      #   is true, we remove all extra blank lines.
+      def whitespace_clean(text, options=DEFAULT_OPTIONS)
+        if options[:ignore_ws]
+          text.gsub!(/[ \t]+/, "") #warnings made me use parens
+        elsif options[:ignore_ws_amount]
+          text.gsub!(/[ \t]+/, ' ')
+          text.gsub!(/[ \t]+\n/, "\n")
+        end
+        text.gsub!(/\n+/, '') if options[:ignore_blank_lines]
+        text
+      end
+      
+      ##
+      # Given a line, returns a string that represents "adding that line" in a diff,
+      # based on the options.
+      #
+      # @param [String] input the input line
+      # @return [String] the output line, in a format indicating it is "added"
+      def add_line(input, options)
+        options[:pretty] ? "+#{input.chomp}".green+"\n" : "+#{input}"
+      end
+      
+      ##
+      # Given a line, returns a string that represents "removing that line" in a diff,
+      # based on the options.
+      #
+      # @param [String] input the input line
+      # @return [String] the output line, in a format indicating it is "removed"
+      def remove_line(input, options)
+        options[:pretty] ? "-#{input.chomp}".red+"\n" : "-#{input}"
+      end
+      
+      ##
+      # Creates a header or something? Not sure what this is used for, no code
+      # references it. I think it's for git or something. eh.
+      def diff_line(revisions, a, b, options=DEFAULT_OPTIONS)
+        options = DEFAULT_OPTIONS.merge options
+        parts = ['diff']
+        
+        parts << '--git' if options[:git]
+        parts << revisions.map {|r| "-r #{r}"}.join(' ') if revisions && !options[:git]
+        if options[:git]
+          parts << "a/#{a}"
+          parts << "b/#{b}"
+        else
+          parts << a
+        end
+        parts.join(' ') + "\n"
+      end
+      
+      ##
+      # Creates a date tag appropriate for diffs. Not all diff types use
+      # dates though (namely git, apparently), so the options matter.
+      # 
+      # @param [Time] date the time that we want to make a spiffy date line for
+      # @param [String] fn1 the filename of the file being stamped. Only
+      #   used if the addtab option is on.
+      # @param [Boolean] addtab (false) whether or not to add a tab in the
+      #   line or not. Only used if we're in git mode or no-date mode.
+      # @param options the options to use while creating the date line.
+      # @option [Boolean] options :git (false) are we creating a git diff?
+      #   this will deactivate dates.
+      # @option options [Boolean] :nodates (false) should we never print dates?
+      def date_tag(date, fn1, addtab = true, options = DEFAULT_OPTIONS)
+        return "\t#{date.to_diff}\n" if !(options[:git]) && !(options[:nodates])
+        return "\t\n" if addtab && fn1 =~ / /
+        return "\n"
+      end
+      
+      ##
+      # Returns a unified diff based on the 2 blocks of text, their modification
+      # times, their filenames, and the options. 
+      #
+      # This is a self-contained replacement for diffs.
+      # 
+      # @param a the original text
+      # @param [Time] ad the modification timestamp for the old file
+      # @param b the new text
+      # @param [Time] bd the modification timestamp for the new file
+      # @param fn1 the old filename
+      # @param fn2 the new filename
+      # @param r not sure what this does
+      # @param options the options we will be using. There's a lot of settings,
+      #   see the descriptions for {whitespace_clean} and {date_tag}.
+      def unified_diff(a, ad, b, bd, fn1, fn2, r=nil, options=DEFAULT_OPTIONS)
+        return "" if (a.nil? || a.empty?) && (b.nil? || b.empty?)
+        epoch = Time.at(0)
+        if !options[:text] && (!a.nil? && a.binary? || !b.nil? && b.binary?)
+          return "" if a.any? && b.any? && a.size == b.size && a == b #DERR
+          l = ["Binary file #{fn1} has changed\n"]
+        elsif a.nil? || a.empty?
+          b = b.split_lines_better
+          header = []
+          if options[:pretty]
+            l1 = a.nil? ? "Added file " : "Changed file "
+            l1 += "#{fn2} at #{date_tag(bd,fn1,true,options)}"
+            l1 = l1.cyan
+            header << l1
+          else
+            if a.nil?
+              header << "--- /dev/null#{date_tag(epoch, fn1, false, options)}"
+            else
+              header << "--- #{"a/" + fn1}#{date_tag(ad,fn1,true,options)}"
+            end
+            header << "+++ #{"b/" + fn2}#{date_tag(bd,fn1,true,options)}"
+            header << "@@ -0,0 +1,#{b.size} @@\n"
+          end
+          l = header + (b.map {|line| add_line(line, options)})
+        elsif b.nil? || b.empty?
+          a = b.split_lines_better
+          header = []
+          if options[:pretty]
+            l1 = b.nil? ? "Removed file " : "Changed file "
+            l1 += "#{fn2} at #{date_tag(bd,fn1,true,options)}"
+            l1 = l1.cyan
+            header << l1
+          else
+            header << "--- #{"a/" + fn1}#{date_tag(ad,fn1,true,options)}"
+            if b.nil?
+              header << "+++ /dev/null#{date_tag(epoch, fn1, false, options)}"
+            else
+              header << "+++ #{"b/" + fn2}#{date_tag(bd,fn1,true,options)}"
+            end
+            header << "@@ -1,#{a.size} +0,0 @@\n"
+          end
+          l = header + (a.map {|line| remove_line(line, options)})
+        else
+          al = a.split_lines_better
+          bl = b.split_lines_better
+          l = bunidiff(a, b, al, bl, "a/"+fn1, "b/"+fn2, options)
+          return "" if l.nil? || l.empty?
+          if options[:pretty]
+            l.shift
+            if fn1 == fn2
+              l[0] = "Changed file #{fn1.cyan} at #{date_tag(bd,fn1,true,options).lstrip}"
+            else
+              l[0] = "Moved file from #{fn1.cyan} to #{fn2.cyan}"
+            end
+          else
+            l[0] = "#{l[0][0 .. -3]}#{date_tag(ad,fn1,true,options)}"
+            l[1] = "#{l[1][0 .. -3]}#{date_tag(bd,fn1,true,options)}"
+          end
+        end
+        
+        l.size.times do |ln|
+          if l[ln][-1,1] != "\n"
+            l[ln] << "\n\\n"
+          end
+        end
+        
+        if r
+          l.unshift diff_line(r, fn1, fn2, options)
+        end
+        
+        l.join
+      end
+      
+      ##
+      # Starts a block ending context for a change - part of the unified diff
+      # format.
+      def context_end(l, len, options)
+        ret = l + options[:context]
+        ret = len if ret > len
+        ret
+      end
+      
+      ##
+      # Starts a block starting context for a change - part of the unified diff
+      # format.
+      def context_start(l, options)
+        ret = l - options[:context]
+        return 0 if ret < 0
+        ret
+      end
+      
+      ##
+      # Given a hunk of changes, yield each line we need to write to the diff.
+      # 
+      # @param [Hash] hunk specifies a block of lines that changed between
+      #   the two files.
+      # @param header the header for the block, if we have one.
+      # @param l1 the original lines - used for context (unified diff format)
+      # @param delta the lines that have changed thus far
+      # @param options settings for the unified diff action. unused mostly here.
+      def yield_hunk(hunk, header, l1, delta, options)
+        header.each {|x| yield x} if header && header.any?
+        delta = hunk[:delta]
+        astart, a2, bstart, b2 = hunk[:start_a], hunk[:end_a], hunk[:start_b], hunk[:end_b]
+        aend = context_end(a2,l1.size,options)
+        alen = aend - astart
+        blen = b2 - bstart + aend - a2
+        
+        # i seriously don't know what this does.
+        func = ""
+        if options[:show_func]
+          (astart - 1).downto(0) do |x|
+            t = l1[x].rstrip
+            if t =~ /\w/
+              func = ' ' + t[0 .. 39]
+              break
+            end
+          end
+        end
+        
+        # yield the header
+        if options[:pretty]
+          yield "From original lines #{astart + 1}-#{alen+astart+1}".yellow + "\n"
+        else
+          yield "@@ -%d,%d +%d,%d @@%s\n" % [astart + 1, alen,
+                                            bstart + 1, blen, func]
+        end
+                                           
+        # then yield each line of changes
+        delta.each {|x| yield x}
+        # then yield some context or something?
+        a2.upto(aend-1) {|x| yield ' ' + l1[x] }
+      end
+      
+      ##
+      # Helper method for creating unified diffs.
+      # 
+      # @param [String] t1 original text
+      # @param [String] t2 new text
+      # @param [String] l1 the original text broke into lines?
+      # @param [String] l2 the new etxt broken into lines?
+      # @param [String] header1 the original file's header
+      # @param [String] header2 the new file's header
+      # @param opts options for the method
+      def bunidiff(t1,t2, l1, l2, header1, header2, opts=DEFAULT_OPTIONS)
+        header = [ "--- #{header1}\t\n", "+++ #{header2}\t\n" ]
+
+        diff = BinaryDiff.blocks(t1,t2)
+        hunk = nil
+        return_hunks = []
+        saved_delta = []
+        delta = []
+        diff.size.times do |i|
+          s = (i > 0) ? diff[i-1] : {:start_a => 0, :end_a => 0, :start_b => 0, :end_b => 0}
+          saved_delta += delta unless delta.empty?
+          delta = []
+          s1 = diff[i]
+          a1 = s[:end_a]
+          a2 = s1[:start_a]
+          b1 = s[:end_b]
+          b2 = s1[:start_b]
+          
+          old = (a2 == 0) ? [] : l1[a1..(a2-1)]
+          newb = (b2 == 0) ? [] : l2[b1..(b2-1)] #stands for new "b"
+          
+          next if old.empty? && newb.empty?
+          if opts[:ignore_ws] || opts[:ignore_blank_lines] || opts[:ignore_ws_amount]
+            next if whitespace_clean(old.join,opts) == whitespace_clean(newb.join,opts)
+          end
+          
+          astart = context_start(a1,opts)
+          bstart = context_start(b1,opts)
+          prev = nil
+          if hunk
+            if astart < hunk[:end_a] + opts[:context] + 1
+              prev = hunk
+              astart = hunk[:end_a]
+              bstart = hunk[:end_b]
+            else
+              yield_hunk(hunk, header, l1, delta, opts) {|x| return_hunks << x}
+
+              header = nil
+            end
+          end
+          # move this inside previous nested if statements
+          if prev
+            hunk[:end_a] = a2
+            hunk[:end_b] = b2
+            delta = hunk[:delta]
+          else
+            hunk = {:start_a => astart, :end_a => a2, :start_b => bstart, :end_b => b2, :delta => delta}
+          end
+          
+          hunk[:delta] += l1[astart..(a1-1)].map {|x| ' ' + x } if a1 > 0
+          hunk[:delta] += old.map  {|x| remove_line(x, opts) }
+          hunk[:delta] += newb.map {|x| add_line(x, opts) } 
+
+        end
+        saved_delta += delta
+  
+        yield_hunk(hunk, header, l1, saved_delta, opts) {|x| return_hunks << x} if hunk
+        return_hunks
+      end
+      
+      ##
+      # Unpacks a binary-compressed patch.
+      # 
+      # @param [String] binary the packed binary text to unpack
+      def patch_text(binary)
+        pos = 0
+        t = []
+        while pos < binary.size
+          p1, p2, l = binary[pos..(pos+11)].unpack("NNN")
+          pos += 12
+          t << binary[pos..(pos + l - 1)]
+          pos += l
+        end
+        t.join
+      end
+      
+      ##
+      # Applies the patch _bin_ to the text _a_.
+      # 
+      # @param [String] a the text to patch
+      # @param [String] bin the binary patch to apply
+      def patch(a, bin)
+        MercurialPatch.apply_patches(a, [bin])
+      end
+      
+      ##
+      # Gets the matching blocks between the two texts.
+      # 
+      # @param [String] a the original text
+      # @param [String] b the final text
+      # @return [[Hash]] The blocks of changes between the two
+      def get_matching_blocks(a, b)
+        an = a.split_lines_better
+        bn = b.split_lines_better
+        
+        SequenceMatcher.new(an, bn).get_matching_blocks
+      end
+      
+      ## 
+      # Returns the obvious header for when we create a new file
+      # 
+      # @param [Fixnum] length the length of the file
+      # @return [String] the obvious header
+      def trivial_diff_header(length)
+        [0, 0, length].pack("NNN")
+      end
+      
+      ##
+      # Returns a text diff between a and b. This returns the packed, binary
+      # kind of diff.
+      def text_diff a,b
+        BinaryDiff.bdiff a,b
+      end
+    end
+  end
+end