amp-pure 0.5.0

data/lib/amp/revlogs/changelog.rb

@@ -0,0 +1,338 @@
+module Amp
+  
+  ##
+  # This is used for faking data writing, until we're totally done
+  # accumulating data.
+  class FakeFileAppender
+    
+    ##
+    # Initializes the fake file with the pointer to the real deal,
+    # and also the current data
+    def initialize(fp, buffer, size)
+      @data = buffer
+      @fp = fp
+      @offset = fp.tell
+      @size = size
+    end
+    
+    ##
+    # Returns the endpoint of the data in the (fake) file
+    def endpt
+      @size + @data.join.size
+    end
+    
+    ##
+    # Returns the current offset of the (fake) file
+    def tell
+      @offset
+    end
+    
+    ##
+    # Nothing, since we don't flush, we just sit here
+    def flush; end
+    
+    ##
+    # Closes the real file pointer for this fake file
+    def close
+      @fp.close
+    end
+    
+    ##
+    # Seeks to the position requested. We're faking this, but it's a little
+    # tougher, because if we break the fake file down like this:
+    #
+    # [   actual file  size = 10  |  pending data size = 10 ]
+    #
+    # If the user seeks to 15, we need to make sure we don't try to seek to
+    # 15 in the file, as that would cause errors.
+    def seek(offset, whence)
+      if whence == IO::SEEK_SET
+        @offset = offset
+      elsif whence == IO::SEEK_CUR
+        @offset += offset
+      elsif whence == IO::SEEK_END
+        @offset = self.endpt + offset
+      end
+      if @offset < @size
+        @fp.seek @offset
+      end
+    end
+    
+    ##
+    # Reads from the fake file, for _count_ bytes. This is a little sketchy
+    # because we might be reading some real data and some fake data, or all
+    # real, or all fake.
+    # 
+    # @param  [Integer] count how much to read. -1 will read it all.
+    # @return [String]  the contents
+    def read(count=-1)
+      ret = ""
+      
+      if @offset < @size
+        s = @fp.read(count)
+        ret = s
+        @offset += s.size
+        if count > 0
+          count -= s.size
+        end
+      end
+      
+      unless count.zero?
+        doff = @offset - @size
+        @data.unshift @data.join
+        @data.delete_range(1..-1)
+        s = @data[0][doff..(doff+count-1)]
+        @offset += s.size
+        ret += s
+      end
+      
+      ret
+    end
+    
+    ##
+    # Writes to the fake file. Notice - this will only work because we only
+    # append to the file - we don't write in the middle anywhere, or this
+    # scheme would fail.
+    # 
+    # @param [#to_s] s data to write
+    def write(s)
+      @data << s.to_s
+      @offset += s.size
+    end
+  end
+  
+  class DelayedOpener
+    attr_accessor :default
+    
+    ##
+    # Initializes the delayed opener, needing the real deal, and the owner
+    # of the delayed opener.
+    # 
+    # @param [Opener] realopener the actual opener. Since the DelayedOpener
+    #   doesn't know how to open files, we'll need this!
+    # @param [ChangeLog] owner the owner of the delayed opener. This reference
+    #   is needed because we need to check on the state of the delayed_buffer
+    #   and what not.
+    def initialize(realopener, owner)
+      @real_opener, @owner = realopener, owner
+    end
+    
+    ##
+    # Specialized opener that will fake writing when asked to. We need to
+    # know who our owner is and we need a real opener so we can actually
+    # open files. The DelayedOpener doesn't know how to do real IO.
+    def open(name, mode="r")
+      fp = @real_opener.open(name, mode)
+      return fp if name != @owner.index_file
+      
+      # Are we holding off on writing? if so, set up the file where we
+      # writing pending data.
+      
+      if @owner.delay_count == 0
+        @owner.delay_name = File.amp_name(fp)
+        mode.gsub!(/a/, 'w') if @owner.empty?
+        return @real_opener.open(name+".a", mode) # See what I did there?
+      end
+      
+      # FakeFileAppender = fake file so we don't do any real writing yet
+      size = File.stat(@real_opener.join(name)).size
+      ffa = FakeFileAppender.new(fp, @owner.delay_buffer, size)
+      
+      return ffa
+    end
+  end
+  
+  ##
+  # A ChangeLog is a special revision log that stores the actual commit data,
+  # including usernames, dates, messages, all kinds of stuff.
+  #
+  # This version of the revision log is special though, because sometimes
+  # we have to hold off on writing until all other updates are done, for
+  # example during merges that might fail. So we have to actually have
+  # a real Opener and a fake one, which will save the data in memory.
+  # When you call #finalize, the fake file will replace the real deal.
+  class ChangeLog < Amp::Revlog
+    attr_accessor :delay_count, :delay_name, :index_file, :delay_buffer, :node_map
+    
+    ##
+    # Initializes the revision log. Just pass in an Opener. Amp::Opener.new(path)
+    # will do just fine.
+    # 
+    # @param [Amp::Opener] opener an object that knows how to open
+    #   and return files based on a root directory.
+    def initialize(opener)
+      super(opener, "00changelog.i")
+      @node_map = @index.node_map
+    end
+    alias_method :changelog_initialize, :initialize
+    
+    ##
+    # Tells the changelog to stop writing updates directly to the file,
+    # and start saving any new info to memory/other files. Used when the
+    # changelog has to be the last file saved.
+    def delay_update
+      @_real_opener = @opener
+      @opener = DelayedOpener.new(@_real_opener, self) # Our fake Opener
+      @delay_count = self.size
+      @delay_buffer = []
+      @delay_name = nil
+    end
+    
+    ##
+    # Finalizes the changelog by swapping out the fake file if it has to.
+    # If there's any other data left in the buffer, it will be written
+    # as well.
+    def finalize(journal)
+      if @delay_name
+        src = @_real_opener.join(@index_file+".a")
+        dest = @_real_opener.join(@index_file)
+        @opener = @_real_opener # switch back to normal mode....
+        return File.amp_force_rename(src, dest)
+      end
+      
+      if @delay_buffer && @delay_buffer.any?
+        @fp = open(@index_file, "a")
+        @fp.write @delay_buffer.join
+        @fp.close
+        @delay_buffer = []
+      end
+      # check_inline_size journal
+    end
+    
+    ##
+    # Reads while we're blocking this changelog's output.
+    # @param file the file to read in as a revision log
+    def read_pending(file)
+      r = Revlog.new(@opener, file)
+      @index = r.index
+      @node_map = r.index.node_map
+      @chunk_cache = r.chunk_cache
+    end
+    
+    ##
+    # Writes our data, while being aware of the delay buffer when we're holding
+    # off on finalizing the changelog.
+    def write_pending
+      if @delay_buffer && @delay_buffer.size > 0
+        fp1 = @_real_opener.open(@index_file)
+        fp2 = @_real_opener.open(@index_file + ".a", "w+")
+        UI.debug "trying to open #{@index_file + ".a"}..."
+        fp2.write fp1.read
+        fp2.write @delay_buffer.join
+        fp2.close
+        fp1.close
+        @delay_buffer = []
+        @delay_name = @index_file
+      end
+      return true if @delay_name && @delay_name.any?
+      false
+    end
+    
+    ##
+    # Does a check on our size, but knows enough to quit if we're still in
+    # delayed-writing mode.
+    # @param [Amp::Journal] journal the journal to use to keep track of our transaction
+    # @param [File] fp the file pointer to use to check our size
+    def check_inline_size(journal, fp=nil)
+      return if @opener.is_a? DelayedOpener
+      super(journal, fp)
+    end
+    
+    ##
+    # Decodes the extra data stored with the commit, such as requirements
+    # or just about anything else we need to save
+    # @param [String] text the data in the revision, decompressed
+    # @return [Hash] key-value pairs, joining each file with its extra data
+    def decode_extra(text)
+      extra = {}
+      text.split("\0").select {|l| l.any? }.
+                       map {|l| l.remove_slashes.split(":",2) }.
+                       each {|k,v| extra[k]=v }
+      extra
+    end
+    
+    ##
+    # Encodes the extra data in a format we can use for writing.
+    # @param [Hash] data the extra data to format
+    # @return [String] the encoded data
+    def encode_extra(data)
+      " " + data.sort.map {|k| "#{k}:#{data[k]}".add_slashes }.join("\0")
+    end
+    
+    ##
+    # Reads the revision at the given node_id. It returns it in a format
+    # that tells us everything about the revision - the manifest, the user
+    # who committed it, timestamps, the relevant filenames, the description
+    # message, and any extra data.
+    # 
+    # @todo Text encodings, I hate you. but i must do them
+    # @param [Fixnum] node the node ID to lookup into the revision log
+    # @return [[String, String, [Float, Integer], [String], String, Hash]]
+    #   The format is [Manifest, Username, [Time, Timezone], [Filenames],
+    #   Message, ExtraData].
+    def read(node)
+      text = decompress_revision node
+      if text.nil? || text.empty?
+        return [NULL_ID, "", [0,0], [], "", {"branch" => "default"}]
+      end
+      #p text
+      last = text.index("\n\n")
+      desc = text[last+2..-1] #TODO: encoding
+      l = text[0..last].split("\n")
+      manifest = l[0].unhexlify
+      user = l[1] #TODO: encoding
+      extra_data = l[2].split(' ', 3)
+      if extra_data.size != 3
+        time = extra_data.shift.to_f
+        timezone = extra_data.shift.to_i
+        extra = {}
+      else
+        time, timezone, extra = extra_data
+        time, timezone = time.to_f, timezone.to_i
+        extra = decode_extra text
+      end
+      extra["branch"] = "default" unless extra["branch"]
+      
+      files = l[3..-1]
+      
+      #puts(">> Ari's tipmost changeset: "+[manifest, user, [time, timezone], files, desc, extra].inspect) #killme
+      
+      [manifest, user, [time, timezone], files, desc, extra]
+    end
+    
+    ##
+    # Adds the given commit to the changelog.
+    # 
+    # @todo Handle text encodings
+    # @param [Amp::Manifest] Manifest a hex-version of a node_id or something?
+    # @param [String] files the files relevant to the commit, to be included
+    # @param [String] desc the commit message from the user
+    # @param [Amp::Journal] journal the transaction journal to write to for rollbacks if
+    #   something goes horribly wrong
+    # @param [String] p1 the first parent of this node
+    # @param [String] p2 the second parent of this node
+    # @param [Strng] user the username of the committer
+    # @param [Time] date the date of the commit
+    # @param [Hash] extra any extra data
+    def add(manifest, files, desc, journal, p1=nil, p2=nil, user=nil, date=nil, extra={})
+      user = user.strip
+      raise RevlogSupport::RevlogError.new("no \\n in username") if user=~ /\n/
+      user, desc = user, desc #TODO: encoding!
+      
+      date = Time.now unless date
+      parsed_date = "#{date.to_i} #{-1 * date.utc_offset}"
+      
+      if extra && ["default", "", nil].include?(extra["branch"])
+        extra.delete "branch"
+      end
+      if extra
+        extra = (extra.any?) ? encode_extra(extra) : ""
+        parsed_date = "#{parsed_date}#{extra}"
+      end
+      
+      l = [manifest.hexlify, user, parsed_date] + files.sort + ["", desc]
+      text = l.join "\n"
+      add_revision text, journal, self.size, p1, p2
+    end
+  end
+end

data/lib/amp/revlogs/changeset.rb

@@ -0,0 +1,521 @@
+module Amp
+  
+  ##
+  # A Changeset is a simple way of accessing the repository within a certain
+  # revision. For example, if the user specifies revision # 36, or revision
+  # 3adf21, then we can look those up, and work within the repository at the
+  # moment of that revision.
+  class Changeset
+    include RevlogSupport::Node
+    include Comparable
+    include Enumerable
+    
+    attr_reader :repo
+    alias_method :repository, :repo
+    
+    ##
+    # Initializes a new changeset. We need a repository to work with, and also
+    # a change_id. this change_id could be a revision index or a node_id for
+    # the revision.
+    #
+    # @param [Repository] repo a repository to work with.
+    # @param [Integer, String] change_id an ID or index to lookup to find this
+    #   changeset.
+    #
+    def initialize(repo, change_id='')
+      change_id = '.' if change_id == ''
+      @repo = repo
+      if change_id.kind_of? Integer
+        @revision = change_id
+        @node_id  = @repo.changelog.node_id_for_index change_id
+      else
+        @node_id = @repo.lookup change_id
+        @revision = @repo.changelog.rev @node_id
+      end
+    end
+    
+    ##
+    # Converts the revision to a number
+    def to_i; @revision; end
+    
+    ##
+    # Converts the revision to an easy-to-digest string
+    def to_s(opts = {})
+      if opts[:template]
+        to_templated_s(opts)
+      else
+        @node_id[0..5].hexlify
+      end
+    end
+    
+    ##
+    #
+    def to_templated_s(opts={})
+      
+      change_node = node
+      revision    = self.revision
+      log         = @repo.changelog
+      changes     = log.read change_node
+      username    = changes[1]
+      date        = Time.at changes[2].first
+      files       = changes[3]
+      description = changes[4]
+      extra       = changes[5]
+      branch      = extra["branch"]
+      cs_tags     = tags
+      type        = opts[:template_type].to_s || 'log'
+      
+      added   = opts[:added]
+      removed = opts[:removed]
+      updated = opts[:updated]
+      config  = opts
+      
+      parents = useful_parents log, revision
+      parents.map! {|p| [p, log.node(p)[0..5].hexlify] }
+      
+      p1 = useful_parents(log, revision)[0]
+      p2 = useful_parents(log, revision)[1]
+      
+      return "" if opts[:no_output]
+      
+      config = opts
+      
+      template = opts[:template]
+      template = "default-#{type}" if (template.nil? || template.to_s == "default")
+
+      template = Support::Template[template]
+      template.render({}, binding)
+    end
+    
+    def useful_parents(log, revision)
+      parents = log.parent_indices_for_index revision
+      if parents[1] == -1
+        if parents[0] >= revision - 1
+          parents = []
+        else
+          parents = [parents[0]]
+        end
+      end
+      parents
+    end
+    
+    ##
+    # Gives an easier way to digest this changeset while reminding us it's a
+    # changeset
+    def inspect
+      "#<Changeset #{to_s}>"
+    end
+    
+    ##
+    # Hash function for putting these bad boys in hashes
+    # 
+    # @return [Integer] a hash value.
+    def hash
+      return @revision.hash if @revision
+      return object_id
+    end
+    
+    ##
+    # Compares 2 changesets so we can sort them and whatnot
+    # 
+    # @param [Changeset] other a changeset we will compare against
+    # @return [Integer] -1, 0, or 1. Typical comparison.
+    def <=>(other)
+      return 0 if @revision.nil? || other.revision.nil?
+      @revision <=> other.revision
+    end
+    
+    ##
+    # Are we a null revision?
+    # @return [Boolean] null?
+    def nil?
+     @revision != NULL_REV
+    end
+    alias_method :null?, :nil?
+    
+    # Gets the raw changeset data for this revision. This includes
+    # the user who committed it, the description of the commit, and so on.
+    # Returns this: [manifest, user, [time, timezone], files, desc, extra]
+    def raw_changeset
+      @repo.changelog.read(@node_id)
+    end
+    
+    ##
+    # Returns the {ManifestEntry} for this revision. This will give
+    # us info on any file we want, including flags such as executable
+    # or if it's a link. Sizes and so on are also included.
+    #
+    # @return [ManifestEntry] the manifest at this point in time
+    def manifest
+      @manifest ||= @repo.manifest.read(raw_changeset[0])
+    end
+    
+    ##
+    # Returns the change in the manifest at this revision. I don't entirely
+    # know what this is yet.
+    def manifest_delta
+      @manifest_delta ||= @repo.manifest.read_delta(raw_changeset[0])
+    end
+    
+    ##
+    # Returns the parents of this changeset as {Changeset}s.
+    #
+    # @return [[Changeset]] the parents of this changeset.
+    def parents
+      return @parents if @parents
+      
+      p = @repo.changelog.parent_indices_for_index @revision
+      p = [p[0]] if p[1] == NULL_REV
+      
+      @parents = p.map {|x| Changeset.new(@repo, x) }
+    end
+    
+    ##
+    # Returns the children of this changeset as {Changeset}s.
+    #
+    # @return [Array<Changeset>] the children of this changeset.
+    def children
+      @repo.changelog.children(node_id).map do |node|
+        Changeset.new(@repo, node)
+      end
+    end
+    
+    ##
+    # Iterates over each entry in the manifest.
+    def each(&block)
+      manifest.sort.each(&block)
+    end
+    
+    ##
+    # Checks whether this changeset included a given file or not.
+    # 
+    # @param [String] file the file to lookup
+    # @return [Boolean] whether the file is in this changeset's manifest
+    def include?(file)
+      manifest[file] != nil
+    end 
+    
+    ##
+    # Gets the file with the given name, as a {VersionedFile}.
+    # @param file the path to the file to retrieve
+    # @return [VersionedFile] the file at this revision
+    #
+    def [](file)
+      get_file(file)
+    end
+    
+    ##
+    # Returns the file's info, namely it's node_id and flags it may
+    # have at this point in time, such as "x" for executable.
+    # 
+    # @param path the path to the file
+    # @return [[String, String]] the [node_id, flags] pair for this file
+    def file_info(path)
+      if manifest # have we loaded our manifest yet? if so, use that sucker
+        result = [manifest[path], manifest.flags[path]]
+        if result[0].nil?
+          return [NULL_ID, '']
+        else
+          return result
+        end
+      end
+      if manifest_delta || files[path] # check if it's in the delta... i dunno
+        if manifest_delta[path]
+          return [manifest_delta[path], manifest_delta.flags[path]]
+        end
+      end
+      # Give us, just look it up the long way in the manifest. not fun. slow.
+      node, flag = @repo.manifest.find(raw_changeset[0], path)
+      if node.nil?
+        return [NULL_ID, '']
+      end
+      return [node, flag]
+    end
+    
+    ##
+    # Gets the flags for the file at the given path at this revision.
+    # @param path the path to the file in question
+    # @return [String] the flags for the file, such as "x" or "l".
+    #
+    def flags(path)
+      info = file_info(path)[1]
+      return "" if info.nil?
+      info
+    end
+    
+    ##
+    # Gets the node_id in the manifest for the file at this path, for this
+    # specific revision.
+    # 
+    # @param path the path to the file
+    # @return [String] the node's ID in the manifest, which we'll use every
+    #   where we need a node_id.
+    def file_node(path)
+      file_info(path).first[0..19]
+    end
+    
+    ##
+    # Creates a versioned file for the file at the given path, for the frame
+    # of reference of this revision.
+    # @param path the path to the file
+    # @param [String] file_id the node_id, to save us some computation
+    # @param [FileLog] file_log the file_log to use, again to save us computation
+    # @return [VersionedFile] the file at this revision.
+    #
+    def get_file(path, file_id = nil, file_log = nil)
+      file_id = file_node(path) if file_id.nil?
+      VersionedFile.new(@repo, path, :file_id => file_id, :changeset => self,
+                                     :file_log => file_log)
+    end
+    #accessors
+    # revision index
+    def revision; @revision; end
+    alias_method :rev, :revision
+    # node_id
+    def node_id; @node_id; end
+    # @see node_id
+    alias_method :node, :node_id
+    # our node_id in sexy hexy
+    def hex; @node_id.hexlify; end
+    # the user who committed me!
+    def user; raw_changeset[1]; end
+    # the date i was committed!
+    def date; raw_changeset[2]; end
+    def easy_date; Time.at(raw_changeset[2].first); end
+    # the files affected in this commit!
+    def files; raw_changeset[3]; end
+    # the message with this commit
+    def description; raw_changeset[4]; end
+    # What branch i was committed onto
+    def branch 
+      raw_changeset[5]["branch"] 
+    end
+    # Any extra stuff I've got in me
+    def extra; raw_changeset[5]; end
+    # tags
+    def tags; @repo.tags_for_node node; end
+    
+    ##
+    # recursively walk
+    # 
+    # @param [Amp::Matcher] match this is a custom object that knows files
+    #   magically. Not your grampa's proc!
+    def walk(match) # calls DirState#walk
+      # just make it so the keys are there
+      results = []
+      
+      hash = Hash.with_keys match.files
+      hash.delete '.'
+      
+      each do |file|
+        hash.each {|f, val| (hash.delete file and break) if f == file }
+        
+        results << file if match.call file # yield file if match.call file
+      end
+      
+      hash.keys.sort.each do |file|
+        if match.bad file, "No such file in revision #{revision}" and match[file]
+          results << file # yield file
+        end
+      end
+      results
+    end
+    
+    def ancestor(other_changeset)
+      node = @repo.changelog.ancestor(self.node, other_changeset.node)
+      return Changeset.new(@repo, node)
+    end
+    
+    def ancestors
+      results = []
+      @repo.changelog.ancestors(revision)
+    end
+  end
+  
+  ##
+  # This is a special changeset that specifically works within the
+  # working directory. We sort of have to combine the old revision
+  # logs with the fact that files might be changed, and not in the
+  # revision logs! oh, mercy!
+  class WorkingDirectoryChangeset < Changeset
+    
+    def initialize(repo, opts={:text => ""})
+      @repo = repo
+      @revision = nil
+      @node_id  = nil
+      @text = opts[:text]
+      require 'time' if opts[:date].kind_of?(String)
+      @date = opts[:date].kind_of?(String) ? Time.parse(opts[:date]) : opts[:date]
+      @user = opts[:user] if opts[:user]
+      @parents = opts[:parents].map {|p| Changeset.new(@repo, p)} if opts[:parents]
+      @status = opts[:changes] if opts[:changes]
+      
+      @extra = {}
+      @extra = opts[:extra].dup if opts[:extra]
+      unless @extra["branch"]
+        branch = @repo.dirstate.branch
+        # encoding - to UTF-8
+        @extra["branch"] = branch
+      end
+      @extra["branch"] = "default" if @extra["branch"] && @extra["branch"].empty?
+      
+    end
+    
+    ##
+    # Converts to a string.
+    # I'm my first parent, plus a little extra.
+    def to_s
+      parents.first.to_s + "+"
+    end
+    
+    ##
+    # Am I nil? never!
+    def nil?; false; end
+    
+    ##
+    # Do I include a given file? (not sure this is ever used yet)
+    def include?(key); "?r".include?(@repo.dirstate[key].status.to_hg_letter); end
+    
+    ##
+    # What is the status of the working directory? This little
+    # method hides quite a bit of work!
+    def status
+      @status ||= @repo.status(:unknown => true)
+    end
+    
+    ##
+    # Who is the user working on me?
+    def user 
+      @user ||= @repo.config.username
+    end
+    
+    ##
+    # Well, I guess the working directory's date is... right now!
+    def date
+      @date ||= Time.new
+    end
+    
+    ##
+    # Who is the working directory's father? Is it Chef? Mr. Garrison?
+    # the 1989 denver broncos?
+    #
+    # hahaha mike that's hilarious
+    def parents
+      return @parents if @parents
+      p = @repo.dirstate.parents
+      p = [p[0]] if p[1] == NULL_ID
+      @parents = p.map {|x| Changeset.new(@repo, x) }
+      @parents
+    end
+    
+    ##
+    # OK, so we've got the last revision's manifest, that part's simple and makes sense.
+    # except now, we need to get the status of the working directory, and
+    # add in all the other files, because they're in the "manifest" by being
+    # in existence. Oh, and we need to remove any files from the parent's
+    # manifest that don't exist anymore. Make sense?
+    def manifest
+      return @manifest if @manifest
+      
+      # Start off with the last revision's manifest, that's safe.
+      man = parents()[0].manifest.dup
+      # Any copied files since the last revision?
+      copied = @repo.dirstate.copy_map
+      # Any modified, added, etc files since the last revision?
+      modified, added, removed  = status[:modified], status[:added], status[:removed]
+      deleted, unknown          = status[:deleted], status[:unknown]
+      # Merge these discoveries in!
+      {:a => added, :m => modified, :u => unknown}.each do |k, list|
+        list.each do |file|
+          copy_name = (copied[file] || file)
+          man[file] = (man.flags[copy_name] || NULL_ID) + k.to_s
+          man.flags[file] = @repo.dirstate.flags(file)
+        end
+      end
+      
+      # Delete files from the real manifest that don't exist.
+      (deleted + removed).each do |file|
+        man.delete file if man[file]
+      end
+      
+      man
+    end
+    
+    ##
+    # Returns a {VersionedWorkingFile} to represent the file at the given
+    # point in time. It represents a file in the working directory, which
+    # obvious don't read from the history, but from the actual file in
+    # question.
+    # 
+    # @param path the path to the file
+    # @param file_log the log for the file to save some computation
+    # @return [Amp::VersionedWorkingFile] the file object we can work with
+    def get_file(path, file_log=nil)
+      VersionedWorkingFile.new(@repo, path, :working_changeset => self, 
+                                            :file_log => file_log)
+    end
+    
+    ##
+    # Gets the flags for the file at current state in time
+    # 
+    # @param [String] path the path to the file
+    # @return [String] the flags, such as "x", "l", or ""
+    def flags(path)
+      if @manifest
+        return manifest.flags[path] || ""
+      end
+      pnode = parents[0].raw_changeset[0]
+
+      orig = @repo.dirstate.copy_map[path] || path
+      node, flag = @repo.manifest.find(pnode, orig)
+      return @repo.dirstate.flags(@repo.working_join(path))
+    end
+    
+    def useful_parents(log, revision)
+      parents = @parents.map {|p| p.revision}
+      if parents[1] == -1
+        if parents[0] >= @repo.size - 1
+          parents = []
+        else
+          parents = [parents[0]]
+        end
+      end
+      parents
+    end
+    
+    ##
+    # Recursively walk the directory tree, getting all files that +match+ says
+    # are good.
+    # 
+    # @param [Amp::Match] match how to select the files in the tree
+    # @param [Boolean] check_ignored (false) should we check for ignored files?
+    # @return [Array<String>] an array of filenames in the tree that match +match+
+    def walk(match, check_ignored = false)
+      tree = @repo.dirstate.walk true, check_ignored, match
+      tree.keys.sort
+    end
+    
+    # If there's a description, ok then
+    def description; @text; end
+    # Files affected in this transaction: modified, added, removed.
+    def files; (status[:modified] + status[:added] + status[:removed]).sort; end
+    # What files have changed?
+    def modified; status[:modified]; end
+    # What files have we added?
+    def added; status[:added]; end
+    # What files have been removed?
+    def removed; status[:removed]; end
+    # What files have been deleted (but not officially)?
+    def deleted; status[:deleted]; end
+    # What files are hanging out, but untracked?
+    def unknown; status[:unknown]; end
+    # What files are pristine since the last revision?
+    def clean; status[:normal]; end
+    # What branch are we in?
+    def branch; @extra["branch"]; end
+    # Any other extra data? i'd like to hear it
+    def extra; @extra; end
+    # No children. Returns the empty array.
+    def children; []; end
+  end
+end