amp 0.5.0

data/lib/amp/commands/commands/version.rb

@@ -0,0 +1,7 @@
+command :version do |c|
+  c.desc "Prints the current version of Amp."
+  c.workflow :all
+  c.on_run do |options, args|
+    puts "Amp version #{Amp::VERSION} (#{Amp::VERSION_TITLE})"
+  end
+end

data/lib/amp/commands/commands/workflow.rb

@@ -0,0 +1,28 @@
+command :workflow do |c|
+  c.workflow :all
+  c.maybe_repo
+  
+  c.desc "Sets the workflow amp uses for commands"
+  c.opt :local, "Sets the workflow locally, instead of globally", :short => "-l"
+  
+  c.before do |opts, args|
+    if args.size < 1
+      puts "Usage:      amp workflow workflow_name"
+      c.break
+    end
+    
+    true
+  end
+  
+  c.on_run do |opts, args|
+    config = opts[:global_config]
+    unless opts[:local]
+      while config.parent_config
+        config = config.parent_config
+      end
+    end
+    
+    config["amp"]["workflow"] = args.shift
+    config.save!
+  end
+end

data/lib/amp/commands/commands/workflows/git/add.rb

@@ -0,0 +1,65 @@
+command :add do |c|
+  c.workflow :git
+  c.desc "Add a file to the repository (it will be tracked from here on)"
+  c.opt :all,   "Adds all untracked files to the repository", :short => "-a"
+  c.opt :force, "Forces addition of ignored files", :short => "-f"
+  c.opt :"dry-run", "Doesn't actually add files - just shows output", :short => "-n"
+  c.opt :verbose, "Verbose output", :short => "-v"
+  c.help <<-HELP
+amp add [-n] [--force | -f] [--interactive | -i] [--patch | -p]
+             [--all | [--update | -u]] [--refresh] [--ignore-errors] [--]
+             <filepattern>...
+
+add the specified files on the next commit
+This command:
+
+    * Schedules files to be version controlled and added to the repository.
+    
+    * If an ignored file is explicitly named to be added, then the command will
+      abort. If an ignored file is added with a pattern, then they will be ignored silently.
+
+    * The files will be added to the repository at the next commit. To
+      undo an add before that, see [amp revert].
+    
+    * See the help for `git add` to see how this differs from the Mercurial implementation.
+
+HELP
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    working_changeset = repo[nil]
+    
+    files    = args.reject {|p| p.include?("*") }
+    patterns = args.select {|p| p.include?("*") }
+    
+    if opts[:all]
+      matcher = Amp::Match.create(:files => []) { |file| !repo.dirstate.include?(file) }
+    else
+      matcher = Amp::Match.create(:files => files, :includer => (["syntax: glob"] + patterns)) { false }
+    end
+    
+    names = []
+    exact = {}
+    working_changeset.walk(matcher, true).each do |file, _|
+      if matcher.exact? file
+        if repo.dirstate.ignore(file) && !opts[:force]
+          raise abort("Can't add the ignored file #{file}. Use --force to override")
+        end
+        Amp::UI.status "adding #{file.relative_path repo.root}" if opts[:verbose]
+        names << file
+        exact[file] = true
+      elsif !repo.dirstate.include?(file) && (!repo.dirstate.ignore(file) || opts[:force])
+        Amp::UI.status "adding #{file.relative_path repo.root}"
+        names << file
+      end
+    end
+    
+    rejected = repo.add names unless opts[:"dry-run"]
+    
+    if names.size == 1
+      Amp::UI.say "File #{names.first.blue} has been added at #{Time.now}"
+    else
+      Amp::UI.say "#{names.size.to_s.blue} files have been added at #{Time.now}"
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+command :copy do |c|
+  c.workflow :git
+  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.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
+  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/git/mv.rb

@@ -0,0 +1,23 @@
+command :mv do |c|
+  c.workflow :git
+  c.desc "Moves a file from one place to another"
+  
+  c.opt :force, "Forces the move, ignoring overwrites", :short => "-f"
+  c.opt :"dry-run", "Doesn't actually move files - only prints what would happen", :short => "-n"
+  
+  c.before do |opts, args|
+    if args.size < 2
+      Amp::UI.say "Usage: amp move source destination"
+      c.break
+    elsif args.size > 2 && !File.directory?(args.last)
+      Amp::UI.say "If you want to move more than 1 file, your destination must" +
+                  " be a directory."
+      c.break
+    end
+  end
+  
+  c.on_run do |opts, args|
+    opts.merge!(:rename => true)
+    Amp::Command["copy"].run(opts, args)
+  end
+end

data/lib/amp/commands/commands/workflows/git/rm.rb

@@ -0,0 +1,60 @@
+command :rm do |c|
+  c.workflow :git
+  c.desc "Removes files from the repository on next commit"
+  c.opt :force, "Forces removal of files", :short => "-f", :default => false
+  c.opt :quiet, "Doesn't print which files are removed", :short => "-q"
+  c.opt :"dry-run", "Doesn't actually remove files - just prints output", :short => "-n"
+  c.opt :cached, "Removes the file only from the index (doesn't unlink file)"
+  c.opt :recursive, "Recursively remove named directories", :short => "-r"
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    working_changeset = repo[nil]
+    
+    args     = args.map    {|p| repo.relative_join(p) }
+    files    = args.reject {|p| p.include?("*") }
+    patterns = args.select {|p| p.include?("*") }
+    # 
+    # files.select {|f| File.directory?(repo.working_join(f))}.each do |folder|
+    #   patterns += 
+    
+    match = Amp::Match.create(:files => files, :includer => (["syntax: glob"] + patterns)) { false }
+    
+    s = repo.status :match => match, :clean => true
+    modified, added, deleted, clean = s[:modified], s[:added], s[:deleted], s[:clean]
+    
+    remove, forget = [], []
+    
+    remove += clean
+    remove += deleted
+    remove += modified if opts[:force]
+    
+    if opts[:cached]
+      forget += added
+    elsif opts[:force]
+      remove += added
+    end
+    
+    unless opts[:force]
+      modified.each {|p| Amp::UI.warn "not removing #{p} - file is modified (use --force)"        }
+    end
+    
+    unless opts[:cached] || opts[:force]
+      added.each    {|p| Amp::UI.warn "not removing #{p} - file is marked for add (use --cached)" }
+    end
+    
+    unless opts[:quiet]
+      (remove + forget).sort.each {|f| Amp::UI.say "removing #{f}" }
+    end
+    
+    repo.remove remove, :unlink => ! opts[:after] unless opts[:"dry-run"] # forgetting occurs here
+    repo.forget forget unless opts[:"dry-run"]
+    
+    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/add.rb

@@ -0,0 +1,53 @@
+command :add do |c|
+  c.workflow :hg
+  
+  c.desc "Add a file to the repository (it will be tracked from here on)"
+  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 :"dry-run", "Doesn't actually add files - just shows output", :short => "-n"
+  c.help <<-HELP
+amp add [FILE]+ [options]
+
+  add the specified files on the next commit
+  This command:
+  
+      * Schedules files to be version controlled and added to the repository.
+  
+      * The files will be added to the repository at the next commit. To
+        undo an add before that, see [amp revert].
+  
+      If no names are given, all files are added to the repository.
+    
+  Where options are:
+HELP
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    list = args.map {|p| repo.relative_join(p) }
+    
+    matcher = Amp::Match.create :files    => list,
+                                :includer => opts[:include],
+                                :excluder => opts[:exclude]
+    names = []
+    exact = {}
+    repo.walk(nil, matcher).each do |file, _|
+      if matcher.exact? file
+        Amp::UI.status "adding #{file.relative_path repo.root}" if opts[:verbose]
+        names << file
+        exact[file] = true
+      elsif not repo.dirstate.include? file
+        Amp::UI.status "adding #{file.relative_path repo.root}"
+        names << file
+      end
+    end
+    
+    rejected = repo.add names unless opts[:"dry-run"]
+    
+    
+    if names.size == 1
+      Amp::UI.say "File #{names.first.blue} has been added at #{Time.now}"
+    else
+      Amp::UI.say "#{names.size.to_s.blue} files have been added at #{Time.now}"
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+##
+# This command will go through your repository's working directory, and if it
+# discovers any files that it was tracking, but have mysteriously disappeared,
+# the command will assume you meant to remove it (stop tracking it), and remove it
+# for you. Similarly, if you have any files that are untracked and have appeared
+# in your repository, and they aren't ignored by your .hgignore file, then we
+# assume you wanted to add them, and add them for you.
+#
+# The only significant difference between this command and Mercurial's implementation
+# is the addition of the interactive mode. This mode asks the user before each removal
+# and addition. Personally, I added it because I don't like blanket actions taken across
+# my entire repository. It's off by default.
+command :addremove do |c|
+  c.workflow :hg
+  
+  c.desc "Add all new files, delete all missing files"
+  c.opt :interactive, "Asks about each file before adding/removing", :default => false, :short => "-a"
+  c.opt :include, "include names matching the given patterns", :type => :string, :short => "-I"
+  c.opt :exclude, "exclude names matching the given patterns", :type => :string, :short => "-E"
+  c.opt :"dry-run", "Don't perform actions, just print output", :short => "-n"
+  c.help <<-EOS
+amp addremove [options]+
+
+  New files are ignored if they match any of the patterns in .hgignore. As
+  with add, these changes take effect at the next commit.
+
+  Use the -s option to detect renamed files. With a parameter > 0,
+  this compares every removed file with every added file and records
+  those similar enough as renames. This option takes a percentage
+  between 0 (disabled) and 100 (files must be identical) as its
+  parameter. Detecting renamed files this way can be expensive.
+  
+  Where options are:
+EOS
+
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    # Standard preparation for mercurial-style matching. We need a match object.
+    # If a file is missed by our matcher, assume we want it included (unknown files match
+    # this situation)
+    matcher = Amp::Match.create(:includer => opts[:include], :excluder => opts[:exclude]) { true }
+    # Get only the deleted and unknown files. We'll remove the former and add the latter.
+    results = repo.status(:match => matcher, :deleted => true, :added => false, :unknown => true,
+                          :ignored => false, :modified => false, :clean => false)
+    
+    Amp::UI.say
+    # Prettified, add check later if user disables colors
+    Amp::UI.say "ADDING FILES".blue if results[:unknown].any?
+    # Handle adding the files now
+    if opts[:interactive]
+      # Interactive means we ask the user if they want to add the file or not.
+      # Build a list based on what they agree upon, then add that list
+      to_add = []
+      results[:unknown].each do |file|
+        add = Amp::UI.yes_or_no("Add #{file.relative_path(repo.root).blue}? [y/n] ")
+        to_add << file if add
+      end
+    else
+      # Otherwise, just let the user know what we're about to add
+      results[:unknown].each {|file| Amp::UI.say "Adding #{file.relative_path repo.root}" }
+      to_add = results[:unknown]
+    end
+    repo.add(to_add) unless opts[:"dry-run"]
+    
+    Amp::UI.say
+    # Prettified, add check later if user disables colors
+    Amp::UI.say "REMOVING FILES".red if results[:deleted].any?
+    # Now we remove any files that mysteriously disappeared on us
+    if opts[:interactive]
+      # Interactive means ask the user if they want to remove a file from the repo or not.
+      # Build a list.
+      to_del = []
+      results[:deleted].each do |file|
+        del = Amp::UI.yes_or_no("Remove #{file.relative_path(repo.root).red}?")
+        to_del << file if del
+      end
+    else
+      # Otherwise, just inform the user of the damage (yes I'm biased against this command)
+      results[:deleted].each {|file| Amp::UI.say "Removing #{file.relative_path repo.root}" }
+      to_del = results[:deleted]
+    end
+    repo.remove to_del unless opts[:"dry-run"]
+    
+  end
+end

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

@@ -0,0 +1,46 @@
+command :annotate do |c|
+  c.workflow :hg
+  
+  c.desc "Shows who committed each line in a given file."
+  c.opt :rev, "Which revision to annotate", :short => "-r", :type => :integer, :default => nil
+  c.opt :"line-number", "Show line number of first appearance", :short => "-l"
+  c.opt :changeset, "Show the changeset ID instead of revision number", :short => "-c"
+  c.opt :user, "Shows the user who committed instead of the revision", :short => "-u"
+  c.opt :date, "Shows the date when the line was committed", :short => "-d"
+  c.synonyms :blame, :praise
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+
+    
+    args.each do |arg|
+      newopts = {:line_numbers => opts[:"line-number"]}
+      results = repo.annotate(arg, opts[:rev], newopts)
+      revpart = ""
+      max_size = 0
+      full_results = results.map do |file, line_number, line|
+        revpart = ""
+        showrev = !([opts[:changeset], opts[:user], opts[:date]].any?)
+        
+        revpart += (opts[:verbose] ? file.changeset.user : file.changeset.user.split("@").first[0..15]) if opts[:user]
+        revpart += Time.at(file.changeset.date.first).to_s if opts[:date]
+        revpart += " " + file.changeset.node_id.hexlify[0..11] if opts[:changeset]
+        revpart += file.change_id.to_s if showrev
+        
+        if line_number
+          revpart += ":" + line_number.to_s + ":"
+        else
+          revpart += ":"
+        end
+        max_size = revpart.size if revpart.size > max_size
+        [revpart, file, line_number, line]
+      end
+      
+      
+      full_results.map! do |revpart, file, line_number, line|
+        (revpart).rjust(max_size) + "  " + line 
+      end
+      puts full_results.join
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+command :archive do |c|
+  c.workflow :hg
+  c.desc "Create an unversioned archive of a repository revision"
+  
+  c.opt :"no-decode", "Do not pass files through decoders"
+  c.opt :prefix     , "Directory prefix for files in archive",     :short => '-p', :type => :string
+  c.opt :rev        , "Revision to distribute",                    :short => '-r', :type => :integer
+  c.opt :type       , "Type of distribution to create",            :short => '-t', :type => :string
+  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.help <<-HELP
+amp archive [options]+ dest
+
+    By default, the revision used is the parent of the working
+    directory; use "-r" to specify a different revision.
+
+    To specify the type of archive to create, use "-t". Valid
+    types are:
+
+    "files" (default): a directory full of files
+    "tar": tar archive, uncompressed
+    "tbz2": tar archive, compressed using bzip2
+    "tgz": tar archive, compressed using gzip
+    "uzip": zip archive, uncompressed
+    "zip": zip archive, compressed using deflate
+
+    The exact name of the destination archive or directory is given
+    using a format string; see "hg help export" for details.
+
+    Each member added to an archive file has a directory prefix
+    prepended. Use "-p" to specify a format string for the prefix.
+    The default is the basename of the archive, with suffixes removed.
+
+    Where options are:
+HELP
+  c.synonyms :export, :x
+  
+  c.on_run do |opts, args|
+    repo      = opts[:repository]
+    rev       = opts[:rev]
+    changeset = repo[rev]
+    dest      = args.shift
+    
+    matcher   = Amp::Match.create(:includer => opts[:include],
+                                  :excluder => opts[:exclude]) { true }
+    
+    
+    Amp::UI::tell "created destination \"#{dest}\", now writing files"
+    
+    make_tar_file = lambda do |tar_dest|
+      File.open(tar_dest, 'w') do |tarfile|
+        Archive::Tar::Minitar::Writer.open(tarfile) do |tar|
+          changeset.walk(matcher).each do |file|
+            Amp::UI::tell '.' # use dots to keep track
+            data = changeset.get_file(file).data
+            tar.add_file_simple(File.join(File.amp_split_extension(dest).first,file), :size => data.size, :mode => 0644) { |f| f.write data }
+          end
+        end
+      end
+    end
+    
+    case opts[:type]
+    when 'files' # a directory full of files
+      FileUtils.mkdir_p dest
+      Dir.chdir dest
+            
+      changeset.walk(matcher).each do |file|
+        Amp::UI::tell '.' # use dots to keep track
+        FileUtils.mkdir_p File.dirname(file) # make all the leading dirs
+        File.open(file, 'w') {|f| f.write changeset.get_file(file).data } # now write the data
+      end
+      
+    when 'tar' # tar archive, uncompressed
+      make_tar_file[dest]
+    when 'tbz2' # tar archive, compressed using bzip2
+      # http://www.nabble.com/how-to-stream-or-write-data-into-a-tar.gz-file-as-if-the-data-were--from-files--td19498643.html
+      need { '../../../../../../ext/amp/bz2/bz2' }
+      
+      tar_name = File.amp_split_extension(dest).first + '.tar'
+      
+      make_tar_file[tar_name]
+      
+      File.open(tar_name) do |in_tar|
+        BZ2::Writer.open(dest) do |f|
+          in_tar.amp_each_chunk { |chunk| Amp::UI::tell 'c'; f.write chunk }
+        end
+      end
+      
+      File.unlink(tar_name)
+    when 'tgz' # tar archive, compressed using gzip
+      # http://www.nabble.com/how-to-stream-or-write-data-into-a-tar.gz-file-as-if-the-data-were--from-files--td19498643.html
+      require 'zlib'
+      tar_name = File.amp_split_extension(dest).first + '.tar'
+      
+      make_tar_file[tar_name]
+      
+      File.open(tar_name) do |in_tar|
+        Zlib::GzipWriter.open(dest) do |f|
+          in_tar.amp_each_chunk { |chunk| Amp::UI::tell 'c'; f.write chunk }
+        end
+      end
+      
+      File.unlink(tar_name)
+    when 'uzip' # zip archive, uncompressed
+      raise "Not Yet Implemented"
+    when 'zip' # zip archive, compressed using deflate
+      
+      # Open up the destination
+      Zip::ZipFile.open dest, Zip::ZipFile::CREATE do |z|
+        # For each file in the revision that matches what we want
+        changeset.walk(matcher).each do |f|
+          Amp::UI::tell '.' # use dots to keep track
+          # create a file-spot for the file in the changeset
+          # and write the data to it
+          z.get_output_stream(f) {|q| q << changeset.get_file(f).data }
+        end
+        z.commit
+      end
+    else
+      raise "Unknown compression type: #{opts[:type]}"
+    end
+    
+    Amp::UI::say " revision exported!"
+  end
+end