amp 0.5.2 → 0.5.3

data/lib/amp/repository/repositories/http_repository.rb

@@ -1,377 +0,0 @@
-require 'uri'
-
-# to shut up those fucking warnings!
-# taken from http://www.5dollarwhitebox.org/drupal/node/64
-class Net::HTTP
-  alias_method :old_initialize, :initialize
-  def initialize(*args)
-    old_initialize(*args)
-    require 'openssl' unless defined? OpenSSL
-    @ssl_context = OpenSSL::SSL::SSLContext.new
-    @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-  end
-end
-
-module Amp
-  module Repositories
-    ##
-    # = This is the class for connecting to an HTTP[S]-based repository.
-    # The protocol's pretty simple - just ?cmd="command", and any other
-    # args you need. Should be pretty easy.
-    class HTTPRepository < Repository
-      include RevlogSupport::Node
-      
-      DEFAULT_HEADERS = {"User-agent" => "Amp-#{Amp::VERSION}",
-                         "Accept" => "Application/Mercurial-0.1"}
-      
-      ##
-      # The URL we connect to for this repository
-      attr_reader :url
-      
-      ##
-      # Should the repository connect via SSL?
-      attr_accessor :secure
-      
-      ##
-      # Returns whether the repository is local or not. Which it isn't. Because
-      # we're connecting over HTTP.
-      #
-      # @return [Boolean] +false+. Because the repo isn't local.
-      def local?; false; end
-      
-      ##
-      # Standard initializer for a repository. However, "create" is a no-op.
-      #
-      # @param [String] path the URL for the repository.
-      # @param [Boolean] create this is useless since we can't create remote repos
-      # @param [Amp::AmpConfig] config the configuration for Amp right now.
-      def initialize(path="", create=false, config=nil)
-        @url, @config = URI.parse(path), config
-        @auth_mode = :none
-        raise InvalidArgumentError.new("Invalid URL for an HTTP repo!") if @url.nil?
-      end
-      
-      ##
-      # Loads the capabilities from the server when necessary. (Lazy loading)
-      #
-      # @return [Hash] the capabilities of the server, in the form:
-      #      { capability => true }
-      #   or
-      #      { capability => "capability;settings;"}
-      def get_capabilities
-        return @capabilities if @capabilities
-        begin
-          @capabilities = {}
-          do_read("capabilities").first.split.each do |k| 
-            if k.include? "="
-              key, value = k.split("=", 2)
-              @capabilities[key] = value
-            else
-              @capabilities[k] = true
-            end
-          end
-        rescue
-          @capabilities = []
-        end
-        @capabilities
-      end
-      
-      ##
-      # Unsupported - raises an error.
-      def lock; raise RepoError.new("You can't lock an HTTP repo."); end
-      
-      ##
-      # Looks up a node with the given key. The key could be a node ID (full or
-      # partial), an index number (though this is slightly risky as it might
-      # match a node ID partially), "tip", and so on. See {LocalRepository#[]}.
-      #
-      # @param [String] key the key to look up - could be node ID, revision index,
-      #   and so on.
-      # @return [String] the full node ID of the requested node on the remote server
-      def lookup(key)
-        require_capability("lookup", "Look up Remote Revision")
-        data = do_read("lookup", :key => key).first
-        code, data = data.chomp.split(" ", 2)
-        
-        return data.unhexlify if code.to_i > 0
-        raise RepoError.new("Unknown Revision #{data}")
-      end
-      
-      ##
-      # Gets all the heads of the repository. Returned in binary form.
-      #
-      # @return [Array<String>] the full, binary node_ids of all the heads on
-      #   the remote server.
-      def heads
-        data = do_read("heads").first
-        data.chomp.split(" ").map {|h| h.unhexlify }
-      end
-      
-      ##
-      # Gets the node IDs of all the branch roots in the repository. Uses
-      # the supplied nodes to use to search for branches.
-      #
-      # @param [Array<String>] nodes the nodes to use as heads to search for
-      #   branches. The search starts at each supplied node (or the tip, if
-      #   left empty), and goes to that tree's root, and returns the relevant
-      #   information for the branch.
-      # @return [Array<Array<String>>] An array of arrays of strings. Each array
-      #   has 4 components: [head, root, parent1, parent2].
-      def branches(nodes)
-        n = nodes.map {|n| n.hexlify }.join(" ")
-        data = do_read("branches", :nodes => n).first
-        data.split("\n").map do |b|
-          b.split(" ").map {|b| b.unhexlify}
-        end
-      end
-      
-      ##
-      # Asks the server to bundle up the given nodes into a changegroup, and returns it
-      # uncompressed. This is for pulls.
-      #
-      # @todo figure out what the +kind+ parameter is for
-      # @param [Array<String>] nodes the nodes to package into the changegroup
-      # @param [NilClass] kind (UNUSED)
-      # @return [StringIO] the uncompressed changegroup as a stream
-      def changegroup(nodes, kind)
-        n = nodes.map{|i| i.hexlify }.join ' '
-        f = do_read('changegroup', n.empty? ? {} : {:roots => n}).first
-
-        s = StringIO.new "",(ruby_19? ? "w+:ASCII-8BIT" : "w+")
-        s.write Zlib::Inflate.inflate(f)
-        s.pos = 0
-        s
-      end
-      
-      ##
-      # Asks the server to bundle up all the necessary nodes between the lists
-      # bases and heads. It is returned as a stream that reads it in a decompressed
-      # fashion. This is for pulls.
-      # 
-      # @param [Array<String>] bases the base nodes of the subset we're requesting.
-      #   Should be an array (or any Enumerable) of node ids.
-      # @param [Array<String>] heads the heads of the subset we're requesting.
-      #   These nodes will be retrieved as well. Should be an array of node IDs.
-      # @param [NilClass] source i have no idea (UNUSED)
-      # @return [StringIO] the uncompressed changegroup subset as a stream.
-      def changegroup_subset(bases, heads, source)
-        #require_capability 'changegroupsubset', 'look up remote changes'
-        base_list = bases.map {|n| n.hexlify }.join ' '
-        head_list = heads.map {|n| n.hexlify }.join ' '
-#        p base_list, head_list
-        f, code = *do_read("changegroupsubset", :bases => base_list, :heads => head_list)
-        
-        s = StringIO.new "",(ruby_19? ? "w+:ASCII-8BIT" : "w+")
-        s.write Zlib::Inflate.inflate(f)
-        s.rewind
-        s
-      end
-      
-      ##
-      # Sends a bundled up changegroup to the server, who will add it to its repository.
-      # Uses the bundle format.
-      #
-      # @param [StringIO] cg the changegroup to push as a stream.
-      # @param [Array<String>] heads the heads of the changegroup being sent
-      # @param [NilClass] source no idea UNUSED
-      # @return [Fixnum] the response code from the server (1 indicates success)
-      def unbundle(cg, heads, source)
-        # have to stream bundle to a temp file because we do not have
-        # http 1.1 chunked transfer
-        
-        type = ''
-        types = capable? 'unbundle'
-        
-        # servers older than d1b16a746db6 will send 'unbundle' as a boolean
-        # capability
-        # this will be a list of allowed bundle compression types
-        types = types.split ',' rescue ['']
-        
-        # pick a compression format
-        types.each do |x|
-          (type = x and break) if RevlogSupport::ChangeGroup::BUNDLE_HEADERS.include? x
-        end
-        
-        # compress and create the bundle
-        data = RevlogSupport::ChangeGroup.write_bundle cg, type
-        
-        # send the data
-        resp = do_read 'unbundle', :data => data.string,
-                                   :headers => {'Content-Type' => 'application/octet-stream'},
-                                   :heads => heads.map{|h| h.hexlify }.join(' ')
-        # parse output
-        resp_code, output = resp.first.split "\n"
-        
-        # make sure the reponse was in an expected format (i.e. with a response code)
-        unless resp_code.to_i.to_s == resp_code
-          raise abort("push failed (unexpected response): #{resp}")
-        end
-        
-        # output any text from the server
-        UI::say output
-        # return 1 for success, 0 for failure
-        resp_code.to_i
-      end
-      
-      def stream_out
-        do_cmd 'stream_out'
-      end
-      
-      ##
-      # For each provided pair of nodes, return the nodes between the pair.
-      #
-      # @param [Array<Array<String>>] an array of node pairs, so an array of an array
-      #   of strings. The first node is the head, the second node is the root of the pair.
-      # @return [Array<Array<String>>] for each pair, we return 1 array, which contains
-      #   the node IDs of every node between the pair.
-      # add lstrip to split_newlines to fix but not cure bug
-      def between(pairs)
-        batch = 8
-        ret   = []
-        
-        (0..(pairs.size)).step(batch) do |i|
-          n = pairs[i..(i+batch-1)].map {|p| p.map {|k| k.hexlify }.join("-") }.join(" ")
-          d, code = *do_read("between", :pairs => n)
-          
-          raise RepoError.new("unexpected code: #{code}") unless code == 200
-          
-          ret += d.lstrip.split_newlines.map {|l| (l && l.split(" ").map{|i| i.unhexlify }) || []}
-        end
-        Amp::UI.debug "between returns: #{ret.inspect}"
-        ret
-      end
-      
-      private
-      
-      ##
-      # Runs the given command by the server, gets the response. Takes the name of the command,
-      # the data, headers, etc. The command is assumed to be a GET request, unless args[:data] is
-      # set, in which case it is sent via POST.
-      #
-      # @param [String] command the command to send to the server, such as "heads"
-      # @param [Hash] args the arguments you need to provide - for lookup, it
-      #   might be the revision indicies.
-      # @return [String] the response data from the server.
-      def do_cmd(command, args={})
-        require 'net/http'
-        
-        # Be safe for recursive calls
-        work_args = args.dup
-        # grab data, but don't leave it in, or it'll be added to the query string
-        data = work_args.delete(:data) || nil
-        # and headers, but don't leave it in, or it'll be added to the query string
-        headers = work_args.delete(:headers) || {}
-        
-        # Our query string is "cmd => command" plus any other parts of the args hash
-        query = { "cmd" => command }
-        query.merge! work_args
-        
-        # break it up, make a query
-        host = @url.host
-        path = @url.path
-        # Was having trouble with this... should be safe now
-        path += "?" + URI.escape(query.map {|k,v| "#{k}=#{v}"}.join("&"), /[^-_!~*'()a-zA-Z\d;\/?:@&=+$,\[\]]/n)
-        
-        # silly scoping
-        response = nil
-        # Create an HTTP object so we can send our request. static methods aren't flexible
-        # enough for us
-        sess = Net::HTTP.new host, @url.port
-        # Use SSL if necessary
-        sess.use_ssl = true if secure
-        # Let's send our request!
-        sess.start do |http|
-          # if we have data, it's a POST
-          if data
-            req = Net::HTTP::Post.new(path)
-            req.body = data
-          else
-            # otherwise, it's a GET
-            req = Net::HTTP::Get.new(path)
-          end
-          if @auth_mode == :digest
-            # Set digest headers
-            req.digest_auth @username, @password, @auth_digest
-          elsif @auth_mode == :basic
-            # Set basic auth headers
-            req.basic_auth  @username, @password
-          end
-          # Copy over the default headers
-          DEFAULT_HEADERS.each {|k, v| req[k] = v}
-          # Then overwrite them (and add new ones) from our arguments
-          headers.each {|k, v| req[k] = v}
-          # And send the request!
-          response = http.request(req)
-        end
-        # Case on response - we'll be using the kind_of? style of switch statement
-        # here
-        case response
-        when Net::HTTPRedirection
-          # Redirect to a new URL - grab the new URL...
-          newurl = response["Location"]
-          @url = URI.parse(newurl)
-          # and try that again.
-          do_cmd(command, args)
-        when Net::HTTPUnauthorized
-          if @auth_mode == :digest
-            # no other handlers!
-            raise AuthorizationError.new("Failed to authenticate to local repository!")
-          elsif @auth_mode == :basic
-            # failed to authenticate via basic, so escalate to digest mode
-            @auth_mode = :digest
-            @auth_digest = response
-            do_cmd command, args
-          else
-            # They want a username and password. A few routes:
-            # First, check the URL for the username:password@host format
-            @username ||= @url.user 
-            @password ||= @url.password
-            # and start off with basic authentication
-            @auth_mode = :basic
-            # If the URL didn't contain the username AND password, ask the user for them.
-            unless @username && @password
-              UI::say "==> HTTP Authentication Required"
-              
-              @username = UI::ask 'username: '
-              @password = UI::ask 'password: ', :password
-            end
-            
-            # Recursively call the command
-            do_cmd command, args
-          end
-        else
-          # We got a successful response! Woo!
-          response
-        end
-      end
-      
-      ##
-      # This is a helper for do_cmd - it splits up the response object into
-      # two relevant parts: the response body, and the response code.
-      #
-      # @param [String] command the remote command to execute, such as "heads"
-      # @param [Hash] args the arguments to pass to the request. Takes some special values. All
-      #   other values are sent in the query string.
-      # @option args [String] :data (nil) the POST data to send
-      # @option args [Hash] :headers ({}) the headers to send with the request, not including
-      #   any authentication or user-agent headers.
-      # @return [Array] the response data, in the form [body, response_code]
-      def do_read(command, args={})
-        response = do_cmd(command, args)
-        [response.body, response.code.to_i]
-      end
-    end
-    
-    ##
-    # A special form of the HTTPRepository, except that it is secured over SSL (HTTPS).
-    # Other than that, nothing fancy about it.
-    class HTTPSRepository < HTTPRepository
-      def initialize(*args)
-        require 'net/https'
-        
-        super(*args)
-        self.secure = true
-      end
-    end
-  end
-end

data/lib/amp/repository/repositories/local_repository.rb

@@ -1,2661 +0,0 @@
-require 'fileutils'
-
-module Amp
-  module Repositories
-    
-    ##
-    # A Local Repository is a repository that works on local repo's, such
-    # as your working directory. This makes it pretty damn important, and also
-    # pretty damn complicated. Have fun!
-    class LocalRepository < Repository
-      include Amp::RevlogSupport::Node
-      include Amp::Repositories::BranchManager
-      include Amp::Repositories::TagManager
-      include Amp::Repositories::Updatable
-      include Amp::Repositories::Verification
-      
-      # The config is an {AmpConfig} for this repo (and uses .hg/hgrc)
-      attr_accessor :config
-      
-      attr_reader :root
-      attr_reader :root_pathname # save some computation here
-      attr_reader :hg
-      attr_reader :hg_opener
-      attr_reader :branch_manager
-      attr_reader :store_opener
-      attr_reader :store
-      
-      ##
-      # Initializes a new directory to the given path, and with the current
-      # configuration.
-      # 
-      # @param [String] path a path to the Repository.
-      # @param [Boolean] create Should we create a new one? Usually for
-      #   the "amp init" command.
-      # @param [Amp::AmpConfig] config the configuration loaded from the user's
-      #   system. Will have some settings overwritten by the repo's hgrc.
-      def initialize(path="", create=false, config=nil)
-        @capabilities = {}
-        @root        = path[-1, 1] == '/' ? path[0..-2] : path # no ending slashes
-        @root        = File.expand_path @root
-        @hg          = File.join @root, ".hg"
-        @file_opener = Amp::Opener.new @root
-        @file_opener.default = :open_file     # these two are the same, pretty much
-        @hg_opener   = Amp::Opener.new @root
-        @hg_opener.default   = :open_hg     # just with different defaults
-        @filters     = {}
-        @changelog   = nil
-        @manifest    = nil
-        @dirstate    = nil
-        requirements = []
-      
-        # make a repo if necessary
-        unless File.directory? @hg
-          if create
-          then requirements = init config
-          else raise RepoError.new("Repository #{path} not found")
-          end
-        end
-        
-        # no point in reading what we _just_ wrote...
-        unless create
-          # read requires
-          # save it if something's up
-          @hg_opener.open("requires", 'r') {|f| f.each {|r| requirements << r.strip } } rescue nil
-        end
-        
-        @store = Stores.pick requirements, @hg, Amp::Opener
-        @config = Amp::AmpConfig.new :parent_config => config
-        @config.read_file File.join(@hg,"hgrc")
-      end
-      
-      def local?; true; end
-      
-      def relative_join(file, cur_dir=FileUtils.pwd)
-        @root_pathname ||= Pathname.new(@root)
-        Pathname.new(File.expand_path(File.join(cur_dir, file))).relative_path_from(@root_pathname).to_s
-      end
-      
-      
-      def inspect; "#<LocalRepository @root=#{@root.inspect}>"; end
-      
-      ##
-      # Creates this repository's folders and structure.
-      # 
-      # @param [AmpConfig] config the configuration for this user so
-      #   we know what neato features to use (like filename cache) 
-      # @return [Array<String>] the requirements that we found are returned,
-      #   so further configuration can go down.
-      def init(config=@config)
-        # make the directory if it's not there
-        FileUtils.makedirs @hg
-      
-        requirements = ["revlogv1"]
-        
-        # add some requirements
-        if config["format"]["usestore", Boolean] || true
-          FileUtils.mkdir "#{@hg}/store"
-          requirements << "store"
-          requirements << "fncache" if config["format"]["usefncache", Boolean, true]
-      
-          # add the changelog
-          make_changelog
-        end
-        
-      
-        # write the requires file
-        write_requires requirements
-      end
-      
-      ##
-      # Has the repository been changed since the last commit?
-      # Returns true if there are NO outstanding changes or uncommitted merges.
-      # 
-      # @return [Boolean] is the repo pristine
-      def pristine?        
-        dirstate.parents.last == RevlogSupport::Node::NULL_ID &&
-        status(:only => [:modified, :added, :removed, :deleted]).all? {|_, v| v.empty? }
-      end
-      
-      ##
-      # @see pristine?
-      def changed?; !pristine?; end
-      
-      ##
-      # Effectively FileUtils.pwd
-      # 
-      # @return [String] the current location
-      def cwd
-        dirstate.cwd
-      end
-      alias_method :pwd, :cwd
-      
-      ##
-      # Returns the relative path from +src+ to +dest+.
-      # 
-      # @param [String] src This is a directory! If this is relative,
-      #                     it is assumed to be relative to the root.
-      # @param [String] dest This MUST be within root! It also is a file.
-      # @return [String] the relative path
-      def path_to(src, dest)
-        dirstate.path_to src, dest
-      end
-      
-      ##
-      # Gets the changeset at the given revision.
-      # 
-      # @param [String, Integer] rev the revision index (Integer) or
-      #   node_id (String) that we want to access. if nil, returns
-      #   the working directory. if the string is 'tip', it returns the
-      #   latest head. Can be either a string or an integer; 
-      #   this shit is smart.
-      # @return [Changeset] the changeset at the given revision index or node
-      #   id. Could be working directory.
-      def [](rev)
-        if rev.nil?
-          return WorkingDirectoryChangeset.new(self)
-        end
-        rev = rev.to_i if rev.to_i.to_s == rev
-        return Changeset.new(self, rev)
-      end
-      
-      ##
-      # Iterates over each changeset in the repository, from oldest to newest.
-      # 
-      # @yield each changeset in the repository is yielded to the caller, in order
-      #   from oldest to newest. (Actually, lowest revision # to highest revision #)
-      def each(&block)
-        0.upto(size - 1) { |i| yield self[i]}
-      end
-      
-      ##
-      # Creates a lock at the given path. At first it tries to just make it straight away.
-      # If this fails, we then sleep for up to a given amount of time (defaults to 10 minutes!)
-      # and continually try to acquire the lock.
-      #
-      # @raise [LockHeld] if the lock cannot be acquired, this exception is raised
-      # @param [String] lockname the name of the lock to create
-      # @param [Boolean] wait should we wait for the lock to be released?
-      # @param [Proc, #call] release_proc a proc to run when the lock is released
-      # @param [Proc, #call] acquire_proc a proc to run when we get the lock
-      # @param [String] desc the description of the lock to show if someone stomps on it
-      # @return [Lock] a lock at the given location.
-      def make_lock(lockname, wait, release_proc, acquire_proc, desc)
-        begin
-          lock = Lock.new(lockname, :timeout => 0, :release_fxn => release_proc, :desc => desc)
-        rescue LockHeld => err
-          raise unless wait
-          UI.warn("waiting for lock on #{desc} held by #{err.locker}")
-          lock = Lock.new(lockname, :timeout => @config["ui","timeout","600"].to_i, 
-                                    :release_proc => release_proc, :desc => desc)
-        end
-        acquire_proc.call if acquire_proc  
-        return lock
-      end
-      
-      ##
-      # Locks the repository's .hg/store directory. Returns the lock, or if a block is given,
-      # runs the block with the lock, and clears the lock afterward.
-      #
-      # @yield When a block is given, that block is executed under locked
-      #  conditions. That code can be guaranteed it is the only code running on the
-      #  store in a destructive manner.
-      # @param [Boolean] wait (true) wait for the lock to expire?
-      # @return [Lock] the lock on the .hg/store directory
-      def lock_store(wait = true)
-        return @lock_ref if @lock_ref && @lock_ref.weakref_alive?
-        
-        lock = make_lock(store_join("lock"), wait, nil, nil, "repository #{root}")
-        @lock_ref = WeakRef.new(lock)
-        if block_given?
-          begin
-            yield
-          ensure
-            @lock_ref = nil
-            lock.release
-          end
-        else
-          return lock
-        end
-      end
-      
-      ##
-      # Locks the repository's .hg/store directory. Returns the lock, or if a block is given,
-      # runs the block with the lock, and clears the lock afterward.
-      #
-      # @yield When a block is given, that block is executed under locked
-      #  conditions. That code can be guaranteed it is the only code running on the
-      #  working directory in a destructive manner.
-      # @param [Boolean] wait (true) wait for the lock to expire?
-      # @return [Lock] the lock on the .hg/store directory
-      def lock_working(wait = true)
-        return @working_lock_ref if @working_lock_ref && @working_lock_ref.weakref_alive?
-        
-        lock = make_lock(join("wlock"), wait, nil, nil, "working directory of #{root}")
-        @working_lock_ref = WeakRef.new(lock)
-        if block_given?
-          begin
-            yield
-          ensure
-            @working_lock_ref = nil
-            lock.release
-          end
-        else
-          return lock
-        end
-      end
-      
-      ##
-      # Takes a block, and runs that block with both the store and the working directory locked.
-      #
-      # @param [Boolean] wait (true) should we wait for locks, or jsut give up early?
-      def lock_working_and_store(wait=true)
-        lock_store(wait) do
-          lock_working(wait) do
-            yield
-          end
-        end
-      end
-      
-      ##
-      # Gets the file-log for the given path, so we can look at an individual
-      # file's history, for example.
-      # 
-      # @param [String] f the path to the file
-      # @return [FileLog] a filelog (a type of revision log) for the given file
-      def file(f)
-        f = f[1..-1] if f[0, 1] == "/"
-        FileLog.new @store.opener, f
-      end
-      
-      ##
-      # Returns the parent changesets of the specified changeset. Defaults to the
-      # working directory, if +change_id+ is unspecified.
-      #
-      # @param [Integer, String] change_id the ID (or index) of the requested changeset
-      # @return [Array<Changeset>] the parent changesets of the requested changeset
-      def parents(change_id = nil)
-        self[change_id].parents
-      end
-      
-      ##
-      # Gets a versioned file for the given path, so we can look at the individual
-      # file's history with the file object itself.
-      #
-      # @param [String] path the path to the file
-      # @param [Hash] opts the options for creating the versioned file
-      # @option [String] opts change_id (nil) The ID of the changeset in question
-      # @option [String, Integer] opts file_id (nil) the revision # or node ID of
-      #   into the file_log
-      def versioned_file(path, opts={})
-        VersionedFile.new(self, path, opts)
-      end
-      
-      ##
-      # Gets a versioned file, but using the working directory, so we are looking
-      # past the last commit. Important because it uses a different class. Duh.
-      #
-      # @param [String] path the path to the file
-      # @param [Hash] opts the options for creating the versioned file
-      # @option [String] opts change_id (nil) The ID of the changeset in question
-      # @option [String, Integer] opts file_id (nil) the revision # or node ID of
-      #   into the file_log
-      def working_file(path, opts={})
-        VersionedWorkingFile.new(self, path, opts)
-      end
-      
-      ##
-      # Reads from a file, but in the working directory.
-      # Uses encoding if we are set up to do so.
-      # 
-      # @param [String] filename the file to read from the working directory
-      # @return [String] the data read from the file, encoded if we are set
-      #   up to do so.
-      def working_read(filename)
-        data = @file_opener.open(filename, "r") {|f| f.read }
-        data = @filters["encode"].call(filename, data) if @filters["encode"]
-        data
-      end
-      
-      ##
-      # Writes to a file, but in the working directory. Uses encoding if we are
-      # set up to do so. Also handles symlinks and executables. Ugh.
-      #
-      # @param [String] path the path to the file to write to
-      # @param [String] data the data to write
-      # @param [String] flags the flags to set
-      def working_write(path, data, flags)
-        @file_opener.open(path, "w") do |file|
-          file.write(data)
-        end
-        if flags && flags.include?('x')
-          File.amp_set_executable(working_join(path), true)
-        end
-      end
-      
-      ##
-      # Returns the changelog for this repository. This changelog basically
-      # is the history of all commits.
-      # 
-      # @return [ChangeLog] the commit history object for the entire repo.
-      def changelog
-        return @changelog if @changelog
-        
-        @changelog = ChangeLog.new @store.opener
-        
-        if path = ENV['HG_PENDING']
-          if path =~ /^#{root}/
-            @changelog.read_pending('00changelog.i.a')
-          end
-        end
-        
-        @changelog
-      end
-      
-      ##
-      # Returns the merge state for this repository. The merge state keeps track
-      # of what files need to be merged for an update to be successfully completed.
-      # 
-      # @return [MergeState] the repository's merge state.
-      def merge_state
-        @merge_state ||= Amp::Merges::MergeState.new(self)
-      end
-      
-      ##
-      # Returns the manifest for this repository. The manifest keeps track
-      # of what files exist at what times, and if they have certain flags
-      # (such as executable, or is it a symlink).
-      # 
-      # @return [Manifest] the manifest for the repository
-      def manifest
-        return @manifest if @manifest
-        
-        changelog #load the changelog
-        @manifest = Manifest.new @store.opener
-      end
-      
-      ##
-      # Returns the dirstate for this repository. The dirstate keeps track
-      # of files status, such as removed, added, merged, and so on. It also
-      # keeps track of the working directory.
-      # 
-      # @return [DirState] the dirstate for this local repository.
-      def dirstate
-        return @dirstate if @dirstate
-        
-        opener = Amp::Opener.new @root
-        opener.default = :open_hg
-        
-        @dirstate = DirState.new(@root, @config, opener)
-        @dirstate.read!
-      end
-      
-      ##
-      # Returns the URL of this repository. Uses the "file:" scheme as such.
-      #
-      # @return [String] the URL pointing to this repo
-      def url; "file:#{@root}"; end
-      
-      ##
-      # Opens a file using our opener. Can only access files in .hg/
-      def open(*args, &block)
-        @hg_opener.open(*args, &block)
-      end
-      
-      ##
-      # Joins the path to the repo's root (not .hg, the working dir root)
-      # 
-      # @param path the path we're joining
-      # @return [String] the path joined to the working directory's root
-      def working_join(path)
-        File.join(@root, path)
-      end
-
-      ##
-      # Joins the path from this repo's path (.hg), to the file provided.
-      # 
-      # @param file the file we need the path for
-      # @return [String] the repo's root, joined with the file's path
-      def join(file)
-        File.join(@hg, file)
-      end
-      
-      ##
-      # Joins the path, with a bunch of other args, to the store's directory.
-      # Used for opening {FileLog}s and whatnot.
-      # 
-      # @param file the path to the file
-      # @return [String] the path to the file from the store. 
-      def store_join(file)
-        @store.join file
-      end
-      
-      ##
-      # Looks up an identifier for a revision in the commit history. This
-      # key could be an integer (specifying a revision number), "." for
-      # the latest revision, "null" for the null revision, "tip" for
-      # the tip of the repository, a node_id (in hex or binary form) for
-      # a revision in the changelog. Yeah. It's a flexible method.
-      # 
-      # @param key the key to lookup in the history of the repo
-      # @return [String] a node_id into the changelog for the requested revision
-      def lookup(key)
-        key = key.to_i if key.to_i.to_s == key.to_s # casting for things like "10"
-        case key
-        when Fixnum, Bignum, Integer
-          changelog.node_id_for_index(key)
-        when "." 
-          dirstate.parents().first
-        when "null", nil
-          NULL_ID
-        when "tip"
-          changelog.tip
-        else
-          
-          n = changelog.id_match(key)
-          return n if n
-          
-          return tags[key] if tags[key]
-          return branch_tags[key] if branch_tags[key]
-          
-          n = changelog.partial_id_match(key)
-          return n if n
-          
-          # bail
-          raise RepoError.new("unknown revision #{key}")
-        end
-      end
-      
-      ##
-      # Finds the nodes between two nodes - this algorithm is ported from the
-      # python for mercurial (localrepo.py:1247, for 1.2.1 source). Since this
-      # is used by servers, it implements their algorithm... which seems to
-      # intentionally not return every node between +top+ and +bottom+.
-      # Each one is twice as far from +top+ as the previous.
-      #
-      # @param [Array<String, String>] An array of node-id pairs, which are arrays
-      #   of [+top+, +bottom+], which are:
-      #   top [String] the "top" - or most recent - revision's node ID
-      #   bottom [String] the "bottom" - or oldest - revision's node ID
-      #
-      # return [Array<String>] a list of node IDs that are between +top+ and +bottom+
-      def between(pairs)
-        pairs.map do |top, bottom|
-          node, list, counter = top, [], 0
-          add_me = 1
-          while node != bottom && node != NULL_ID
-            if counter == add_me
-              list << node
-              add_me *= 2
-            end
-            parent = changelog.parents_for_node(node).first
-            node   = parent
-            counter += 1
-          end
-          list
-        end
-      end
-      
-      ##
-      # Pull new changegroups from +remote+
-      # This does not apply the changes, but pulls them onto
-      # the local server.
-      # 
-      # @param [String] remote the path of the remote source (will either be
-      #   an HTTP repo or an SSH repo)
-      # @param [{Symbol => [String] or Boolean}] this reads two parameters from
-      #   opts -- heads and force. heads is the changesets to collect. If this
-      #   is empty, it will pull from tip.
-      def pull(remote, opts={:heads => nil, :force => nil})
-        lock_store do
-          # get the common nodes, missing nodes, and the remote heads
-          # this is findcommonincoming in the Python code, for those with both open
-          common, fetch, remote_heads = *common_nodes(remote, :heads => opts[:heads],
-                                                              :force => opts[:force])
-          
-          UI::status 'requesting all changes'          if fetch == [NULL_ID]
-          if fetch.empty?
-            UI::status 'no changes found'
-            return 0
-          end
-          
-          if (opts[:heads].nil? || opts[:heads].empty?) && remote.capable?('changegroupsubset')
-            opts[:heads] = remote_heads
-          end
-          opts[:heads] ||= []
-          cg = if opts[:heads].empty?
-                 remote.changegroup fetch, :pull
-               else
-                 # check for capabilities
-                 unless remote.capable? 'changegroupsubset'
-                   raise abort('Partial pull cannot be done because' +
-                                        'the other repository doesn\'t support' +
-                                        'changegroupsubset')
-                 end # end unless
-                 
-                 remote.changegroup_subset fetch, opts[:heads], :pull
-               end
-          
-          add_changegroup cg, :pull, remote.url
-        end
-      end
-      
-      ##
-      # Add a changegroup to the repo.
-      # 
-      # Return values:
-      # - nothing changed or no source: 0
-      # - more heads than before: 1+added_heads (2..n)
-      # - fewer heads than before: -1-removed_heads (-2..-n)
-      # - number of heads stays the same: 1
-      # 
-      # Don't the first and last conflict? they stay the same if
-      # nothing has changed...
-      def add_changegroup(source, type, url, opts={:empty => []})
-        run_hook :pre_changegroup, :throw => true, :source => type, :url => url
-        changesets = files = revisions = 0
-        
-        return 0 if source.string.empty?
-        
-        rev_map = proc {|x| changelog.revision_index_for_node x }
-        cs_map  = proc do |x|
-          UI::debug "add changeset #{short x}"
-          changelog.size
-        end
-        
-        # write changelog data to temp files so concurrent readers will not
-        # see inconsistent view
-        changelog.delay_update
-        old_heads  = changelog.heads.size
-        new_heads  = nil # scoping
-        changesets = nil # scoping
-        cor        = nil # scoping
-        cnr        = nil # scoping
-        heads      = nil # scoping
-        
-        Journal::start join('journal') do |journal|
-          UI::status 'adding changeset'
-          
-          # pull of the changeset group
-          cor = changelog.size - 1
-          unless changelog.add_group(source, cs_map, journal) || opts[:empty].any?
-            raise abort("received changelog group is empty")
-          end
-          
-          cnr = changelog.size - 1
-          changesets = cnr - cor
-          
-          # pull off the manifest group
-          UI::status 'adding manifests'
-          
-          # No need to check for empty manifest group here:
-          # if the result of the merge of 1 and 2 is the same in 3 and 4,
-          # no new manifest will be created and the manifest group will be
-          # empty during the pull
-          manifest.add_group source, rev_map, journal
-          
-          # process the files
-          UI::status 'adding file changes'
-          
-          loop do
-            f = Amp::RevlogSupport::ChangeGroup.get_chunk source
-            break if f.empty?
-            
-            UI::debug "adding #{f} revisions"
-            fl = file f
-            o  = fl.index_size
-            unless fl.add_group source, rev_map, journal
-              raise abort('received file revlog group is empty')
-            end
-            revisions += fl.index_size - o
-            files += 1
-          end # end loop
-          
-          new_heads = changelog.heads.size
-          heads     = ""
-          
-          unless old_heads.zero? || new_heads == old_heads
-            heads = " (+#{new_heads - old_heads} heads)"
-          end
-          
-          UI::status("added #{changesets} changesets" +
-                     " with #{revisions} changes to #{files} files#{heads}")
-          
-          if changesets > 0
-            changelog.write_pending
-            p = proc { changelog.write_pending && root or "" }
-            run_hook :pre_txnchangegroup, :throw  => true,
-                                          :node   => changelog.node_id_for_index(cor+1).hexlify,
-                                          :source => type,
-                                          :url    => url
-          end
-          
-          changelog.finalize journal
-          
-        end # end Journal::start
-        
-        if changesets > 0
-          # forcefully update the on-disk branch cache
-          UI::debug 'updating the branch cache'
-          branch_tags
-          run_hook :post_changegroup, :node => changelog.node_id_for_index(cor+1).hexlify, :source => type, :url => url
-          
-          ((cor+1)..(cnr+1)).to_a.each do |i|
-            run_hook :incoming, :node   => changelog.node_id_for_index(i).hexlify,
-                                :source => type,
-                                :url    => url
-          end # end each
-        end # end if
-        
-        hdz = branch_heads
-        # never return 0 here
-        ret = if new_heads < old_heads
-                new_heads - old_heads - 1
-              else
-                new_heads - old_heads + 1
-              end # end if
-        
-        # class << ret
-        #   def success?; self <= 1 || hdz.size == 1; end
-        # end
-        
-        ret
-      end # end def
-      
-      ##
-      # A changegroup, of some sort.
-      def changegroup(base_nodes, source)
-        changegroup_subset(base_nodes, heads, source)
-      end
-      
-      ##
-      # Prints information about the changegroup we are going to receive.
-      #
-      # @param [Array<String>] nodes the list of node IDs we are receiving
-      # @param [Symbol] source how are we receiving the changegroup?
-      # @todo add more debug info
-      def changegroup_info(nodes, source)
-        # print info
-        if source == :bundle
-          UI.status("#{nodes.size} changesets found")
-        end
-        # debug stuff
-      end
-      
-      ##
-      # Faster version of changegroup_subset. Useful when pushing working dir.
-      #
-      # Generate a changegruop of all nodes that we have that a recipient
-      # doesn't
-      #
-      # This is much easier than the previous function as we can assume that
-      # the recipient has any changegnode we aren't sending them.
-      #
-      # @param [[String]] common the set of common nodes between remote and self
-      # @param [Amp::Repository] source
-      def get_changegroup(common, source)
-        # Call the hooks
-        run_hook :pre_outgoing, :throw => true, :source => source
-        
-        nodes = changelog.find_missing common
-        revset = Hash.with_keys(nodes.map {|n| changelog.rev(n)})
-
-        changegroup_info nodes, source
-        
-        identity = proc {|x| x }
-        
-        # ok so this method goes through the generic revlog, and looks for nodes
-        # in the changeset(s) we're pushing. Works by the link_rev - basically,
-        # the changelog says "hey we're at revision 35", and any changes to any
-        # files in any revision logs for that commit will have a link_revision
-        # of 35. So we just look for 35!
-        gen_node_list = proc do |log|
-          log.select {|r| revset[r.link_rev] }.map {|r| r.node_id }
-        end
-        
-        # Ok.... I've tried explaining this 3 times and failed.
-        #
-        # Goal of this proc: We need to update the changed_files hash to reflect
-        # which files (typically file logs) have changed since the last push.
-        #
-        # How it works: it generates a proc that takes a node_id. That node_id
-        # will be looked up in the changelog.i file, which happens to store a
-        # list of files that were changed in that commit! So really, this method
-        # just takes a node_id, and adds filenamess to the list of changed files.
-        changed_file_collector = proc do |changed_fileset|
-          proc do |cl_node|
-            c = changelog.read cl_node
-            c[3].each {|fname| changed_fileset[fname] = true }
-          end
-        end
-        
-        lookup_revlink_func = proc do |revlog|
-          # given a revision, return the node
-          # good thing the python has a description of what this does
-          #
-          # *snort*
-          lookup_revlink = proc do |n|
-            changelog.node revlog[n].link_rev
-          end
-        end
-        
-        # This constructs a changegroup, or a list of all changed files.
-        # If you're here, looking at this code, this bears repeating:
-        # - Changelog
-        # -- ChangeSet+
-        # 
-        # A Changelog (history of a branch) is an array of ChangeSets,
-        # and a ChangeSet is just a single revision, containing what files
-        # were changed, who did it, and the commit message. THIS IS JUST A
-        # RECEIPT!!!
-        # 
-        # The REASON we construct a changegroup here is because this is called
-        # when we push, and we push a changelog (usually bundled to conserve
-        # space). This is where we make that receipt, called a changegroup.
-        # 
-        # 'nuff tangent, time to fucking code
-        generate_group = proc do
-          result = []
-          changed_files = {}
-          
-          coll = changed_file_collector[changed_files]
-          # get the changelog's changegroups
-          changelog.group(nodes, identity, coll) {|chunk| result << chunk }
-          
-
-          node_iter = gen_node_list[manifest]
-          look      = lookup_revlink_func[manifest]
-          # get the manifest's changegroups
-          manifest.group(node_iter, look) {|chunk| result << chunk }
-                   
-          changed_files.keys.sort.each do |fname|
-            file_revlog = file fname
-            # warning: useless comment
-            if file_revlog.index_size.zero?
-              raise abort("empty or missing revlog for #{fname}")
-            end
-            
-            node_list = gen_node_list[file_revlog]
-            
-            if node_list.any?
-              result << RevlogSupport::ChangeGroup.chunk_header(fname.size)
-              result << fname
-              
-              lookup = lookup_revlink_func[file_revlog] # Proc#call
-              # more changegroups
-              file_revlog.group(node_list, lookup) {|chunk| result << chunk }
-            end
-          end
-          result << RevlogSupport::ChangeGroup.closing_chunk
-          
-          run_hook :post_outgoing, :node => nodes[0].hexlify, :source => source
-          
-          result
-        end
-        
-        s = StringIO.new "",(ruby_19? ? "w+:ASCII-8BIT" : "w+")
-        generate_group[].each {|chunk| s.write chunk }
-        s.rewind
-        s
-      end
-       
-      ##
-      # This function generates a changegroup consisting of all the nodes
-      # that are descendents of any of the bases, and ancestors of any of
-      # the heads.
-      # 
-      # It is fairly complex in determining which filenodes and which
-      # manifest nodes need to be included for the changeset to be complete
-      # is non-trivial.
-      # 
-      # Another wrinkle is doing the reverse, figuring out which changeset in
-      # the changegroup a particular filenode or manifestnode belongs to.
-      # 
-      # The caller can specify some nodes that must be included in the
-      # changegroup using the extranodes argument.  It should be a dict
-      # where the keys are the filenames (or 1 for the manifest), and the
-      # values are lists of (node, linknode) tuples, where node is a wanted
-      # node and linknode is the changelog node that should be transmitted as
-      # the linkrev.
-      # 
-      # MAD SHOUTZ to Eric Hopper, who actually had the balls to document a
-      # good chunk of this code in the Python. He is a really great man, and
-      # deserves whatever thanks we can give him. *Peace*
-      # 
-      # @param [String => [(String, String)]] extra_nodes the key is a filename
-      #   and the value is a list of (node, link_node) tuples
-      def changegroup_subset(bases, new_heads, source, extra_nodes=nil)
-        unless extra_nodes
-          if new_heads.sort! == heads.sort!
-            common = []
-            
-            # parents of bases are known from both sides
-            bases.each do |base|
-              changelog.parents_for_node(base).each do |parent|
-                common << parent unless parent.null? # == NULL_ID
-              end # end each
-            end # end each
-            
-            # BAIL
-            return get_changegroup(common, source)
-          end # end if
-        end # end unless
-        
-        run_hook :pre_outgoing, :throw => true, :source => source # call dem hooks
-        
-        
-        # missing changelog list, bases, and heads
-        # 
-        # Some bases may turn out to be superfluous, and some heads may be as
-        # well. #nodes_between will return the minimal set of bases and heads
-        # necessary to recreate the changegroup.
-        # missing_cl_list, bases, heads = changelog.nodes_between(bases, heads)
-        btw = changelog.nodes_between(bases, heads)
-        missing_cl_list, bases, heads = btw[:between], btw[:roots], btw[:heads]
-        changegroup_info missing_cl_list, source
-        
-        # Known heads are the list of heads about which it is assumed the recipient
-        # of this changegroup will know.
-        known_heads = []
-        
-        # We assume that all parents of bases are known heads.
-        bases.each do |base|
-          changelog.parents_for_node(base).each do |parent|
-            known_heads << parent
-          end # end each
-        end # end each
-        
-        if known_heads.any? # unless known_heads.empty?
-          # Now that we know what heads are known, we can compute which
-          # changesets are known. The recipient must know about all
-          # changesets required to reach the known heads from the null
-          # changeset.
-          has_cl_set = changelog.nodes_between(nil, known_heads)[:between]
-          
-          # cast to a hash for latter usage
-          has_cl_set = Hash.with_keys has_cl_set
-        else
-          # If there were no known heads, the recipient cannot be assumed to
-          # know about any changesets.
-          has_cl_set = {}
-        end
-        
-        # We don't know which manifests are missing yet
-        missing_mf_set = {}
-        # Nor do we know which filenodes are missing.
-        missing_fn_set = {}
-        
-        ########
-        # Here are procs for further usage
-        
-        # A changeset always belongs to itself, so the changenode lookup
-        # function for a changenode is +identity+
-        identity = proc {|x| x }
-        
-        # A function generating function. Sets up an enviroment for the 
-        # inner function.
-        cmp_by_rev_function = proc do |rvlg|
-          # Compare two nodes by their revision number in the environment's
-          # revision history. Since the revision number both represents the
-          # most efficient order to read the nodes in, and represents a
-          # topological sorting of the nodes, this function if often useful.
-          proc {|a, b| rvlg.rev(a) <=> rvlg.rev(b) }
-        end
-        
-        # If we determine that a particular file or manifest node must be a
-        # node that the recipient of the changegroup will already have, we can
-        # also assume the recipient will have all the parents. This function
-        # prunes them from the set of missing nodes.
-        prune_parents = proc do |rvlg, hasses, missing|
-          has_list = hasses.keys
-          has_list.sort!(&cmp_by_rev_function(rvlg))
-          
-          has_list.each do |node|
-            parent_list = revlog.parent_for_node(node).select {|p| p.not_null? }
-          end
-          
-          while parent_list.any?
-            n = parent_list.pop
-            unless hasses.include? n
-              hasses[n] = 1
-              p = revlog.parent_for_node(node).select {|p| p.not_null? }
-              parent_list += p
-            end
-          end
-          
-          hasses.each do |n|
-            missing.slice!(n - 1, 1) # pop(n, None)
-          end
-        end
-        
-        # This is a function generating function used to set up an environment
-        # for the inner funciont to execute in.
-        manifest_and_file_collector = proc do |changed_fileset|
-          # This is an information gathering function that gathers
-          # information from each changeset node that goes out as part of
-          # the changegroup. The information gathered is a list of which
-          # manifest nodes are potentially required (the recipient may already
-          # have them) and total list of all files which were changed in any
-          # changeset in the changegroup.
-          # 
-          # We also remember the first changenode we saw any manifest
-          # referenced by so we can later determine which changenode owns
-          # the manifest.
-          
-          # this is what we're returning
-          proc do |cl_node|
-            c = changelog.read cl_node
-            c[3].each do |f|
-              # This is to make sure we only have one instance of each
-              # filename string for each filename
-              changed_fileset[f] ||= f
-            end # end each
-            
-            missing_mf_set[c[0]] ||= cl_node
-          end # end proc
-        end # end proc
-        
-        # Figure out which manifest nodes (of the ones we think might be part
-        # of the changegroup) the recipients must know about and remove them
-        # from the changegroup.
-        prune_manifest = proc do
-          has_mnfst_set = {}
-          missing_mf_set.values.each do |node|
-            # If a 'missing' manifest thinks it belongs to a changenode
-            # the recipient is assumed to have, obviously the recipient
-            # must have the manifest.
-            link_node = changelog.node manifest.link_rev(manifest.revision_index_for_node(node))
-            has_mnfst_set[n] = 1 if has_cl_set.include? link_node
-          end # end each
-          
-          prune_parents[manifest, has_mnfst_set, missing_mf_set] # Proc#call
-        end # end proc
-        
-        # Use the information collected in collect_manifests_and_files to say
-        # which changenode any manifestnode belongs to.
-        lookup_manifest_link = proc {|node| missing_mf_set[node] }
-        
-        # A function generating function that sets up the initial environment
-        # the inner function.
-        filenode_collector = proc do |changed_files|
-          next_rev = []
-          
-          # This gathers information from each manifestnode included in the
-          # changegroup about which filenodes the manifest node references
-          # so we can include those in the changegroup too.
-          #
-          # It also remembers which changenode each filenode belongs to.  It
-          # does this by assuming the a filenode belongs to the changenode
-          # the first manifest that references it belongs to.
-          collect_missing_filenodes = proc do |node|
-            r = manifest.rev node
-            
-            if r == next_rev[0]
-              
-              # If the last rev we looked at was the one just previous,
-              # we only need to see a diff.
-              delta_manifest = manifest.read_delta node
-              
-              # For each line in the delta
-              delta_manifest.each do |f, fnode|
-                f = changed_files[f]
-                
-                # And if the file is in the list of files we care
-                # about.
-                if f
-                  # Get the changenode this manifest belongs to
-                  cl_node = missing_mf_set[node]
-                  
-                  # Create the set of filenodes for the file if
-                  # there isn't one already.
-                  ndset = missing_fn_set[f] ||= {}
-                  
-                  # And set the filenode's changelog node to the
-                  # manifest's if it hasn't been set already.
-                  ndset[fnode] ||= cl_node
-                end
-              end
-            else
-              # Otherwise we need a full manifest.
-              m = manifest.read node
-              
-              # For every file in we care about.
-              changed_files.each do |f|
-                fnode = m[f]
-                
-                # If it's in the manifest
-                if fnode
-                  # See comments above.
-                  cl_node = msng_mnfst_set[mnfstnode]
-                  ndset   = missing_fn_set[f] ||= {}
-                  ndset[fnode] ||= cl_node
-                end
-              end
-            end
-            
-            # Remember the revision we hope to see next.
-            next_rev[0] = r + 1
-          end # end proc
-        end # end proc
-        
-        # We have a list of filenodes we think need for a file, let's remove
-        # all those we know the recipient must have.
-        prune_filenodes = proc do |f, f_revlog|
-          missing_set = missing_fn_set[f]
-          hasset = {}
-          
-          # If a 'missing' filenode thinks it belongs to a changenode we
-          # assume the recipient must have, the the recipient must have
-          # that filenode.
-          missing_set.each do |n|
-            cl_node = changelog.node f_revlog[n].link_rev
-            hasset[n] = true if has_cl_set.include? cl_node
-          end
-          
-          prune_parents[f_revlog, hasset, missing_set] # Proc#call
-        end # end proc
-        
-        # Function that returns a function.
-        lookup_filenode_link_func = proc do |name|
-          missing_set = missing_fn_set[name]
-          
-          # lookup the changenode the filenode belongs to
-          lookup_filenode_link = proc do |node|
-            missing_set[node]
-          end # end proc
-        end # end proc
-        
-        # add the nodes that were explicitly requested.
-        add_extra_nodes = proc do |name, nodes|
-          return unless extra_nodes && extra_nodes[name]
-          
-          extra_nodes[name].each do |node, link_node|
-            nodes[node] = link_node unless nodes[node]
-          end
-          
-        end
-        
-        # Now that we have all theses utility functions to help out and
-        # logically divide up the task, generate the group.
-        generate_group = proc do
-          changed_files = {}
-          group = changelog.group(missing_cl_list, identity, &manifest_and_file_collector[changed_files])
-          group.each { |chunk| yield chunk }
-          prune_manifests.call
-          add_extra_nodes[1, msng_mnfst_set]
-          msng_mnfst_lst = msng_mnfst_set.keys
-          
-          msng_mnfst_lst.sort!(&cmp_by_rev_function[manifest])
-          
-          group = manifest.group(msng_mnfst_lst, lookup_filenode_link,
-                                 filenode_collector[changed_files])
-          
-          group.each {|chunk| yield chunk }
-          
-          msng_mnfst_lst = nil
-          msng_mnfst_set.clear
-          
-          if extra_nodes
-            extra_nodes.each do |fname|
-              next if fname.kind_of?(Integer)
-              msng_mnfst_set[fname] ||= {}
-              changed_files[fname] = true
-            end
-          end
-          
-          changed_files.sort.each do |fname|
-            file_revlog = file(fname)
-            unless file_revlog.size > 0
-              raise abort("empty or missing revlog for #{fname}")
-            end
-            
-            if msng_mnfst_set[fname]
-              prune_filenodes[fname, file_revlog]
-              add_extra_nodes[fname, missing_fn_set[fname]]
-              missing_fn_list = missing_fn_set[fname].keys
-            else
-              missing_fn_list = []
-            end
-            
-            if missing_fn_list.size > 0
-              yield ChangeGroup.chunk_header(fname.size)
-              yield fname
-              missing_fn_list.sort!(&cmp_by_rev_function[file_revlog])
-              group = file_revlog.group(missing_fn_list,
-                                        lookup_filenode_link_func[fname])
-              group.each {|chunk| yield chunk }
-            end
-            if missing_fn_set[fname]
-              missing_fn_set.delete fname
-            end
-          end
-          
-          yield ChangeGroup.close_chunk
-          
-          if missing_cl_list
-            run_hook :post_outgoing
-          end
-        end # end proc
-        
-        s = StringIO.new "",(ruby_19? ? "w+:ASCII-8BIT" : "w+")
-        generate_group.call do |chunk|
-          s.write chunk
-        end
-        s.seek(0, IO::SEEK_SET)
-        
-      end # end def
-      
-      ##
-      # Revert a file or group of files to +revision+. If +opts[:unlink]+
-      # is true, then the files 
-      # 
-      # @param  [Array<String>] files a list of files to revert
-      # @return [Boolean] a success marker
-      def revert(files, opts={})
-        # get the parents - used in checking if we haven an uncommitted merge
-        parent, p2 = dirstate.parents
-        
-        # get the revision
-        rev = opts[:revision] || opts[:rev] || opts[:to]
-        
-        # check to make sure it's logically possible
-        unless rev || p2 == RevlogSupport::Node::NULL_ID
-          raise abort("uncommitted merge - please provide a specific revision")
-        end
-        
-        # if we have anything here, then create a matcher
-        matcher = if files
-                    Amp::Match.create :files    => files         ,
-                                      :includer => opts[:include],
-                                      :excluder => opts[:exclude]
-                  else
-                    # else just return nil
-                    # we can return nil because when it gets used in :match => matcher,
-                    # it will be as though it's not even there
-                    nil
-                  end
-        
-        # the changeset we use as a guide
-        changeset = self[rev]
-        
-        # get the files that need to be changed
-        stats = status :node_1 => rev, :match => matcher
-        
-        ###
-        # now make the changes
-        ###
-
-        ##########
-        # MODIFIED and DELETED
-        ##########
-        # Just write the old data to the files
-        (stats[:modified] + stats[:deleted]).each do |path|
-          File.open path, 'w' do |file|
-            file.write changeset.get_file(path).data
-          end
-          UI::status "restored\t#{path}"
-        end
-
-        ##########
-        # REMOVED
-        ##########
-        # these files are set to be removed, and have thus far been dropped from the filesystem
-        # we restore them and we alert the repo
-        stats[:removed].each do |path|
-          File.open path, 'w' do |file|
-            file.write changeset.get_file(path).data
-          end
-
-          dirstate.normal path # pretend nothing happened
-          UI::status "saved\t#{path}"
-        end
-
-        ##########
-        # ADDED
-        ##########
-        # these files have been added SINCE +rev+
-        stats[:added].each do |path|
-          remove path
-          UI::status "destroyed\t#{path}"
-        end # pretend these files were never even there
-        
-        true # success marker
-      end
-      
-      # Return list of roots of the subsets of missing nodes from remote
-      # 
-      # If base dict is specified, assume that these nodes and their parents
-      # exist on the remote side and that no child of a node of base exists
-      # in both remote and self.
-      # Furthermore base will be updated to include the nodes that exists
-      # in self and remote but no children exists in self and remote.
-      # If a list of heads is specified, return only nodes which are heads
-      # or ancestors of these heads.
-      # 
-      # All the ancestors of base are in self and in remote.
-      # All the descendants of the list returned are missing in self.
-      # (and so we know that the rest of the nodes are missing in remote, see
-      # outgoing)
-      def find_incoming_roots(remote, opts={:base  => nil,   :heads => nil,
-                                            :force => false, :base  => nil})
-        common_nodes(remote, opts)[1]
-      end
-      
-      ##
-      # Find the common nodes, missing nodes, and remote heads.
-      # 
-      # So in this code, we use  opts[:base] and fetch as hashes
-      # instead of arrays. We could very well use arrays, but hashes have
-      # O(1) lookup time, and since these could get RFH (Really Fucking
-      # Huge), we decided to take the liberty and just use hash for now.
-      # 
-      # If opts[:base] (Hash) is specified, assume that these nodes and their parents
-      # exist on the remote side and that no child of a node of base exists
-      # in both remote and self.
-      # Furthermore base will be updated to include the nodes that exists
-      # in self and remote but no children exists in self and remote.
-      # If a list of heads is specified, return only nodes which are heads
-      # or ancestors of these heads.
-      # 
-      # All the ancestors of base are in self and in remote.
-      # 
-      # @param [Amp::Repository] remote the repository we're pulling from
-      # @param [(Array<>, Array<>, Array<>)] the common nodes, missing nodes, and
-      #   remote heads
-      def common_nodes(remote, opts={:heads => nil, :force => nil, :base => nil})
-        # variable prep!
-        node_map = changelog.node_map
-        search   = []
-        unknown  = []
-        fetch    = {}
-        seen     = {}
-        seen_branch = {}
-        opts[:base]  ||= {}
-        opts[:heads] ||= remote.heads
-        
-        # if we've got nothing...
-        if changelog.tip == NULL_ID
-          opts[:base][NULL_ID] = true # 1 is stored in the Python
-          
-          return [NULL_ID], [NULL_ID], opts[:heads].dup unless opts[:heads] == [NULL_ID]
-          return [NULL_ID], [], [] # if we didn't trip ^, we're returning this
-        end
-        
-        # assume we're closer to the tip than the root
-        # and start by examining heads
-        UI::status 'searching for changes'
-        
-        opts[:heads].each do |head|
-          if !node_map.include?(head)
-            unknown << head 
-          else
-            opts[:base][head] = true # 1 is stored in the Python
-          end
-        end
-        
-        opts[:heads] = unknown # the ol' switcheroo
-        return opts[:base].keys, [], [] if unknown.empty? # BAIL
-        
-        # make a hash with keys of unknown
-        requests = Hash.with_keys unknown
-        count    = 0
-        # Search through the remote branches
-        # a branch here is a linear part of history, with 4 (four)
-        # parts:
-        # 
-        # head, root, first parent, second parent
-        # (a branch always has two parents (or none) by definition)
-        # 
-        # Here's where we start using the Hashes instead of Arrays
-        # trick. Keep an eye out for opts[:base] and opts[:heads]!
-        unknown = remote.branches(*unknown)
-        until unknown.empty?
-          r = []
-          
-          while node = unknown.shift
-            next if seen.include?(node[0])
-            UI::debug "examining #{short node[0]}:#{short node[1]}"
-            
-            if node[0] == NULL_ID
-              # Do nothing...
-            elsif seen_branch.include? node
-              UI::debug 'branch already found'
-              next
-            elsif node_map.include? node[1]
-              UI::debug "found incomplete branch #{short node[0]}:#{short node[1]}"
-              search << node[0..1]
-              seen_branch[node] = true # 1 in the python
-            else
-              unless seen.include?(node[1]) || fetch.include?(node[1])
-                if node_map.include?(node[2]) and node_map.include?(node[3])
-                  UI::debug "found new changset #{short node[1]}"
-                  fetch[node[1]] = true # 1 in the python
-                end # end if
-                
-                node[2..3].each do |p|
-                  opts[:base][p] = true if node_map.include? p
-                end
-              end # end unless
-              
-              node[2..3].each do |p|
-                unless requests.include?(p) || node_map.include?(p)
-                  r << p
-                  requests[p] = true # 1 in the python
-                end # end unless
-              end # end each
-            end # end if
-            
-            seen[node[0]] = true # 1 in the python
-          end # end while
-          
-          unless r.empty?
-            count += 1
-            
-            UI::debug "request #{count}: #{r.map{|i| short i }}"
-            
-            (0..(r.size-1)).step(10) do |p|
-              remote.branches(r[p..(p+9)]).each do |b|
-                UI::debug "received #{short b[0]}:#{short b[1]}"
-                unknown << b
-              end
-            end
-          end # end unless
-        end # end until
-        
-        # sorry for the ambiguous variable names
-        # the python doesn't name them either, which
-        # means I have no clue what these are
-        find_proc = proc do |item1, item2|
-          fetch[item1]       = true
-          opts[:base][item2] = true
-        end
-        
-        # do a binary search on the branches we found
-        search, new_count = *binary_search(:find => search,
-                                           :repo => remote,
-                                           :node_map => node_map,
-                                           :on_find => find_proc)
-        count += new_count # keep keeping track of the total
-        
-        # sanity check, because this method is sooooo fucking long
-        fetch.keys.each do |f|
-          if node_map.include? f
-            raise RepoError.new("already have changeset #{short f[0..3]}")
-          end
-        end
-        
-        if opts[:base].keys == [NULL_ID]
-          if opts[:force]
-            UI::warn 'repository is unrelated' 
-          else
-            raise RepoError.new('repository is unrelated')
-          end
-        end
-        
-        UI::debug "found new changesets starting at #{fetch.keys.map{|f| short f }.join ' '}"
-        UI::debug "#{count} total queries"
-        
-        # on with the show!
-        [opts[:base].keys, fetch.keys, opts[:heads]]
-      end
-      
-      ##
-      # Call the hooks that run under +call+
-      # 
-      # @param [Symbol] call the location in the system where the hooks
-      #   are to be called
-      def run_hook(call, opts={:throw => false})
-        Hook.run_hook(call, opts)
-      end
-      
-      ##
-      # Adds a list of file paths to the repository for the next commit.
-      # 
-      # @param [String, Array<String>] paths the paths of the files we need to
-      #   add to the next commit
-      # @return [Array<String>] which files WEREN'T added
-      def add(*paths)
-        lock_working do
-          rejected = []
-          paths.flatten!
-          
-          paths.each do |file|
-            path = working_join file
-            
-            st = File.lstat(path) rescue nil
-            
-            unless st
-              UI.warn "#{file} does not exist!"
-              rejected << file
-              next
-            end
-            
-            if st.size > 10.mb
-              UI.warn "#{file}: files over 10MB may cause memory and" +
-                          "performance problems\n" +
-                          "(use 'amp revert #{file}' to unadd the file)\n"
-            end
-            
-            
-            state = dirstate[file]
-            
-            
-            if File.ftype(path) != 'file' && File.ftype(path) != 'link'
-              # fail if it's not a file or link
-              UI.warn "#{file} not added: only files and symlinks supported. Type is #{File.ftype path}"
-              rejected << path
-            elsif state.added? || state.modified? || state.normal?
-              # fail if it's being tracked
-              UI.warn "#{file} already tracked!"
-            elsif state.removed?
-              # check back on it if it's being removed
-              dirstate.normal_lookup file
-            else
-              # else add it
-              dirstate.add file
-              #Amp::Logger.info("added #{file}")
-            end
-          end
-          
-          dirstate.write unless rejected.size == paths.size
-          return rejected
-        end
-      end
-      
-      ##
-      # Returns the number of revisions the repository is tracking.
-      # 
-      # @return [Integer] how many revisions there have been
-      def size
-        changelog.size
-      end
-      
-      ##
-      # Forgets an added file or files from the repository. Doesn't delete the
-      # files, it just says "don't add this on the next commit."
-      #
-      # @param [Array, String] list a file path (or list of file paths) to
-      #   "forget".
-      # @return [Boolean] success marker
-      def forget(list)
-        lock_working do
-          list = [*list]
-          
-          successful = list.any? do |f|
-            if dirstate[f].status != :added
-              UI.warn "#{f} not being added! can't forget it"
-              false
-            else
-              dirstate.forget f
-              true
-            end
-          end
-          
-          dirstate.write if successful
-        end
-        
-        true
-      end
-      
-      ##
-      # Removes the file (or files) from the repository. Marks them as removed
-      # in the DirState, and if the :unlink option is provided, the files are
-      # deleted from the filesystem.
-      #
-      # @param list the list of files. Could also just be 1 file as a string.
-      #   should be paths.
-      # @param opts the options for this removal.
-      # @option [Boolean] opts :unlink (false) whether or not to delete the
-      #   files from the filesystem after marking them as removed from the
-      #   DirState.
-      # @return [Boolean] success?
-      def remove(list, opts={})
-        list = [*list]
-        
-        # Should we delete the filez?
-        if opts[:unlink]
-          list.each do |f|
-            ignore_missing_files do
-              FileUtils.safe_unlink working_join(f)
-            end
-          end
-        end
-        
-        lock_working do
-          # Save ourselves a dirstate write
-          successful = list.any? do |f|
-            if opts[:unlink] && File.exists?(working_join(f))
-              # Uh, why is the file still there? Don't remove it from the dirstate
-              UI.warn("#{f} still exists!")
-              false # no success
-            elsif dirstate[f].added?
-              # Is it already added? if so, forgettaboutit
-              dirstate.forget f
-              #Amp::Logger.info("forgot #{f}")
-              true # success!
-            elsif !dirstate.tracking?(f)
-              # Are we not even tracking this file? dumbass
-              UI.warn("#{f} not being tracked!")
-              false # no success
-            else
-              # Woooo we can delete it
-              dirstate.remove f
-              #Amp::Logger.info("removed #{f}")
-              true
-            end
-          end
-          
-          # Write 'em out boss
-          dirstate.write if successful
-        end
-        
-        true
-      end
-      
-      ##
-      # Returns the parents that aren't NULL_ID
-      def living_parents
-        dirstate.parents.select {|p| p != NULL_ID }
-      end
-      
-      ##
-      # There are two ways to push to remote repo:
-      #
-      # addchangegroup assumes local user can lock remote
-      # repo (local filesystem, old ssh servers).
-      #
-      # unbundle assumes local user cannot lock remote repo (new ssh
-      # servers, http servers).
-      def push(remote_repo, opts={:force => false, :revs => nil})
-        if remote_repo.capable? "unbundle"
-          push_unbundle remote_repo, opts
-        else
-          push_add_changegroup remote_repo, opts
-        end
-      end
-      
-      ##
-      # Push and add a changegroup
-      # @todo -- add default values for +opts+
-      def push_add_changegroup(remote, opts={})
-        # no locking cuz we rockz
-        ret = pre_push remote, opts
-        
-        if ret[0]
-          cg, remote_heads = *ret
-          remote.add_changegroup cg, :push, url
-        else
-          ret[1]
-        end
-      end
-      
-      ##
-      # Push an unbundled dohickey
-      # @todo -- add default values for +opts+
-      def push_unbundle(remote, opts={})
-        # local repo finds heads on server, finds out what revs it
-        # must push. once revs transferred, if server finds it has
-        # different heads (someone else won commit/push race), server
-        # aborts.
-        
-        ret = pre_push remote, opts
-        
-        if ret[0]
-          cg, remote_heads = *ret
-          remote_heads = ['force'] if opts[:force]
-          remote.unbundle cg, remote_heads, :push
-        else
-          ret[1]
-        end
-      end
-      
-      ##
-      # Return list of nodes that are roots of subsets not in remote
-      # 
-      # If base dict is specified, assume that these nodes and their parents
-      # exist on the remote side.
-      # If a list of heads is specified, return only nodes which are heads
-      # or ancestors of these heads, and return a second element which
-      # contains all remote heads which get new children.
-      def find_outgoing_roots(remote, opts={:base => nil, :heads => nil, :force => false})
-        base, heads, force = opts[:base], opts[:heads], opts[:force]
-        if base.nil?
-          base = {}
-          find_incoming_roots remote, :base => base, :heads => heads, :force => force
-        end
-        
-        UI::debug("common changesets up to "+base.keys.map {|k| k.short_hex}.join(" "))
-        
-        remain = Hash.with_keys changelog.node_map.keys, nil
-        
-        # prune everything remote has from the tree
-        remain.delete NULL_ID
-        remove = base.keys
-        while remove.any?
-          node = remove.shift
-          if remain.include? node
-            remain.delete node
-            changelog.parents_for_node(node).each {|p| remove << p }
-          end
-        end
-        
-        # find every node whose parents have been pruned
-        subset = []
-        # find every remote head that will get new children
-        updated_heads = {}
-        remain.keys.each do |n|
-          p1, p2 = changelog.parents_for_node n
-          subset << n unless remain.include?(p1) || remain.include?(p2)
-          if heads && heads.any?
-            updated_heads[p1] = true if heads.include? p1
-            updated_heads[p2] = true if heads.include? p2
-          end
-        end
-        
-        # this is the set of all roots we have to push
-        if heads && heads.any?
-          return subset, updated_heads.keys
-        else
-          return subset
-        end 
-      end
-      
-      ##
-      # The branches available in this repository.
-      # 
-      # @param [Array<String>] nodes the list of nodes. this can be optionally left empty
-      # @return [Array<String>] the branches, active and inactive!
-      def branches(*nodes)
-        branches = []
-        nodes = [changelog.tip] if nodes.empty?
-        
-        # for each node, find its first parent (adam and eve, basically)
-        # -- that's our branch!
-        nodes.each do |node|
-          t = node
-          # traverse the tree, staying to the left side
-          #            node
-          #          /     \
-          #   parent1     parent2
-          # ....              ....
-          # This will get us the first parent. When it's finally NULL_ID,
-          # we have a root -- this is the basis for our branch.
-          loop do
-            parents = changelog.parents_for_node t
-            if parents[1] != NULL_ID || parents[0] == NULL_ID
-              branches << [node, t, *parents]
-              break
-            end
-            t = parents.first # get the first parent and start again
-          end
-        end
-        
-        branches
-      end
-      
-      ##
-      # Copies a file from +source+ to +destination+, while being careful of the
-      # specified options. This method will perform all necessary file manipulation
-      # and dirstate changes and so forth. Just give 'er a source and a destination.
-      #
-      # @param [String] source the path to the source file
-      # @param [String] destination the path to the destination file
-      # @param [Hash] opts the options for the copy
-      # @option [Boolean] opts :after (false) should the file be deleted?
-      # @return [Boolean] success?
-      def copy(source, destination, opts)
-        # Traverse repository subdirectories
-        src    = relative_join source
-        target = relative_join destination
-        
-        # Is there a tracked file at our destination? If so, get its state.
-        state = dirstate[target].status
-        # abstarget is the full path to the target. Needed for system calls
-        # (just to be safe)
-        abstarget = working_join target
-        
-        # If true, we're copying into a directory, so be smart about it.
-        if File.directory? abstarget
-          abstarget = File.join abstarget, File.basename(src)
-          target = File.join target, File.basename(src)
-        end
-        abssrc = working_join(src)
-        
-        
-        exists = File.exist? abstarget
-        # If the file's there, and we aren't forcing the copy, then we should let
-        # the user know they might overwrite an existing file in the repo.
-        if (!opts[:after] && exists || opts[:after] && [:merged, :normal].include?(state))
-          unless opts[:force]
-            Amp::UI.warn "#{target} not overwriting, file exists"
-            return false
-          end
-        end
-        
-        return if opts[:after] && !exists
-        unless opts[:"dry-run"]
-          # Performs actual file copy from one locatino to another.
-          # Overwrites file if it's there.
-          begin
-            File.safe_unlink(abstarget) if exists
-            
-            target_dir = File.dirname abstarget
-            File.makedirs target_dir unless File.directory? target_dir
-            File.copy(abssrc, abstarget)
-          rescue Errno::ENOENT
-            # This happens if the file has been deleted between the check up above
-            # (exists = File.exist? abstarget) and the call to File.safe_unlink.
-            Amp::UI.warn("#{target}: deleted in working copy in the last 2 microseconds")
-          rescue StandardError => e
-            Amp::UI.warn("#{target} - cannot copy: #{e}")
-            return false
-          end
-        end
-        
-        # Be nice and give the user some output
-        if opts[:verbose] || opts[:"dry-run"]
-          action = opts[:rename] ? "moving" : "copying"
-          Amp::UI.status("#{action} #{src} to #{target}")
-        end
-        return false if opts[:"dry-run"]
-        
-        # in case the source of the copy is marked as the destination of a 
-        # different copy (that hasn't yet been committed either), we should
-        # do some extra handling
-        origsrc = dirstate.copy_map[src] || src
-        if target == origsrc
-          # We're copying back to our original location! D'oh.
-          unless [:merged, :normal].include?(state)
-            dirstate.maybe_dirty target
-          end
-        else
-          if dirstate[origsrc].added? && origsrc == src
-            # we copying an added (but uncommitted) file?
-            UI.warn("#{origsrc} has not been committed yet, so no copy data" +
-                    "will be stored for #{target}")
-            if [:untracked, :removed].include?(dirstate[target].status)
-              add [target]
-            end
-          else
-            dirstate_copy src, target
-          end
-        end
-        
-        # Clean up if we're doing a move, and not a copy.
-        remove([src], :unlink => !(opts[:after])) if opts[:rename]
-      end
-      
-      ##
-      # Copy a file from +source+ to +dest+. Really simple, peeps.
-      # The reason this shit is even *slightly* complicated because
-      # it deals with file types. Otherwise I could write this
-      # in, what, 3 lines?
-      # 
-      # @param [String] source the from
-      # @param [String] dest the to
-      def dirstate_copy(source, dest)
-        path = working_join dest
-        
-        if !File.exist?(path) || File.ftype(path) == 'link'
-          UI::warn "#{dest} doesn't exist!"
-        elsif not (File.ftype(path) == 'file' || File.ftype(path) == 'link')
-          UI::warn "copy failed: #{dest} is neither a file nor a symlink"
-        else
-          lock_working do
-            # HOME FREE!!!!!!! i love getting out of school before noon :-D
-            # add it if it makes sense (like it was previously removed or untracked)
-            # and then copy da hoe
-            state  = dirstate[dest].status
-            dirstate.add dest if [:untracked, :removed].include?(state)
-            dirstate.copy source => dest
-            dirstate.write
-            
-            #Amp::Logger.info("copy #{source} -> #{dest}")
-          end
-        end
-      end
-      
-      ##
-      # Undelete a file. For instance, if you remove something and then
-      # find out that you NEED that file, you can use this command.
-      # 
-      # @param [[String]] list the files to be undeleted
-      def undelete(list)
-        manifests = living_parents.map do |p|
-          manifest.read changelog.read(p).first
-        end
-        
-        # now we actually restore the files
-        list.each do |file|
-          unless dirstate[file].removed?
-            UI.warn "#{file} isn't being removed!"
-          else
-            m = manifests[0] || manifests[1]
-            data = file(f).read m[f]
-            add_file file, data, m.flags(f) # add_file is wwrite in the python
-            dirstate.normal f # we know it's clean, we just restored it
-          end
-        end
-      end
-      alias_method :restore, :undelete
-      
-      ##
-      # Write data to a file in the CODE repo, not the .hg
-      # 
-      # @param [String] file_name
-      # @param [String] data (no trailing newlines are appended)
-      # @param [[String]] flags we're really just looking for links
-      #   and executables, here
-      def add_file(file_name, data, flags)
-        data = filter "decode", file_name, data
-        path = "#{@root}/#{file_name}"
-        
-        File.unlink path rescue nil
-        
-        if flags.include? 'l' # if it's a link
-          @file_opener.symlink path, data
-        else
-          @file_opener.open(path, 'w') {|f| f.write data }
-          File.set_flag path, false, true if flags.include? 'x'
-        end
-      end
-      
-      ##
-      # Returns the node_id's of the heads of the repository.
-      def heads(start=nil, options={:closed => true})
-        heads = changelog.heads(start)
-        should_show = lambda do |head|
-          return true if options[:closed]
-          
-          extras = changelog.read(head)[5]
-          return !(extras["close"])
-        end
-        heads = heads.select {|h| should_show[h] }
-        heads.map! {|h| [changelog.rev(h), h] }
-        heads.sort! {|arr1, arr2| arr2[0] <=> arr1[0] }
-        heads.map! {|r, n| n}
-      end
-      
-      ##
-      # Walk recursively through the directory tree (or a changeset)
-      # finding all files matched by the match function
-      # 
-      # @param [String, Integer] node selects which changeset to walk
-      # @param [Amp::Match] match the matcher decides how to pick the files
-      # @param [Array<String>] an array of filenames
-      def walk(node=nil, match = Match.create({}) { true })
-        self[node].walk(match) # calls Changeset#walk
-      end
-      
-      ##
-      # Returns the requested file at the given revision annotated by
-      # line number, so you can see who committed which lines in the file's
-      # history.
-      #
-      # @param file The name of the file to annotate
-      # @param [Integer, String] rev (nil) The revision to look at for
-      #   annotation
-      def annotate(file, revision=nil, opts={})
-        changeset = self[revision]
-        file = changeset.get_file(file)
-        return file.annotate(opts[:follow_copies], opts[:line_numbers])
-      end
-      
-      ##
-      # This gives the status of the repository, comparing 2 node in
-      # its history. Now, with no parameters, it's going to compare the
-      # last revision with the working directory, which is the most common
-      # usage - that answers "what is the current status of the repository,
-      # compared to the last time a commit happened?". However, given any
-      # two revisions, it can compare them.
-      # 
-      # @example @repo.status # => {:unknown => ['code/smthng.rb'], :added => [], ...}
-      # @param [Hash] opts the options for this command. there's a bunch.
-      # @option [String, Integer] opts :node_1 (".") an identifier for the starting
-      #   revision
-      # @option [String, Integer] opts :node_2 (nil) an identifier for the ending
-      #   revision. Defaults to the working directory.
-      # @option [Proc] opts :match (proc { true }) a proc that will match
-      #   a file, so we know if we're interested in it.
-      # @option [Boolean] opts :ignored (false) do we want to see files we're
-      #   ignoring?
-      # @option [Boolean] opts :clean (false) do we want to see files that are
-      #   totally unchanged?
-      # @option [Boolean] opts :unknown (false) do we want to see files we've
-      #   never seen before (i.e. files the user forgot to add to the repo)?
-      # @return [Hash<Symbol => Array<String>>] no, I'm not kidding. the keys are:
-      #   :modified, :added, :removed, :deleted, :unknown, :ignored, :clean. The
-      #   keys are the type of change, and the values are arrays of filenames
-      #   (local to the root) that are under each key.
-      def status(opts={:node_1 => '.'})
-        run_hook :status
-        
-        node1, node2, match = opts[:node_1], opts[:node_2], opts[:match]
-        
-        match = Match.create({}) { true } unless match
-        
-        node1 = self[node1] unless node1.kind_of? Changeset # get changeset objects
-        node2 = self[node2] unless node2.kind_of? Changeset
-        
-        write_dirstate = false
-        
-        # are we working with working directories?
-        working = node2.revision == nil
-        parent_working = working && node1 == self["."]
-        
-        # load the working directory's manifest
-        node2.manifest if !working && node2.revision < node1.revision
-        
-        if working
-          # get the dirstate's latest status
-          status = dirstate.status(opts[:ignored], opts[:clean], opts[:unknown], match)
-          
-          # this case is run about 99% of the time
-          # do we need to do hashes on any files to see if they've changed?
-          if parent_working && status[:lookup].any?
-            # lookup.any? is a shortcut for !lookup.empty?
-            clean, modified, write_dirstate = *fix_files(status[:lookup], node1, node2)
-            
-            status[:clean]    += clean
-            status[:modified] += modified
-          end
-        else
-          status = {:clean => [], :modified => [], :lookup => [], :unknown => [], :ignored => [],
-                    :removed => [], :added => [], :deleted => []}
-        end
-        # if we're working with old revisions...
-        unless parent_working
-          # get the older revision manifest
-          mf1 = node1.manifest.dup
-          
-          if working
-            # get the working directory manifest. note, it's a tweaked
-            # manifest to reflect working directory files
-            mf2 = self["."].manifest.dup
-            
-            # mark them as not in the manifest to force checking later
-            files_for_later = status[:lookup] + status[:modified] + status[:added]
-            files_for_later.each {|file| mf2.mark_for_later file, node2 }
-            
-            # remove any files we've marked as removed them from the '.' manifest
-            status[:removed].each {|file| mf2.delete file }
-          else
-            # if we aren't working with the working directory, then we'll
-            # just use the old revision's information
-            status[:removed], status[:unknown], status[:ignored] = [], [], []
-            mf2 = node2.manifest.dup
-          end
-          
-          # Every file in the later revision (or working directory)
-          mf2.each do |file, node|
-            # Does it exist in the old manifest? If so, it wasn't added.
-            if mf1[file]
-              # the tests to run
-              tests = [ mf1.flags[file] != mf2.flags[file]           ,
-                        mf1[file] != mf2[file] &&
-                          (mf2[file] || node1[file] === node2[file]) ]
-              
-              # It's in the old manifest, so lets check if its been changed
-              # Else, it must be unchanged
-              if tests.any?
-                status[:modified] << file 
-                status[:clean]    << file if opts[:clean]
-              end
-              
-              # Remove that file from the old manifest, since we've checked it
-              mf1.delete file
-            else
-              # if it's not in the old manifest, it's been added
-              status[:added] << file
-            end
-          end
-          
-          # Anything left in the old manifest is a file we've removed since the
-          # first revision.
-          status[:removed] = mf1.keys
-        end
-        
-        # We're done!
-        status.delete :lookup # because nobody cares about it
-        delta = status.delete :delta
-        
-        status.map {|k, v| [k, v.sort] }.to_hash # sort dem fuckers
-        status[:delta] = delta
-        status.select {|k, _| opts[:only] ? opts[:only].include?(k) : true }.to_hash
-      end
-      
-      ##
-      # Clone a repository.
-      # 
-      # Here is what this does, pretty much:
-      #   % amp init monkey
-      #   % cd monkey
-      #   % amp pull http://monkey
-      # 
-      # It's so simple it's not even funny.
-      # 
-      # @param [Amp::Repository] remote repository to pull from
-      # @param [Array<String>] heads list of revs to clone (forces use of pull)
-      # @param [Boolean] stream do we stream from the remote source?
-      def clone(remote, opts={:revs => [], :stream => false})
-        # now, all clients that can request uncompressed clones can
-        # read repo formats supported by all servers that can serve
-        # them.
-        
-        # The streaming case:
-        # if revlog format changes, client will have to check version
-        # and format flags on "stream" capability, and use
-        # uncompressed only if compatible.
-        if opts[:stream] && opts[:revs].any? && remote.capable?('stream')
-          stream_in remote
-        else
-          pull remote, :revs => opts[:revs]
-        end
-      end
-      
-      ##
-      # Stream in the data from +remote+.
-      # 
-      # @param [Amp::Repository] remote repository to pull from
-      # @return [Integer] the number of heads in the repository minus 1
-      def stream_in(remote)
-        remote.stream_out do |f|
-          l = f.gets # this should be the server code
-          
-          unless Integer(l)
-            raise ResponseError.new("Unexpected response from server: #{l}")
-          end
-          
-          case l.to_i
-          when 1
-            raise RepoError.new("operation forbidden by server")
-          when 2
-            raise RepoError.new("locking the remote repository failed")
-          end
-          
-          UI::status "streaming all changes"
-          
-          l = f.gets # this is effectively [total_files, total_bytes].join ' '
-          total_files, total_bytes = *l.split(' ').map {|i| i.to_i }[0..1]
-          UI::status "#{total_files} file#{total_files == 1 ? '' : 's' } to transfer, #{total_bytes.to_human} of data"
-          
-          start = Time.now
-          total_files.times do |i|
-            l = f.gets
-            name, size = *l.split("\0")[0..1]
-            size = size.to_i
-            UI::debug "adding #{name} (#{size.to_human})"
-            
-            @store.opener.open do |store_file|
-              chunk = f.read size # will return nil if at EOF
-              store_file.write chunk if chunk
-            end
-          end
-          
-          elapsed = Time.now - start
-          elapsed = 0.001 if elapsed <= 0
-          
-          UI::status("transferred #{total_bytes.to_human} in #{elapsed}" +
-                     "second#{elapsed == 1.0 ? '' : 's' } (#{total_bytes.to_f / elapsed}/sec)")
-          
-          invalidate!
-          heads.size - 1
-        end
-      end
-      
-      ##
-      # Invalidate the repository: delete things and reset others.
-      def invalidate!
-        @changelog = nil
-        @manifest  = nil
-        
-        invalidate_tag_cache!
-        invalidate_branch_cache!
-      end
-      
-      ##
-      # Commits a changeset or set of files to the repository. You will quite often
-      # use this method since it's basically the basis of version control systems.
-      #
-      # @param [Hash] opts the options to this method are all optional, so it's a very
-      #   flexible method. Options listed below.
-      # @option [Array] opts :files ([]) the specific files to commit - if this is
-      #   not provided, the current status of the working directory is used.
-      # @option [Hash] opts :extra ({}) any extra data, such as "close" => true
-      #   will close the active branch.
-      # @option [String] opts :message ("") the message for the commit. An editor
-      #   will be opened if this is not provided.
-      # @option [Boolean] opts :force (false) Forces the commit, ignoring minor details
-      #   like when you try to commit when no files have been changed.
-      # @option [Match] opts :match (nil) A match object to specify how to pick files
-      #   to commit. These are useful so you don't accidentally commit ignored files,
-      #   for example.
-      # @option [Boolean] opts :empty_ok (false) Is an empty commit message a-ok?
-      # @option [Boolean] opts :force_editor (false) Do we force the editor to be
-      #   opened, even if :message is provided?
-      # @option [String] opts :user ($USER) the username to associate with the commit.
-      #   Defaults to AmpConfig#username.
-      # @option [DateTime, Time, Date] opts :date (Time.now) the date to mark with
-      #   the commit. Useful if you miss a deadline and want to pretend that you actually
-      #   made it!
-      # @return [String] the digest referring to this entry in the revlog
-      def commit(opts={:message => "", :extra => {}, :files => []})
-        opts[:extra] ||= {}
-        opts[:force] = true if opts[:extra]["close"]
-        opts[:files] ||= []
-        opts[:files].uniq!
-        
-        use_dirstate = opts[:p1] == nil
-        changes = {}
-        lock_working_and_store do
-          if use_dirstate
-            p1, p2 = dirstate.parents
-            update_dirstate = true
-            
-            tests = [opts[:force] ,
-                     p2 != NULL_ID,
-                     opts[:match] ]
-            
-            raise StandardError("cannot partially commit a merge") if tests.all?
-            
-            if opts[:files].any?
-              changes = {:modified => [], :removed => []}
-              
-              # split the files up so we can deal with them appropriately
-              opts[:files].each do |file|
-                state = dirstate[file]
-                if state.normal? || state.merged? || state.added?
-                  changes[:modified] << file
-                elsif state.removed?
-                  changes[:removed]  << file
-                elsif state.untracked?
-                  UI.warn "#{file} not tracked!"
-                else
-                  UI.err "#{file} has unknown state #{state[0]}"
-                end
-              end
-              
-            else
-              changes = status(:match => opts[:match])
-            end
-          else
-            p1, p2 = opts[:p1], (opts[:p2] || NULL_ID)
-            update_dirstate = dirstate.parents[0] == p1
-            changes = {:modified => files}
-          end
-          
-          
-          merge_state = Amp::Merges::MergeState.new self # merge state!
-          
-          changes[:modified].each do |file|
-            if merge_state[file] && merge_state[file] == "u"
-              raise StandardError.new("unresolved merge conflicts (see `amp resolve`)")
-            end
-          end
-          
-          changeset = WorkingDirectoryChangeset.new self, :parents => [p1, p2]      ,
-                                                          :text    => opts[:message],
-                                                          :user    => opts[:user]   ,
-                                                          :date    => opts[:date]   ,
-                                                          :extra   => opts[:extra]  ,
-                                                          :changes => changes
-            
-          revision = commit_changeset changeset, :force           => opts[:force]       ,
-                                                 :force_editor    => opts[:force_editor],
-                                                 :empty_ok        => opts[:empty_ok]    ,
-                                                 :use_dirstate    => use_dirstate       ,
-                                                 :update_dirstate => update_dirstate
-          
-          merge_state.reset
-          return revision
-        end
-      end
-      
-      ##
-      # Commits the given changeset to the repository.
-      #
-      # @param changeset the changeset to commit. Could be working dir, for
-      #   example.
-      # @param opts the options for committing the changeset.
-      # @option [Boolean] opts :force (false) force the commit, even though
-      #   nothing has changed.
-      # @option [Boolean] opts :force_editor (false) force the user to open
-      #   their editor, even though they provided a message already
-      # @option [Boolean] opts :empty_ok (false) is it ok if they have no
-      #   description of the commit?
-      # @option [Boolean] opts :use_dirstate (true) use the DirState for this
-      #   commit? Used if you're committing the working directory (typical)
-      # @option [Boolean] opts :update_dirstate (true) should we update the
-      #   DirState after the commit? Used if you're committing the working
-      #   directory.
-      # @return [String] the digest referring to this entry in the revlog
-      def commit_changeset(changeset, opts = {:use_dirstate => true,
-                                              :update_dirstate => true})
-        journal = nil
-        valid = false #don't update the DirState if this is set!
-        
-        commit = ((changeset.modified || []) + (changeset.added || [])).sort
-        remove = changeset.removed
-        extra = changeset.extra.dup
-        branchname = extra["branch"]
-        user = changeset.user
-        text = changeset.description
-        
-        p1, p2 = changeset.parents.map {|p| p.node}
-        c1 = changelog.read(p1) # 1 parent's changeset as an array
-        c2 = changelog.read(p2) # 2nd parent's changeset as an array
-        m1 = manifest.read(c1[0]).dup # 1st parent's manifest
-        m2 = manifest.read(c2[0])     # 2nd parent's manifest
-        
-        if opts[:use_dirstate]
-          oldname = c1[5]["branch"]
-          tests = [ commit.empty?, remove.empty?, ! opts[:force],
-                    p2 == NULL_ID, branchname = oldname ]
-          
-          if tests.all?
-            UI::status "nothing changed"
-            return nil
-          end
-        end
-        
-        xp1 = p1.hexlify
-        xp2 = (p2 == NULL_ID) ? "" : p2.hexlify
-        
-        run_hook :pre_commit
-        journal = Journal.new
-
-        fresh    = {} # new = reserved haha
-        changed  = []
-        link_rev = self.size
-        
-        (commit + (remove || [])).each {|file| UI::status file }
-        
-        #Amp::Logger.info("<changeset commit>").indent
-        
-        commit.each do |file|
-          # begin
-          
-          versioned_file = changeset.get_file(file)
-          newflags = versioned_file.flags
-          
-          fresh[file] = commit_file(versioned_file, m1, m2, link_rev,
-                                    journal, changed)
-          if [ changed.empty? || changed.last != file, 
-               m2[file] != fresh[file] ].all?
-            changed << file if m1.flags[file] != newflags
-          end
-          m1.flags[file] = newflags
-          
-          dirstate.normal file if opts[:use_dirstate]
-          #Amp::Logger.section("committing: #{file}") do
-            #Amp::Logger.info("flags: #{newflags.inspect}")
-            #Amp::Logger.info("total changes: #{changed.inspect}")
-          #end
-          # rescue
-          #            if opts[:use_dirstate]
-          #              UI.warn("trouble committing #{file}")
-          #              raise
-          #            else
-          #              remove << file
-          #            end
-          # end
-        end
-        
-        updated, added = [], []
-        changed.sort.each do |file|
-          if m1[file] || m2[file]
-            updated << file
-          else
-            added << file
-          end
-        end
-        
-        m1.merge!(fresh)
-        
-        removed = remove.sort.select {|f| m1[f] || m2[f]}
-        removed_1 = []
-        removed.select {|f| m1[f]}.each do |f|
-          m1.delete f
-          removed_1 << f
-          #Amp::Logger.info("Removed: #{f}")
-        end
-        
-        fresh = fresh.map {|k, v| (v) ? k : nil}.reject {|k| k.nil? }
-        man_entry = manifest.add(m1, journal, link_rev, c1[0], c2[0],
-                                [fresh, removed_1])
-        #Amp::Logger.info("Adding/modifying: #{fresh.inspect}")
-        #Amp::Logger.info("Removing: #{removed_1.inspect}")
-        #Amp::Logger.section("New Manifest") do
-          #manifest.read(:tip).each do |file, _|
-            #Amp::Logger.info(file)
-          #end
-        #end
-        if !opts[:empty_ok] && !text
-          template_opts = {:added => added, :updated => updated,
-                           :removed => removed, :template_type => :commit }
-          edit_text = changeset.to_templated_s(template_opts)
-          text = UI.edit(edit_text, user)
-        end
-        
-        lines = text.rstrip.split("\n").map {|r| r.rstrip}.reject {|l| l.empty?}
-        if lines.empty? && opts[:use_dirstate]
-          raise abort("empty commit message")
-        end
-        text = lines.join("\n")
-        
-        changelog.delay_update
-        n = changelog.add(man_entry, changed + removed_1, text, journal, p1, p2, user,
-                          changeset.date, extra)
-        #Amp::Logger.section("changelog") do
-          #Amp::Logger.info("manifest entry: #{man_entry.inspect}")
-          #Amp::Logger.info("files: #{(changed + removed_1).inspect}")
-          #Amp::Logger.info("text: #{text.inspect}")
-          #Amp::Logger.info("p1: #{p1.inspect}")
-          #Amp::Logger.info("p2: #{p2.inspect}")
-          #Amp::Logger.info("user: #{user.inspect}")
-          #Amp::Logger.info("date: #{changeset.date.inspect}")
-          #Amp::Logger.info("extra: #{extra.inspect}")
-        #end
-        self.changelog.write_pending()
-        changelog.finalize(journal)
-        #Amp::Logger.outdent.info("</changeset commit>")
-        # branchtags
-        
-        if opts[:use_dirstate] || opts[:update_dirstate]
-          dirstate.parents = n
-          removed.each {|f| dirstate.forget(f) } if opts[:use_dirstate]
-          dirstate.write
-        end
-        
-        valid = true
-        journal.close
-        run_hook :post_commit, :added => added, :modified => updated,        :removed => removed, 
-                               :user  => user,  :date     => changeset.date, :text    => text,
-                               :revision => changelog.index_size
-        return n
-      rescue StandardError => e
-        if !valid
-          dirstate.invalidate!
-        end
-        if e.kind_of?(AbortError)
-          UI::warn "Abort: #{e}"
-        else
-          UI::warn "Got exception while committing. #{e}"
-          UI::warn e.backtrace.join("\n")
-        end
-        journal.delete if journal
-      end
-      
-      
-      ##
-      # Commits a file as part of a larger transaction.
-      #
-      # @param file the versioned-file to commit
-      # @param manifest1 the manifest of the first parent
-      # @param manifest2 the manifest of the second parent
-      # @param link_revision the revision index we'll be adding this under
-      # @param journal the journal for aborting failed commits
-      # @param change_list the list of all the files changed during the commit
-      #
-      def commit_file(file, manifest1, manifest2, link_revision, journal, change_list)
-        filename = file.path
-        text = file.data
-        curfile = self.file filename
-        
-        fp1 = manifest1[filename] || NULL_ID
-        fp2 = manifest2[filename] || NULL_ID
-
-        metadata = {}
-        copied = file.renamed
-        if copied && copied[0] != filename
-          # Mark the new revision of this file as a copy of another
-          # file.  This copy data will effectively act as a parent
-          # of this new revision.  If this is a merge, the first
-          # parent will be the nullid (meaning "look up the copy data")
-          # and the second one will be the other parent.  For example:
-          #
-          # 0 --- 1 --- 3   rev1 changes file foo
-          #   \       /     rev2 renames foo to bar and changes it
-          #    \- 2 -/      rev3 should have bar with all changes and
-          #                      should record that bar descends from
-          #                      bar in rev2 and foo in rev1
-          #
-          # this allows this merge to succeed:
-          #
-          # 0 --- 1 --- 3   rev4 reverts the content change from rev2
-          #   \       /     merging rev3 and rev4 should use bar@rev2
-          #    \- 2 --- 4        as the merge base
-          
-          copied_file = copied[0]
-          copied_revision = manifest1[copied_file]
-          new_fp = fp2
-          
-          if manifest2 # branch merge
-            if fp2 == NULL_ID || copied_revision == nil # copied on remote side
-              if manifest2[copied_file]
-                copied_revision = manifest2[copied_file]
-                new_fp = fp1
-              end
-            end
-          end
-
-          if copied_revision.nil? || copied_revision.empty?
-            self["."].ancestors.each do |a|
-              if a[copied_file]
-                copied_revision = a[copied_file].file_node
-                break
-              end
-            end
-          end
-          
-          UI::say "#{filename}: copy #{copied_file}:#{copied_revision.hexlify}"
-          metadata["copy"] = copied_file
-          metadata["copyrev"] = copied_revision.hexlify
-          fp1, fp2 = NULL_ID, new_fp
-        elsif fp2 != NULL_ID
-          fpa = curfile.ancestor(fp1, fp2)
-          
-          fp1, fp2 = fp2, NULL_ID if fpa == fp1
-          fp2 = NULL_ID if fpa != fp2 && fpa == fp2
-        end
-        
-        if fp2 == NULL_ID && !(curfile.cmp(fp1, text)) && metadata.empty?
-          return fp1
-        end
-        
-        change_list << filename
-        return curfile.add(text, metadata, journal, link_revision, fp1, fp2)
-      end
-      
-      private
-      
-      ##
-      # Make the dummy changelog at .hg/00changelog.i
-      def make_changelog
-        @hg_opener.open "00changelog.i", "w" do |file|
-          file.write "\0\0\0\2" # represents revlogv2
-          file.write " dummy changelog to avoid using the old repo type"
-        end
-      end
-      
-      ##
-      # Write the requirements file. This returns the requirements passed
-      # so that it can be the final method call in #init
-      def write_requires(requirements)
-        @hg_opener.open "requires", "w" do |require_file|
-          requirements.each {|r| require_file.puts r }
-        end
-        requirements
-      end
-      
-      ##
-      # Look up the files in +lookup+ to make sure
-      # they're either the same or not. Normally, we can
-      # just tell if two files are the same by looking at their sizes. But
-      # sometimes, we can't! That's where this method comes into play; it
-      # hashes the files to verify integrity.
-      # 
-      # @param [String] lookup files to look up
-      # @param node1
-      # @param node2
-      # @return [[String], [String], Boolean] clean files, modified files, and
-      #   whether or not to write the dirstate
-      def fix_files(lookup, node1, node2)
-        write_dirstate = false # this gets returned
-        modified = [] # and this
-        fixup    = [] # fixup are files that haven't changed so they're being
-                      # marked wrong in the dirstate. this gets returned
-        
-        lookup.each do |file|
-          # this checks to see if the file has been modified after doing
-          # hashes/flag checks
-          tests = [ node1.include?(file)                   ,
-                    node2.flags(file) == node1.flags(file) ,
-                    node1[file]      === node2[file]       ]
-          
-          unless tests.all?
-            modified << file
-          else
-            fixup << file # mark the file as clean
-          end
-        end
-        
-
-        # mark every fixup'd file as clean in the dirstate
-        begin
-          lock_working do        
-            fixup.each do |file|
-              write_dirstate = true
-              dirstate.normal file
-              modified.delete file
-            end
-          end
-        rescue LockError
-        end
-        dirstate.write if write_dirstate
-        
-        # the fixups are actually clean
-        [fixup, modified, write_dirstate]
-      end
-      
-      ##
-      # do a binary search
-      # used by common_nodes
-      # 
-      # Hash info!
-      # :find => the stuff we're searching through
-      # :on_find => what to do when we've got something new
-      # :repo => usually the remote repo where we get new info from
-      # :node_map => the nodes in the current changelog
-      def binary_search(opts={})
-        # I have a lot of stuff to do for scouts
-        # but instead i'm doing this
-        # hizzah!
-        count = 0
-        
-        until opts[:find].empty?
-          new_search = []
-          count += 1
-          
-          #puts opts[:find].inspect #killme
-          #puts opts[:find].inspect #killme
-          
-          zipped = opts[:find].zip opts[:repo].between(opts[:find])
-          zipped.each do |(n, list)|
-            list << n[1]
-            p = n[0]
-            f = 1 # ??? why are these vars so NAMELESS
-
-            list.each do |item|
-              UI::debug "narrowing #{f}:#{list.size} #{short item}"
-
-              if opts[:node_map].include? item
-                if f <= 2
-                  opts[:on_find].call(p, item)
-                else
-                  UI::debug "narrowed branch search to #{short p}:#{short item}"
-                  new_search << [p, item]
-                end
-                break
-              end
-
-              p, f = item, f*2
-            end
-          end
-
-          opts[:find] = new_search
-        end
-
-        [opts[:find], count]
-      end
-      
-      ##
-      # this is called before every push
-      # @todo -- add default values for +opts+
-      def pre_push(remote, opts={})
-        common = {}
-        remote_heads = remote.heads
-        inc = common_nodes remote, :base => common, :heads => remote_heads, :force => true
-        inc = inc[1]
-        update, updated_heads = find_outgoing_roots remote, :base => common, :heads => remote_heads
-        
-        if opts[:revs]
-          btw = changelog.nodes_between(update, opts[:revs])
-          missing_cl, bases, heads = btw[:between], btw[:roots], btw[:heads]
-        else
-          bases, heads = update, changelog.heads
-        end
-        if bases.empty?
-          UI::status 'no changes found'
-          return nil, 1
-        elsif !opts[:force]
-          # check if we're creating new remote heads
-          # to be a remote head after push, node must be either
-          # - unknown locally
-          # - a local outgoing head descended from update
-          # - a remote head that's known locally and not
-          #   ancestral to an outgoing head
-          
-          warn = false
-          if remote_heads == [NULL_ID]
-            warn = false
-          elsif (opts[:revs].nil? || opts[:revs].empty?) and heads.size > remote_heads.size
-            warn  = true
-          else
-            new_heads = heads
-            remote_heads.each do |r|
-              if changelog.node_map.include? r
-                desc = changelog.heads r, heads
-                l = heads.select {|h| desc.include? h }
-                
-                new_heads << r if l.empty?
-              else  
-                new_heads << r
-              end
-            end
-            
-            warn = true if new_heads.size > remote_heads.size
-          end
-          
-          if warn
-            UI::status 'abort: push creates new remote heads!'
-            UI::status '(did you forget to merge? use push -f to forge)'
-            return nil, 0
-          elsif inc.any?
-            UI::note 'unsynced remote changes!'
-          end
-        end
-        
-        if opts[:revs].nil?
-          # use the fast path, no race possible on push
-          cg = get_changegroup common.keys, :push
-        else
-          cg = changegroup_subset update, revs, :push
-        end
-        
-        [cg, remote_heads]
-      end
-      
-    end # localrepo
-  end # repo
-end