amp-pure 0.5.0

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

@@ -0,0 +1,74 @@
+command :pull do |c|
+  c.workflow :hg
+  c.desc "Add a file to the repository (it will be tracked from here on)"
+  c.opt :update, "update to new tip if changesets were pulled",  :short => "-u"
+  c.opt :force,  "run even when remote repository is unrelated", :short => "-f"
+  c.opt :rev, "a specific revision up to which you would like to pull", :short => '-r',
+                                                                        :type => :string
+  c.opt :ssh, "specify ssh command to use", :short => '-e', :type => :string
+  c.opt :remotecmd, "specify amp command to run on the remote side", :type => :string
+  
+  c.desc "pull changes from the specified source"
+  c.help <<-HELP
+amp pull [options]+ src
+  
+  Pull changes from a remote repository to a local one.
+  
+  This finds all changes from the repository at the specified path
+  or URL and adds them to the local repository. By default, this
+  does not update the copy of the project in the working directory.
+  
+  Valid URLs are of the form:
+  
+    local/filesystem/path (or file://local/filesystem/path)
+    http://[user[:pass]@]host[:port]/[path]
+    https://[user[:pass]@]host[:port]/[path]
+    ssh://[user[:pass]@]host[:port]/[path]
+  
+  Paths in the local filesystem can either point to Mercurial
+  repositories or to bundle files (as created by 'amp bundle' or
+  'amp incoming --bundle').
+  
+  An optional identifier after # indicates a particular branch, tag,
+  or changeset to pull.
+HELP
+  
+  c.on_run do |opts, args|
+    repo   = opts[:repository]
+    dest   = args.shift || repo.config["paths", "default-push"] || repo.config["paths", "default"]
+    
+    if dest =~ /#/
+      dest, branch = dest.split('#')
+    else
+      branch = nil
+    end
+    
+    remote = Amp::Repositories::pick repo.config, dest
+    Amp::UI::status "pulling from #{dest.hide_password}"
+    
+    revs = opts[:rev] && [ remote.lookup(opts[:rev]) ]
+    
+    mod_heads = repo.pull remote, :heads => revs, :force => opts[:force]
+    
+    # 
+    # Everything here is "post-incoming"
+    ####################################
+    
+    unless mod_heads.zero?
+      if opts[:update]
+        if mod_heads <= 1 || repo.branch_heads.size == 1 || opts[:rev]
+          Amp::Command['update'].run( { :repository => repo } ,
+                                      { :rev => opts[:rev]  } )
+        else
+          Amp::UI::status "not updating, since new heads were added"
+        end
+      end
+    
+      if mod_heads > 1
+        Amp::UI::status "(run 'amp heads' to see heads, 'amp merge' to merge)"
+      else
+        Amp::UI::status "(run 'amp update' to get a working copy)"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+command :push do |c|
+  c.workflow :hg
+  c.desc "Pushes the latest revisions to the remote repository."
+  c.opt :remote, "The remote repository's URL", :short => "-R"
+  c.opt :revs, "The revisions to push", :short => "-r", :type => :string
+  c.opt :force, "Ignore remote heads", :short => "-f"
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    dest = opts[:remote] || repo.config["paths","default-push"] || repo.config["paths","default"]
+    opts[:revs] ||= nil
+    remote = Amp::Support.parse_hg_url(dest, opts[:revs])
+    dest, revs, checkout = remote[:url], remote[:revs], remote[:head]
+    remote_repo = Amp::Repositories.pick(repo.config, dest, false)
+    
+    revs = revs.map {|rev| repo.lookup rev } if revs
+    
+    result = repo.push remote_repo, :force => opts[:force], :revs => revs
+  end
+end

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

@@ -0,0 +1,45 @@
+command :remove do |c|
+  c.workflow :hg
+  c.desc "Removes files from the repository on next commit"
+  c.opt :after, "record as delete for missing files (whether or not to actually delete files)", :short => "-A", :default => false
+  c.opt :force, "Forces removal of files", :short => "-f", :default => false
+  c.opt :include, "include names matching the given patterns", :short => "-I", :type => :string
+  c.opt :exclude, "exclude names matching the given patterns", :short => "-X", :type => :string
+  
+  c.synonym :rm, :nuke
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    list = args
+    list = list.map {|p| repo.relative_join(p) }
+
+    match = Amp::Match.create :files => list, :includer => opts[:include], :excluder => opts[:exclude]
+    s = repo.status(:match => match, :clean => true)
+    modified, added, deleted, clean = s[:modified], s[:added], s[:deleted], s[:clean]
+    
+    if opts[:force]
+      remove, forget = modified + clean, added
+    elsif opts[:after]
+      remove, forget = deleted, []
+      (modified + added + clean).each {|p| Amp::UI.warn "#{p} still exists" }
+    else
+      remove, forget = deleted + clean, []
+      modified.each {|p| Amp::UI.warn "not removing #{p} - file is modified (use -f)"       }
+      added.each    {|p| Amp::UI.warn "not removing #{p} - file is marked for add (use -f)" }
+    end
+    
+    if opts[:verbose]
+      (remove + forget).sort.each {|f| Amp::UI.status "removing #{f}..." }
+    end
+    
+    repo.remove(remove, :unlink => ! opts[:after]) # forgetting occurs here
+    repo.forget(forget)
+    
+    remove += forget
+    
+    if remove.size == 1
+      Amp::UI.say "File #{remove.first.red} removed at #{Time.now}"
+    else
+      Amp::UI.say "#{remove.size.to_s.red} files removed at #{Time.now}"
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+command :resolve do |c|
+  c.workflow :hg
+  c.desc "Retry file merges, or mark files as successfully hand-merged"
+  c.opt :all, "Attempt to resolve (or mark) all unresolved files", :short => "-a"
+  c.opt :list, "List unresolved files", :short => "-l"
+  c.opt :mark, "Mark file(s) as resolved", :short => "-m"
+  c.opt :unmark, "Mark file(s) as unresolved", :short => "-u"
+  c.opt :include, "Specify patterns of files to include in the operation", :short => "-I", :type => :string
+  c.opt :exclude, "Specify patterns of files to exclude in the operation", :short => "-E", :type => :string
+  
+  c.before do |opts, args|
+    parse_args = lambda {|os| [:all, :mark, :unmark, :list].map {|i| os[i] } }
+    
+    # Checks to make sure user input is valid
+    all, mark, unmark, list = *parse_args[ opts ]
+    
+    if (list && (mark || unmark)) || (mark && unmark)
+      raise abort("too many options specified")
+    end
+    
+    if all && (opts[:include] || opts[:exclude] || args.any?)
+      raise abort("can't specify --all and patterns or files")
+    end
+    
+    if !(all || args.any? || opts[:include] || opts[:exclude] || mark || unmark || list)
+      raise abort("no files or directories specified; use --all to remerge all files")
+    end
+    
+    true
+  end
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    parse_args = lambda {|os| [:all, :mark, :unmark, :list].map {|i| os[i] } }
+    
+    all, mark, unmark, list = *parse_args[opts]
+    merge_state = Amp::Merges::MergeState.new(repo)
+    
+    if opts[:all]
+      # the block means "default to true" - so basically ignore all other input
+      match = Amp::Match.create(:files    => []) { true }
+    else
+      # the block means "default to false" - rely entirely on user input
+      match = Amp::Match.create(:includer => opts[:include],
+                                :excluder => opts[:exclude],
+                                :files    => args) { false }
+    end                        
+                          
+    # iterate over each entry in the merge state file
+    merge_state.each do |file, status|
+      # check to see if our user wants this file
+      if match.call(file)
+        if list
+          Amp::UI.say "#{status.first} #{file}"
+        elsif mark
+          # the "r" means resolved
+          merge_state.mark(file, "r")
+          Amp::UI.say "#{file} marked as #{"resolved".blue}"
+        elsif unmark
+          # the "u" means unresolved
+          merge_state.mark(file, "u")
+          Amp::UI.say "#{file} marked as #{"unresolved".red}"
+        else
+          # retry the merge
+          working_changeset = repo[nil]
+          merge_changeset = working_changeset.parents.last
+          
+          # backup the current file to a .resolve file (but retain the extension
+          # so editors that rely on extensions won't bug out)
+          path = repo.working_join file
+          File.copy(path, path + ".resolve"  + File.extname(path))
+          
+          # try to merge the files!
+          merge_state.resolve(file, working_changeset, merge_changeset)
+          
+          # restore the backup to .orig (overwriting the old one)
+          File.move(path + ".resolve"  + File.extname(path), path + ".orig" + File.extname(path))
+        end
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,53 @@
+command :revert do |c|
+  c.workflow :hg
+  c.desc "Restore individual files or dirs to an earlier state"
+  c.opt :include, "include names matching the given patterns", :short => "-I", :type => :string
+  c.opt :exclude, "exclude names matching the given patterns", :short => "-X", :type => :string
+  c.opt :rev, "The revision to revert to", :short => "-r", :type => :integer
+  c.opt :all, "Revert entire repository", :short => "-a"
+  c.help <<-HELP
+amp revert [options]+ [FILE]+
+  
+  restore individual files or dirs to an earlier state
+  
+  (use update -r to check out earlier revisions, revert does not
+  change the working dir parents)
+  
+  With no revision specified, revert the named files or directories
+  to the contents they had in the parent of the working directory.
+  This restores the contents of the affected files to an unmodified
+  state and unschedules adds, removes, copies, and renames. If the
+  working directory has two parents, you must explicitly specify the
+  revision to revert to.
+  
+  Using the -r option, revert the given files or directories to their
+  contents as of a specific revision. This can be helpful to "roll
+  back" some or all of an earlier change.
+  See 'amp help dates' for a list of formats valid for -d/--date.
+  
+  Revert modifies the working directory. It does not commit any
+  changes, or change the parent of the working directory. If you
+  revert to a revision other than the parent of the working
+  directory, the reverted files will thus appear modified
+  afterwards.
+  
+  If a file has been deleted, it is restored. If the executable
+  mode of a file was changed, it is reset.
+  
+  If names are given, all files matching the names are reverted.
+  If no arguments are given, no files are reverted.
+  
+  Modified files are saved with a .orig suffix before reverting.
+  To disable these backups, use --no-backup.
+  
+Options are:
+HELP
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    list = args.map {|p| repo.relative_join(p) } # we assume they're files
+    
+    repo.revert list, opts
+    
+  end
+end

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

@@ -0,0 +1,13 @@
+command :root do |c|
+  c.workflow :hg
+  c.desc "Prints the current repository's root path."
+  c.help <<-EOF
+amp root
+  
+  Prints the path to the current repository's root.
+EOF
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    puts repo.root
+  end
+end

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

@@ -0,0 +1,38 @@
+command :serve do |c|
+  c.workflow :hg
+  
+  c.desc "Starts an HTTP server (with an associated website) serving the repository"
+  c.opt :path,    "The path section of the URL (e.g. /repository/served/)",    :short => "-P", :type => :string
+  c.opt :port,    "Which port to run the server on",                           :short => "-p", :type => :integer
+  c.opt :basic,   "HTTP Basic Authentication (vs. Digest)",                    :short => "-b", :default => false
+  c.opt :private, "Should the server not be publicly readable?",               :short => "-X", :default => false
+  c.opt :storage, "Store the users in [TYPE] manner. Can be 'sequel' or 'memory'", :short => "-s", :type => :string,
+                                                                               :default => 'memory'
+  c.opt :users,   "File from which to read the users (YAML format)",           :short => '-u', :type => :string
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    http_path = opts[:path] || "/"
+    auth = opts[:basic] ? :basic : :digest
+    
+    server = Amp::Servers::FancyHTTPServer
+    server.set_authentication auth
+    server.amp_repository http_path, repo, {:title => repo.root }
+    server.set :port, opts[:port] if opts[:port]
+    
+    server.set_storage opts[:storage]
+    
+    file  = YAML::load_file(opts[:users] || File.join(repo.hg, 'users')) rescue {:users => []}
+    
+    perms = file[:users].map do |u|
+      [ u[:permission]                                                   ,
+        server << {:username => u[:username], :password => u[:password]} ]
+    end
+    
+    perms.map {|(p, u)| server.set_permission p, repo, u }
+    server.set_private repo, opts[:private]
+    
+    server.run!
+    
+  end
+end

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

@@ -0,0 +1,116 @@
+command :status do |c|
+  c.workflow :hg
+  
+  c.desc "Prints the status of the working directory (or another revision)"
+  c.opt :all,       "Show all files", {:short => "-A"}
+  c.opt :modified,  "Show only modified files", {:short => "-m"}
+  c.opt :added,     "Show only added files", {:short => "-a"}
+  c.opt :deleted,   "Show only deleted files", {:short => "-D"}
+  c.opt :removed,   "Show only removed files", {:short => "-R"}
+  c.opt :clean,     "Show only files without changes", {:short => "-c"}
+  c.opt :unknown,   "Show only untracked files", {:short => "-u"}
+  c.opt :ignored,   "Show only ignored files", {:short => "-i"}
+  c.opt :rev,       "Selects which revision to use", {:short => "-r", :type => :string, :multi => true}
+  c.opt :hg,        "Print the information in hg's style"
+  c.opt :"no-color","Don't use color to categorize the output"
+  c.opt :yaml,      "Print the information in YAML format (for use with computers)", {:short => '-y'}
+  c.synonym :st
+  
+  c.on_run do |options, args|
+    repo = options[:repository]
+    node1, node2 = *c.revision_pair(repo, options[:rev])
+    cwd = "" # use patterns later
+    stop = "\n"
+    copy = {}
+    colors = {'modified' => :cyan,
+              'added'    => :blue,
+              'removed'  => :red,
+              'deleted'  => :magenta,
+              'unknown'  => :green,
+              'ignored'  => :yellow,
+              'clean'    => :white
+             }
+    states = ['modified',
+              'added'   ,
+              'removed' ,
+              'deleted' ,
+              'unknown' ,
+              'ignored' ,
+              'clean'   ]
+    show = states.select {|k| options[k.to_sym] } # filter the list down
+    
+    show = states if options[:all]
+    show = states[0..4] if show.empty?
+    
+    statopts = {:node_1 => node1, :node_2 => node2 }
+    
+    show.each {|switch| statopts[switch.to_sym] = true }
+
+    status = repo.status statopts
+    
+    # this is the proc that does the printing. I have the code in a proc
+    # so that the logic is in a short screenful and isn't convoluted.
+    stdout_print = proc do
+      # PRINTING TIME!!!!!!!!
+      if options[:hg]
+        status_as_array = [status[:modified],
+                           status[:added]   ,
+                           status[:removed] ,
+                           status[:deleted] ,
+                           status[:unknown] ,
+                           status[:ignored] ,
+                           status[:clean]
+                          ]
+        changestates = states.zip("MAR!?IC".split(""), status_as_array)
+        changestates.each do |state, char, files|
+          if show.include? state
+            files.each do |f|
+              #Amp::Logger.info("#{char} #{f}")
+              if options[:"no-color"]
+                Amp::UI.tell "#{char} #{File.join(cwd, f.to_s)[1..-1]}#{stop}" unless f.nil?
+              else
+                Amp::UI.tell "#{char.send colors[state]} #{File.join(cwd, f.to_s)[1..-1]}#{stop}" unless f.nil?
+              end
+            end
+          end
+        end
+      else
+        # print it our way
+        show.each do |state|
+          next if status[state.to_sym].empty?
+          num_of_files = status[state.to_sym].size
+          
+          if options[:"no-color"]
+            Amp::UI.say("#{state.upcase}" +
+                " => #{num_of_files} file#{num_of_files == 1 ? 's' : ''}")
+          else
+            Amp::UI.say("#{state.upcase.send colors[state]}" +
+                " => #{num_of_files} file#{num_of_files == 1 ? 's' : ''}")
+          end
+          
+          status[state.to_sym].each do |file|
+            #Amp::Logger.info("#{state[0,1].upcase} #{file}")
+            Amp::UI.say "\t#{File.join(cwd, file)[1..-1]}"
+          end
+          
+        end
+        
+        Amp::UI.say
+        Amp::UI.say "#{status[:delta]} bytes were changed" if status[:delta]
+      end
+    end
+    
+    yaml_printer = proc do
+      require 'yaml'
+      puts YAML::dump(status)
+    end
+    
+    # printing logic
+    if options[:yaml]
+      yaml_printer[]
+    else
+      stdout_print[]
+    end
+    
+  end
+end