amp 0.5.2 → 0.5.3

data/lib/amp/repository/mercurial/repo_format/changeset.rb

@@ -0,0 +1,768 @@
+module Amp
+  module Mercurial
+    
+    ##
+    # 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 < Amp::Repositories::AbstractChangeset
+      include Mercurial::RevlogSupport::Node
+      
+      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
+        @parents = nil
+      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] || '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['mercurial', 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
+      
+      ##
+      # Commits the given changeset to the repository.
+      # 
+      #  commit_changeset:
+      #    foreach file in commit:
+      #        commit_file file
+      #    end
+      #    add_manifest_entry
+      #    add_changelog_entry
+      # Is this changeset a working changeset?
+      #
+      # @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(opts = {:use_dirstate => true, :update_dirstate => true})
+        valid = false # don't update the DirState if this is set!
+        
+        commit = ((modified || []) + (added || [])).sort
+        remove = removed
+        xtra = extra.dup
+        branchname = xtra["branch"]
+        text = description
+        
+        p1, p2 = parents.map {|p| p.node }
+        c1 = repo.changelog.read(p1) # 1 parent's changeset as an array
+        c2 = repo.changelog.read(p2) # 2nd parent's changeset as an array
+        m1 = repo.manifest.read(c1[0]).dup # 1st parent's manifest
+        m2 = repo.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
+        
+        Hook.run_hook :pre_commit
+        journal = Amp::Mercurial::Journal.new(:opener => repo.store_opener)
+  
+        fresh    = {} # new = reserved haha i don't know why someone wrote "haha"
+        changed  = []
+        link_rev = repo.size
+        
+        (commit + (remove || [])).each {|file| UI::status file }
+        
+        # foreach file in commit:
+        #     commit_file file
+        # end
+        commit.each do |file|
+          versioned_file = self[file]
+          fresh[file]    = versioned_file.commit :manifests     => [m1, m2],
+                                                 :link_revision => link_rev,
+                                                 :journal       => journal ,
+                                                 :changed       => changed
+          
+          new_flags = versioned_file.flags
+          
+          # TODO
+          # Clean this shit up
+          if [ changed.empty? || changed.last != file, 
+               m2[file] != fresh[file]
+             ].all?
+            changed << file if m1.flags[file] != new_flags
+          end
+          m1.flags[file] = new_flags
+          
+          repo.staging_area.normal file if opts[:use_dirstate]
+        end
+        
+        #    add_manifest_entry
+        man_entry, updated, added = *add_manifest_entry(:manifests  => [m1, m2],
+                                                        :changesets => [c1, c2],
+                                                        :journal    => journal ,
+                                                        :link_rev   => link_rev,
+                                                        :fresh      => fresh   ,
+                                                        :remove     => remove  ,
+                                                        :changed    => changed )
+
+        #    get_commit_text
+        text = get_commit_text text, :added   => added,   :updated => updated,
+                                     :removed => removed, :user    => user   ,
+                                     :empty_ok     => opts[:empty_ok]        ,
+                                     :use_dirstate => opts[:use_dirstate]
+        
+        # atomically write to the changelog
+        #    add_changelog_entry
+        # for the unenlightened, rents = 'rents = parents
+        new_rents = add_changelog_entry :manifest_entry => man_entry,
+                                        :files   => (changed + removed),
+                                        :text    => text,
+                                        :journal => journal,
+                                        :parents => [p1, p2],
+                                        :user    => user,
+                                        :date    => date,
+                                        :extra   => xtra
+        
+        # Write the dirstate if it needs to be updated
+        # basically just bring it up to speed
+        if opts[:use_dirstate] || opts[:update_dirstate]
+          repo.dirstate.parents = new_rents
+          removed.each {|f| repo.dirstate.forget(f) } if opts[:use_dirstate]
+          repo.dirstate.write
+        end
+        
+        # The journal and dirstates are awesome. Leave them be.
+        valid = true
+        journal.close
+        
+        # if an error and we've gotten this far, then the journal is complete
+        # and it deserves to stay (if an error is thrown and journal isn't nil,
+        # the rescue will destroy it)
+        journal = nil
+        
+        # Run any hooks
+        Hook.run_hook :post_commit, :added => added, :modified => updated, :removed => removed, 
+                                    :user  => user,  :date     => date,    :text    => text,
+                                    :revision => repo.changelog.index_size
+        return new_rents
+      rescue StandardError => e
+        if !valid
+          repo.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
+        
+        # the journal is a vestigial and incomplete file.
+        # destroyzzzzzzzzzzz
+        journal.delete if journal
+      end
+      
+      ##
+      # Add an entry to the changelog (the final receipt of the commit).
+      # 
+      # @param [Hash] opts
+      # @return [String] the changelog id as to where the revision is in
+      #   the changelog
+      def add_changelog_entry(opts={})
+        repo.changelog.delay_update 
+        new_parents = repo.changelog.add opts[:manifest_entry],
+                                         opts[:files],
+                                         opts[:text],
+                                         opts[:journal],
+                                         opts[:parents][0],
+                                         opts[:parents][1],
+                                         opts[:user],
+                                         opts[:date],
+                                         opts[:extra]
+  
+        repo.changelog.write_pending
+        repo.changelog.finalize opts[:journal]
+        new_parents
+      end
+      
+      ##
+      # Get the commit text. Ask for it if none is given.
+      # 
+      # @param [String, NilClass] text (optional) the commit message
+      # @param [Hash] opts
+      def get_commit_text(text=nil, opts={})
+        user = opts.delete :user
+        
+        unless opts[:empty_ok] || (text && !text.empty?)
+          edit_text = to_templated_s :added   => added,   :updated       => modified,
+                                     :removed => removed, :template_type => :commit
+          text = UI::edit edit_text, user
+        end
+        
+        lines = text.rstrip.split("\n").map {|r| r.rstrip }.reject {|l| l.empty? }
+        raise abort("empty commit message") if lines.empty? && opts[:use_dirstate]
+        lines.join("\n")
+      end
+      
+      def add_manifest_entry(opts={})
+        # changed, m1, m2, c1, c2, fresh, remove, journal, link_rev
+        updated, added = [], []
+        
+        fresh   = opts[:fresh]
+        remove  = opts[:remove]
+        changed = opts[:changed]
+        
+        changesets = opts[:changesets]
+        manifests  = opts[:manifests]
+        
+        changed.sort.each do |file|
+          if manifests[0][file] || manifests[1][file]
+            updated << file
+          else
+            added << file
+          end
+        end
+        
+        manifests[0].merge! fresh
+        
+        remove.sort!
+        remove.reject! {|f| not manifests[0][f] }
+        remove.each {|f| manifests[0].delete f }
+        
+        UI::debug "before adding manifest entry"
+        
+        # sorry for making this destructive
+        # but it's clean and memory efficient
+        # GHC's GC goes like 3 times per second, so STFU
+        # I don't have that kind of luxury
+        fresh.replace fresh.inject([]) {|a, (k, v)| v ? a << k : a }
+        man_entry = repo.manifest.add manifests[0], opts[:journal],
+                                      opts[:link_rev], changesets[0][0], changesets[1][0], [fresh, remove]
+        [man_entry, updated, added]
+      end
+      
+      ##
+      # @return [Boolean] is the changeset representing the working directory?
+      def working?
+        false
+      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_entry
+        @manifest_entry ||= @repo.manifest.read(raw_changeset[0])
+      end
+      
+      ##
+      # Provides access to all the tracked files in the changeset. Needed
+      # for API compatibility.
+      #
+      # @return [Array<String>] all the files tracked in this changeset.
+      def all_files
+        return manifest_entry.files
+      end
+      
+      ##
+      # Returns the change in the manifest at this revision. I don't entirely
+      # know what this is yet.
+      def manifest_delta
+        @manifest_entry_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 entry.
+      # 
+      # @return [Changeset] self, because that's how #each works
+      def each(&block)
+        manifest_entry.sort.each(&block)
+        self
+      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_entry[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_entry # have we loaded our manifest yet? if so, use that sucker
+          result = [manifest_entry[path], manifest_entry.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", "l", or "".
+      #
+      def flags(path)
+        info = file_info(path)[1]
+        return "" if info.nil?
+        info
+      end
+      
+      ##
+      # Gets the node_id in the manifest_entry 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_entry, 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 altered_files; raw_changeset[3]; end
+      # pre-API compatibility
+      alias_method :files, :altered_files
+      
+      # the message with this commit
+      def description; raw_changeset[4]; end
+      # What branch i was committed onto
+      def branch 
+        extra["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
+      
+      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
+        @parents = 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]
+        @manifest = nil
+        @extra = opts[:extra] ? opts[:extra].dup : {}
+        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
+      
+      ##
+      # Is this changeset a working changeset?
+      #
+      # @return [Boolean] is the changeset representing the working directory?
+      def working?
+        true
+      end
+      
+      ##
+      # Converts to a string.
+      # I'm my first parent, plus a little extra.
+      # "I am my own grandpa"
+      # 
+      # @return [String]
+      def to_s
+        parents.first.to_s + "+"
+      end
+      
+      
+      ##
+      # Do I include a given file? (not sure this is ever used yet)
+      def include?(key)
+        status = @repo.staging_area.file_status(key)
+        ![:unknown, :removed].include?(status)
+      end
+      
+      def all_files
+        repo.staging_area.all_files
+      end
+      
+      ##
+      # Am I nil? never!
+      def nil?; false; 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
+        @parents ||= begin
+                       p = @repo.dirstate.parents
+                       p = [p[0]] if p[1] == NULL_ID
+                       p.map {|x| Changeset.new(@repo, x) }
+                     end
+      end
+      
+      ##
+      # OK, so we've got the last revision's manifest entry, 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 entry" by being
+      # in existence. Oh, and we need to remove any files from the parent's
+      # manifest entry that don't exist anymore. Make sense?
+      def manifest_entry
+        return @manifest_entry if @manifest_entry
+        
+        # Start off with the last revision's manifest_entry, that's safe.
+        man = parents()[0].manifest_entry.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 entry 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_entry ||= nil
+          return manifest_entry.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.staging_area.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
+end