amp 0.5.2 → 0.5.3

data/lib/amp/repository/git/repository.rb

@@ -0,0 +1,41 @@
+module Amp
+  module Repositories    
+    module Git
+      
+      class GitPicker < GenericRepoPicker
+        
+        def self.pick(config, path='', create=false)
+          # hot path so we don't load the HTTP repos!
+          unless path[0,4] == "http"
+            return LocalRepository.new(find_repo(path), create, config)
+          end
+          raise "Unknown repository format for Git"
+        end
+        
+        def self.repo_in_dir?(path)
+          return true if path[0, 4] == "http"
+          until File.directory? File.join(path, ".git")
+            old_path, path = path, File.dirname(path)
+            if path == old_path
+              return false
+            end
+          end
+          true
+        end
+        
+        ################################
+        private
+        ################################
+        def self.find_repo(path)
+          until File.directory? File.join(path, ".git")
+            old_path, path = path, File.dirname(path)
+            if path == old_path
+              raise "No Repository Found"
+            end
+          end
+          path
+        end
+      end
+    end
+  end
+end

data/lib/amp/repository/mercurial/encoding/mercurial_diff.rb

@@ -0,0 +1,382 @@
+module Amp
+  module Diffs
+    module Mercurial
+      
+      ##
+      # = 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?)
+          options = DEFAULT_OPTIONS.merge(options) # overlay the defaults with the supplied opts
+          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
+end

data/lib/amp/repository/mercurial/encoding/mercurial_patch.rb

@@ -0,0 +1 @@
+amp_c_extension 'amp/mercurial_patch/CMercurialPatch', 'pure_ruby/ruby_mercurial_patch'

data/lib/amp/repository/mercurial/encoding/patch.rb

@@ -0,0 +1,294 @@
+# 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
+    module Mercurial
+      
+      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
+end