amp 0.5.0

data/lib/amp/encoding/mercurial_patch.rb

@@ -0,0 +1 @@
+amp_c_extension '../../../ext/amp/mercurial_patch/MercurialPatch', 'pure_ruby/ruby_mercurial_patch'

data/lib/amp/encoding/patch.rb

@@ -0,0 +1,292 @@
+# I have seen few files so poorly organized such as patch.py
+# What. The. Fuck. This is going to take so long to make.
+module Amp
+  module Patch
+    
+    class PatchError < StandardError; end
+    class NoHunkError < PatchError; end
+    
+    class Patch
+      
+      ##
+      # The filename of the patch
+      attr_accessor :file_name
+      
+      ##
+      # The opener used to open the patch
+      attr_accessor :opener
+      
+      ##
+      # @todo - add comment
+      attr_accessor :lines
+      
+      ##
+      # does the patch exist?
+      attr_accessor :exists
+      alias_method  :exists?, :exists
+      
+      ##
+      # Is the file in the filesystem
+      attr_accessor :missing
+      alias_method  :missing?, :missing
+      
+      ##
+      # @todo - add comment
+      attr_accessor :hash
+      
+      ##
+      # Is this dirty and does it need to be resynced with something?
+      attr_accessor :dirty
+      alias_method  :dirty?, :dirty
+      
+      ##
+      # @todo - add comment
+      attr_accessor :offset
+      
+      ##
+      # has this been printed? (duh)
+      attr_accessor :printed
+      alias_method  :printed?, :printed
+      
+      ##
+      # @todo - add comment
+      attr_accessor :hunks
+      
+      def initialize(file_name, opener, missing=false)
+        @file_name = file_name
+        @opener    = opener
+        @lines     = []
+        @exists    = false
+        @hash      = {}
+        @dirty     = false
+        @offset    = 0
+        @rejected  = []
+        @printed   = false
+        @hunks     = 0
+        
+        ##
+        # If the patch is in the filesystem
+        # then we should read it and accurately set its existence
+        unless @missing = missing
+          begin
+            readlines!
+            @exists = true
+          rescue IOError
+          end
+        else
+          UI::warn "unable to find '#{@file_name}' for patching"
+        end
+      end
+      
+      ##
+      # Loads up the patch info from +@file_name+
+      # into +@lines+
+      def readlines!
+        @opener.open @file_name do |f|
+          @lines = f.readlines
+        end
+      end
+      
+      ##
+      # Mysteriously and safely disappear...
+      #
+      # @return [Boolean] success marker
+      def unlink; File.safe_unlink @file_name; end
+      
+      ##
+      # Print out the patch to STDOUT, or STDERR if +warn+ is true.
+      # 
+      # @param [Boolean] warn should we be printing to STDERR?
+      def print(warn=false)
+        return if printed? # no need to print it twice
+        
+        @printed = true if warn
+        message  = "patching file #{@file_name}"
+        warn ? UI::warn message : UI::note message
+      end
+      
+      ##
+      # From the Python: looks through the hash and finds candidate lines. The
+      # result is a list of line numbers sorted based on distance from linenum.
+      # 
+      # I wish I knew how to make sense of that sentence.
+      # 
+      # @todo Look into removing an unnecessary `- number`.
+      # @param  [String] line
+      # @param  [Integer] number the line number
+      # @return [Array] the lines that matchish.
+      def find_lines(line, number)
+        return [] unless @hash.include? line
+        
+        # really, we're just getting the lines and sorting them
+        # is the `- number` even necessary?
+        @hash[line].sort {|a, b| (a - number).abs <=> (b - number).abs }
+      end
+      
+      ##
+      # I have no clue what song I am listening to but it is SOOOOO GOOD!!!!!!!!
+      # "This time baby, I'll be bullet proof"
+      # If I had working internet now, I'd be googling the lyrics.
+      # 
+      # Oh right, the method. I don't know what this does... YET
+      # 
+      # @todo Figure out what this does
+      def hash_lines
+        @hash = Hash.new {|h, k| h[k] = [] }
+        (0 ... @lines.size).each do |x|
+          s = @lines[x]
+          @hash[s] << x
+        end
+      end
+      
+      ##
+      # our rejects are a little different from patch(1).  This always
+      # creates rejects in the same form as the original patch.  A file
+      # header is inserted so that you can run the reject through patch again
+      # without having to type the filename.
+      def write_rejects
+        return if @rejects.empty?
+        fname = @file_name + '.rej'
+        
+        UI::warn("#{@rejects.size} out of #{@hunks} hunks FAILED --" +
+                 "saving rejects to file #{fname}")
+        
+        # i have never written code as horrid as this
+        # please help me
+        lz = []
+        base = File.dirname @file_name
+        lz << "--- #{base}\n+++ #{base}\n"
+        @rejects.each do |r|
+          r.hunk.each do |l|
+            lz << l
+            lz << "\n\n" if l.last.chr != "\n"
+          end
+        end
+        
+        write fname, lz, true
+      end
+      
+      ##
+      # Write +linez+ to +fname+. We won't be doing any writing if
+      # nothing has been changed, but this can be overridden with the
+      # force parameter.
+      # 
+      # @param [String] dest the filename to write to
+      # @param [Array<String>] linez an array of the lines to write
+      # @param [Boolean] force force a write
+      def write(dest=@file_name, linez=@lines, force=false)
+        return unless dirty? || force
+        
+        @opener.open dest, 'w' do |f|
+          f.write linez.join("\n")
+        end
+      end
+      
+      ##
+      # A more restrictive version of {write}
+      def write_patch
+        write @file_name, @lines, true
+      end
+      
+      ##
+      # Closing rites. Write the patch and then write the rejects.
+      def close
+        write_patch
+        write_rejects
+      end
+      
+      ##
+      # Apply the current hunk +hunk+. Also, should we reverse the hunk? Consult +reverse+.
+      # 
+      # @param
+      # @param
+      def apply(hunk, reverse)
+        unless hunk.complete?
+          raise PatchError.new("bad hunk #%d %s (%d %d %d %d)" % 
+                               [hunk.number, hunk.desc, hunk.a.size,
+                                hunk.len_a, hunk.b.size, hunk.len_b])
+        end
+        
+        @hunks += 1               # It's clear we're adding a new hunk.
+        
+        # Obey reversal rules.
+        hunk.reverse                                 if reverse
+        
+        # Does the file already exist? Better tell someone
+        UI::warn "file #{@file_name} already exists" if exists? && hunk.create_file?
+        
+        # Is this a misfit?
+        (@rejects << hunk; return -1)                if missing? || (exists? && hunk.create_file?)
+        
+        # Deal with GitHunks
+        if hunk.is_a? GitHunk
+          if hunk.remove_file?
+            File.safe_unlink @file_name
+          else
+            @lines   = hunk.new
+            @offset += hunk.new.size
+            @dirty   = true
+          end
+          
+          return 0
+        end
+        
+        # fast case first, no offsets, no fuzz
+        old = hunk.old
+        
+        # patch starts counting at 1 unless we are adding the file
+        start = hunk.start_a == 0 ? 0 : h.start_a + @offset - 1
+        
+        orig_start = start
+        if DiffHelpers::test_hunk(old, @lines, start) == 0
+          if hunk.remove_file?
+            File.safe_unlink @file_name
+          else
+            @lines[start .. (start + hunk.len_a)] = hunk.new
+            @offset += hunk.len_b - hunk.len_a
+            @dirty   = true
+          end
+          
+          return 0
+        end # end if
+      end # end def
+      
+      # Ok, We couldn't match the hunk.  Let's look for offsets and fuzz it
+      # as well as use proper punctuation for the 'let us' contraction.
+      hash_lines
+      
+      # if the hunk tried to put something at the bottom of the file
+      # then override the start line and use eof here
+      search_start = hunk[-1][0].chr != ' ' ? @lines.size : orig_start
+      
+      0.upto(2) do |fuzz_len|
+        [true, false].each do |top_only|
+          old = hunk.old fuzz_len, top_only
+          # Continue at patch.py:407
+          # ...
+          # ...
+        end
+      end # end upto
+      
+    end # end class Patch
+    
+    class PatchMeta
+    end
+    
+    class Hunk
+    end
+    
+    class GitHunk
+    end
+    
+    class BinaryHunk
+    end
+    
+    class SymLinkHunk
+    end
+    
+    class LineReader
+    end
+    
+  end
+end

data/lib/amp/encoding/pure_ruby/ruby_mercurial_patch.rb

@@ -0,0 +1,123 @@
+
+module Amp
+  module Diffs
+    
+    ##
+    # This handles applying patches in mercurial. yay!!!!
+    module MercurialPatch
+      
+      ##
+      # This attempts to apply a series of patches in time proportional to
+      # the total size of the patches, rather than patches * len(text). This
+      # means rather than shuffling strings around, we shuffle around
+      # pointers to fragments with fragment lists.
+      #
+      # When the fragment lists get too long, we collapse them. To do this
+      # efficiently, we do all our operations inside a buffer created by
+      # mmap and simply use memmove. This avoids creating a bunch of large
+      # temporary string buffers.
+      #
+      # UPDATE 2AM BEFORE I GO BACK TO SCHOOL
+      # I FUCKING HATE PYTHON
+      def self.apply_patches(source, patches)
+        return source if patches.empty?
+        patch_lens = patches.map {|patch| patch.size}
+        pl = patch_lens.sum
+        bl = source.size + pl
+        tl = bl + bl + pl
+        b1, b2 = 0, bl
+        
+        return a if tl == 0 #empty patches. lame.
+        
+        output = StringIO.new "",(ruby_19? ? "r+:ASCII-8BIT" : "r+")
+        output.write source
+        
+        frags = [[source.size, b1]]
+        
+        pos = b2 + bl
+        output.seek pos
+        patches.each {|patch| output.write(patch)}
+        patch_lens.each do |plen|
+          if frags.size > 128
+            b2, b1 = b1, b2
+            frags = [self.collect(output,b1,frags)]
+          end
+          newarr = []
+          endpt = pos + plen
+          last = 0
+          while pos < endpt
+            output.seek pos
+            p1, p2, l = output.read(12).unpack("NNN")
+            self.pull(newarr, frags, p1 - last)
+            self.pull([], frags, p2 - p1)
+            newarr << [l, pos + 12]
+            pos += l + 12
+            last = p2
+          end
+          frags = newarr + frags
+        end
+  
+        t = self.collect output, b2, frags
+        output.seek t[1]
+        output.read t[0]
+      end
+      
+      
+      def self.patched_size(orig, delta)
+        outlen, last, bin = 0, 0, 0
+        binend = delta.size
+        data = 12 # size of the delta instruction values (3 longs)
+        while data <= binend
+          decode = delta[bin..(bin+11)]
+          start, endpt, length = decode.unpack("NNN")
+          break if start > endpt
+          
+          bin = data + length
+          data = bin + 12
+          outlen += start - last
+          last = endpt
+          outlen += length
+        end
+        
+        raise "patch cannot be decoded" if bin != binend
+        
+        outlen += orig - last
+        outlen
+      end
+      
+      def self.copy_block(io, destination, source, count)
+        io.seek(source)
+        buf = io.read(count)
+        io.seek(destination)
+        io.write(buf)
+      end
+      
+      ##
+      # 
+      def self.pull(dst, src, l)
+        until l == 0
+          f = src.shift
+          if f[0] > l
+            src.unshift [f[0] - l, f[1] + l]
+            dst << [l, f[1]]
+            return
+          end
+          dst << f
+          l -= f[0]
+        end
+      end
+      
+      ##
+      # Takes the fragments we've accumulated and applies them all to the IO.
+      def self.collect(io, buf, list)
+        start = buf
+        list.each do |l, p|
+          self.copy_block(io, buf, p, l)
+          buf += l
+        end
+        [buf - start, start]
+      end
+      
+    end
+  end
+end

data/lib/amp/extensions/ditz.rb

@@ -0,0 +1,41 @@
+namespace :ditz do
+  
+  command :close do |c|
+    c.desc "Close a Ditz bug and commit saying that it has been closed"
+    
+    c.opt :message, "Any notes concerning this bug", :short => '-m', :type => :string, :default => ''
+    
+    c.on_run do |opts, args|
+      repo  = opts[:repository]
+      msg   = opts[:message]
+      issue = args.shift
+      
+      system "ditz close #{issue}"
+      
+      repo.commit :message => "Closed Bug ##{issue}#{msg.empty? ? '' : ": #{msg}"}"
+    end
+  end
+  
+  command :add do |c|
+    c.desc "Add a Ditz bug and commit saying that it has been opened"
+    
+    c.opt :message, "Any notes concerning this bug", :short => '-m', :type => :string, :default => ''
+    
+    c.on_run do |opts, args|
+      repo  = opts[:repository]
+      msg   = opts[:message]
+      
+      system "ditz add"
+      
+      # seydar: *sigh* i hate taking advantage of side effects
+      # File.read('.ditz-config') =~ /^issue_dir:(.+)$/
+      # bugs = $1.strip
+      # adgar: then don't use them!
+      bugs = File.read('.ditz-config').match(/^issue_dir:(.+)$/)[1].strip
+      
+      Amp::Command[:add].run opts, [bugs]
+      repo.commit :message => "Added Bugs"
+    end
+  end
+  
+end