amp 0.5.0

data/lib/amp/commands/commands/workflows/hg/branch.rb

@@ -0,0 +1,28 @@
+command :branch do |c|
+  c.workflow :hg
+  
+  c.desc "Set/Show the current branch name"
+  c.opt :force, "Forces the branch-name change", :short => "-f"
+  c.opt :clean, "Resets the branch setting for this repository", :short => "-c"
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    if opts[:clean]
+      _label = repo[nil].parents[0].branch
+      repo.dirstate.branch = _label
+      Amp::UI.status("Reset working directory to branch #{_label}")
+    elsif args.size > 0
+      _label = args.first
+      if !opts[:force] && repo.branch_tags.include?(_label)
+        if !repo.parents.map {|p| p.branch}.include?(_label)
+          raise abort("a branch of the same name already exists!"+
+                               " (use --force to override)")
+        end
+      end
+      repo.dirstate.branch = _label
+      Amp::UI.status("marked working directory as branch #{_label}")
+    else
+      Amp::UI.say("#{repo.dirstate.branch}")
+    end
+  end
+end

data/lib/amp/commands/commands/workflows/hg/branches.rb

@@ -0,0 +1,30 @@
+command :branches do |c|
+  c.workflow :hg
+  c.desc "Prints the current branches (active and closed)"
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+
+    active_branches = repo.heads(nil, :closed => false).map {|n| repo[n].branch}
+    branches = repo.branch_tags.map do |tag, node|
+      [ active_branches.include?(tag), repo.changelog.rev(node), tag ]
+    end
+    branches.reverse!
+    branches.each do |is_active, node, tag|
+      if !opts[:active] || is_active
+        hexable = repo.lookup(node)
+        if is_active
+          branch_status = ""
+        elsif !(repo.branch_heads(tag, :closed => false).include?(hexable))
+          notice = " (closed)"
+        else
+          notice = " (inactive)"
+        end
+        revision = node.to_s.rjust(31 - tag.size)
+        data = [tag, revision, hexable.short_hex, notice]
+        Amp::UI.say "#{tag} #{revision}:#{hexable.short_hex}#{notice}"
+      end
+    end  #end each
+
+  end  # end on_run
+end

data/lib/amp/commands/commands/workflows/hg/bundle.rb

@@ -0,0 +1,115 @@
+command :bundle do |c|
+  c.workflow :hg
+  
+  c.desc "Create a changegroup file"
+  c.help <<-EOS
+amp bundle [options]+ file dest
+
+  Generate a compressed changegroup file collecting changesets not
+  known to be in another repository.
+  
+  If no destination repository is specified the destination is
+  assumed to have all the nodes specified by one or more --base
+  parameters. To create a bundle containing all changesets, use
+  --all (or --base null). To change the compression method applied,
+  use the -t option (by default, bundles are compressed using bz2).
+  
+  The bundle file can then be transferred using conventional means and
+  applied to another repository with the unbundle or pull command.
+  This is useful when direct push and pull are not available or when
+  exporting an entire repository is undesirable.
+  
+  Applying bundles preserves all changeset contents including
+  permissions, copy/rename information, and revision history.
+  
+  Options are:
+EOS
+
+  c.opt :force, "Run even when remote repository is unrelated",     :short => '-f'
+  c.opt :rev,   "A changeset up to which you would like to bundle", :short => '-r', :type => :string
+  c.opt :base,  "A base changeset to specify instead of a destination",             :type => :string
+  c.opt :all,   "Bundle all changesets in the repository",          :short => '-a'
+  c.opt :type,  "Bundle compression type to use (default: bzip2)",  :short => '-t',                   :default => 'bzip2'
+  c.opt :ssh,   "Specify ssh command to use",                       :short => '-e', :type => :string
+  c.opt :"remote-cmd", "Specify hg command to run on the remote side",              :type => :string
+  
+  c.on_run do |opts, args|
+    repo  = opts[:repository]
+    rev   = opts[:rev]
+    fname = args.shift
+    dest  = args.shift
+    
+    # Type notation!
+    # rev :: Amp::Changeset
+    rev  = repo.lookup rev
+    base = repo.lookup(opts[:all] ? nil : opts[:base]) # --all overrides --base
+    
+    if base
+      if dest
+        raise abort("--base is incompatible with specifiying a destination")
+      end
+      
+      o   = []
+      has = {Amp::RevlogSupport::Node::NULL_ID => nil}
+      
+      # iterates over each file node id
+      base.each do |filename, node_id|
+        has.update repo.changelog.reachable_nodes_for_node(node_id)
+      end
+      
+      visit = [rev]
+      seen  = {} # {node => Boolean} where node is a string
+      add   = proc do |node|
+        seen[node] = true
+        visit << node
+      end
+      
+      until visit.empty?
+        n = visit.pop
+        
+        # for those who are lame:
+        # rents = 'rents = parents
+        rents = repo.changelog.parents(n).select do |parental_unit|
+          !has.include?(parental_unit)
+        end
+        
+        if rents.empty?
+          o.unshift n
+        else
+          rents.each {|rent| add[ rent ] unless seen.include? rent }
+        end # end if
+      end # end until
+    else
+      path = c.expand_path dest || 'default-push', dest || 'default', repo.config
+      dest, revs, checkout = *c.parse_url(path, [rev])
+      # alio is Esperanto for "other"; it's conveniently the same length as repo
+      alio = Amp::Repositories.pick nil, dest
+      o = repo.find_outgoing_roots alio, :force => opts[:force]
+    end # end if
+    
+    # Oh no, bitches! If you thought we were done, you'd be wrong.
+    # Nevermind, false alarm. Turns out there's not that much left to do.
+    
+    cg = if revs
+           p [o, rev]
+           repo.changegroup_subset o, [rev], 'bundle'
+         else
+           repo.changegroup o, 'bundle'
+         end
+    
+    # these few lines convert nice human speak to icky computer speak
+    bundle_type = opts[:type].downcase
+    btypes      = {'none' => 'HG10UN', 'bzip2' => 'HG10BZ', 'gzip' => 'HG10GZ'}
+    bundle_type = btypes[bundle_type]
+    
+    # some error checking
+    # yes, this calls Array#include, but the array is only 3 elements
+    unless Amp::RevlogSupport::ChangeGroup::BUNDLE_TYPES.include? bundle_type
+      raise abort('unknown bundle type specified with --type')
+    end
+    
+    File.open fname, 'w' do |file|
+      Amp::RevlogSupport::ChangeGroup.write_bundle cg, bundle_type, file
+    end
+  end  # end on_run
+end

data/lib/amp/commands/commands/workflows/hg/clone.rb

@@ -0,0 +1,95 @@
+command :clone do |c|
+  c.workflow :hg
+  c.desc "Clone a repository"
+  c.opt :pull, "Whether to do a pull from the destination (the alternative is to stream)", :short => '-p'
+  c.opt :stream, "stream raw data uncompressed from repository", :short => '-u'
+  c.opt :rev, "revision to clone up to (implies pull=True)", :short => '-r'
+  c.opt :"no-update", "Don't do an update after cloning, leaving the directory, if local, empty"
+  
+  c.help <<-HELP
+amp clone [options]+ src dest
+  
+  Make a copy of an existing repository.
+  
+  Create a copy of an existing repository in a new directory.  The
+  source and destination are URLs, as passed to the repository
+  function.  Returns a pair of repository objects, the source and
+  newly created destination.
+  
+  The location of the source is added to the new repository's
+  .hg/hgrc file, as the default to be used for future pulls and
+  pushes.
+  
+  If an exception is raised, the partly cloned/updated destination
+  repository will be deleted.
+  
+  Where options are:
+HELP
+  
+  c.on_run do |opts, args|
+    require 'uri'
+    
+    src, rev, checkout = *c.parse_url(args.shift)               # get the source url, revisions we want, and the checkout
+    # puts [src, rev, checkout].inspect
+    source = Amp::Repositories.pick opts[:global_config], src # make it an actual repository
+    dest   = (dest = args.shift) || File.basename(src)        # get the destination URL
+    
+    Amp::UI::status "destination directory: #{dest}"
+    
+    # at this point, source is an {Amp::Repository} and dest is a {String}
+    begin
+      src  = c.local_path src
+      dest = c.local_path dest
+      copy = false
+      
+      raise Amp::Repositories::RepoError.new("destination #{dest} already exists") if File.exist? dest
+      
+      if source.can_copy? and ['file', nil].include? URI.parse(dest).scheme
+        copy = !opts[:pull] && rev.empty?
+      end
+      
+      if ['file', nil].include? URI.parse(dest).scheme # then it's local
+        
+        if source.local? && copy # then we're copying
+          FileUtils.copy_entry src, dest # copy everything, pray it's pristine
+          dest_repo = Amp::Repositories::LocalRepository.new dest, false, opts[:global_config]
+        else # we have to pull
+          # make the directory, cd into it, pull, and maaaaaaybe update
+          dest_repo = Amp::Repositories::LocalRepository.new dest, true, opts[:global_config]
+          dest_repo.clone source, :revs   => (rev ? rev.map {|r| source.lookup r } : []),
+                                  :stream => opts[:stream] # the actual cloning which pulls
+        end
+        
+      else
+        
+        # we're cloning ourselves to a faraway land
+        # which DOESN'T HAPPEN unless source is local
+        # remote - remote cloning just isn't supported in mercurial
+        if source.local?
+          dest_repo = Amp::Repositories.pick opts[:global_config], dest
+          source.push dest_repo, :revs => rev.map {|r| source.lookup r }
+        else
+          raise Amp::RepoError.new("Remote -> Remote cloning is not yet supported")
+        end
+        
+      end
+      
+      # NOW we write the hgrc file if the dest is local
+      if dest_repo.local?
+        dest_repo.hg_opener.open('hgrc', 'w') do |f|
+          f.puts '[paths]'
+          f.puts "default = #{File.expand_path(src).gsub('%', '%%')}"
+        end
+        
+        if opts[:update]
+          Amp::UI::status "updating working directory"
+          dest_repo.update if opts[:update] # and here we add the files if we want to
+        end
+      end
+      
+      [source, dest_repo]
+    rescue
+      FileUtils.remove_entry dest # kill the dir if we've had any problems
+    end
+  end
+end

data/lib/amp/commands/commands/workflows/hg/commit.rb

@@ -0,0 +1,42 @@
+command :commit do |c|
+  c.workflow :hg
+  
+  c.desc "Commit yo shit"
+  c.opt :force, "Forces files to be committed", :short => "-f"
+  c.opt :include, "Includes the given patterns", :short => "-I", :type => :string
+  c.opt :exclude, "Ignores the given patterns", :short => "-E", :type => :string
+  c.opt :message, "The commit message", :short => "-m", :type => :string
+  c.opt :user,    "The user committing the revision", :short => "-u", :type => :string
+  c.opt :date,    "The date of the commit", :short => "-d", :type => :string
+  c.synonym :ci
+  c.help <<-EOS
+amp commit [options]+ [FILE]+
+
+  Commit changes to the given files into the repository.
+
+  If a list of files is omitted, all changes reported by "amp status"
+  will be committed.
+
+  If you are committing the result of a merge, do not provide any
+  file names or -I/-X filters.
+
+  If no commit message is specified, the configured editor is started to
+  prompt you for a message.
+  
+  amp commit [FILE]+ [options]
+  
+  Where options are:
+EOS
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    files    = args
+    included = opts[:include]
+    excluded = opts[:exclude]
+    extra    = {}
+    match    = Amp::Match.create(:files => files, :includer => included, :excluder => excluded) { !files.any? }
+    opts.merge! :match => match, :extra => extra
+    repo.commit opts
+  end
+end

data/lib/amp/commands/commands/workflows/hg/copy.rb

@@ -0,0 +1,31 @@
+command :copy do |c|
+  c.workflow :hg
+  c.desc "Copies a file from one location to another, while maintaining history"
+  c.opt :force, "Forces the copy, ignoring overwrites", :short => "-f"
+  c.opt :"dry-run", "Doesn't actually move files - only prints what would happen", :short => "-n"
+  c.opt :verbose, "Prints more output than normal", :short => "-v"
+  c.synonym :cp
+  c.before do |opts, args|
+    if args.size < 2
+      Amp::UI.say "Usage: amp copy source [other-sources...] destination"
+      c.break
+    elsif args.size > 2 && !File.directory?(args.last)
+      Amp::UI.say "If you want to copy more than 1 file, your destination must" +
+                  " be a directory."
+      c.break
+    end
+    true
+  end
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    sources = args[0..-2]
+    destination = args.last
+    sources.each do |source|
+      repo.copy source, destination, opts
+    end
+  end
+end
+
+

data/lib/amp/commands/commands/workflows/hg/debug/dirstate.rb

@@ -0,0 +1,32 @@
+namespace :debug do
+  command :dirstate do |c|
+    c.workflow :hg
+    
+    c.desc "Shows the current state of the working directory, as amp sees it."
+    c.opt :"no-dates", "Do not show modification dates", :short => "-D"
+    
+    c.on_run do |opts, args|
+      repo = opts[:repository]
+      showdates = !opts[:"no-dates"]
+      time = ""
+      
+      repo.dirstate.files.sort.each do |file, ent|
+        if showdates
+          # fuck locales for now....
+          timetouse = ent.mtime == -1 ? 0 : ent.mtime
+          time = Time.at(timetouse).strftime("%Y-%m-%d %H:%M:%S")
+        end
+        if ent.mode & 020000 != 0
+          mode = 'lnk'
+        else
+          mode = (ent.mode & 0777).to_s(8)
+        end
+        Amp::UI.say "#{ent.status}\t#{mode.to_s.rjust(3)} #{ent.size.to_s.rjust(10)} #{time} #{file}"
+      end
+      
+      repo.dirstate.copy_map.each do |key, value|
+        Amp::UI.say "copy: #{value} -> #{key}"
+      end
+    end
+  end
+end

data/lib/amp/commands/commands/workflows/hg/debug/index.rb

@@ -0,0 +1,36 @@
+namespace :debug do
+  
+  command :index do |c|
+    c.workflow :hg
+    
+    c.desc "Dumps the index of an index file"
+    
+    c.on_run do |opts, args|
+      opener = Amp::Opener.new(Dir.pwd)
+      opener.default = :open_file
+      args.each do |index_file|
+        Amp::UI.say "Index: #{index_file}"
+        Amp::UI.say "|---------|------------|------------|----------|-----------|--------------|--------------|--------------|"
+        Amp::UI.say "|   rev   |   offset   |   length   |   base   |  linkrev  |   nodeid     |    parent1   |    parent2   |"
+        Amp::UI.say "|---------|------------|------------|----------|-----------|--------------|--------------|--------------|"
+        revlog = Amp::Revlog.new(opener, index_file)
+        idx = 0
+        revlog.each do |entry|
+          node    = entry.node_id
+          parents = revlog.parents_for_node(node) || (["\0" * 20] * 2)
+          Amp::UI.say "|#{idx.to_s.ljust(9)}|"+
+                 "#{revlog.data_start_for_index(idx).to_s.ljust(12)}|"+
+                 "#{revlog[idx].compressed_len.to_s.ljust(12)}|"  +
+                 "#{revlog[idx].base_rev.to_s.ljust(10)}|"+
+                 "#{revlog[idx].link_rev.to_s.ljust(11)}|"+
+                 " #{node.hexlify[0..11]} |"+
+                 " #{parents[0].hexlify[0..11]} |"+
+                 " #{parents[1].hexlify[0..11]} |"
+          idx += 1
+        end
+        Amp::UI.say "|---------|------------|------------|----------|-----------|--------------|--------------|--------------|"                 
+      end
+      
+    end
+  end
+end

data/lib/amp/commands/commands/workflows/hg/default.rb

@@ -0,0 +1,9 @@
+command :default do |c|
+  c.workflow :hg
+  c.desc "run the `info` and `status` commands"
+  
+  c.on_run do |options, args|
+    Amp::Command['info'].run   options, args
+    Amp::Command['status'].run options, args
+  end
+end

data/lib/amp/commands/commands/workflows/hg/diff.rb

@@ -0,0 +1,30 @@
+command :diff do |c|
+  c.desc "Shows the differences between changesets"
+  c.opt :"no-color", "Turns off colored formatting", :short => "-c"
+  c.opt :rev, "Specifies a revision for diffing.", :short => "-r", :multi => true, :type => :integer
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    revs = opts[:rev] || []
+    
+    revs << "tip" if revs.size == 0
+    revs << nil   if revs.size == 1
+    
+    revs.map! {|key| repo[key]}
+    
+    differences = repo.status(:node_1 => revs[0], :node_2 => revs[1])
+    files = differences[:added] + differences[:removed] + differences[:deleted] + differences[:modified]
+    
+    files.each do |filename|
+      vf_old, vf_new     = revs.map {|rev| rev.get_file filename} 
+      date_old, date_new = revs.map {|rev| rev.easy_date }
+      path_old, path_new = vf_old.path, vf_new.path || "/dev/null"
+      rev_old, rev_new   = vf_old.file_rev, vf_new.file_rev
+      
+      diff = vf_new.file_log.unified_revision_diff rev_old, date_old, rev_new, 
+                                                   date_new, path_old, path_new, 
+                                                   :pretty => !opts[:"no-color"]
+      Amp::UI::say diff
+    end
+    
+  end
+end