amp 0.5.2 → 0.5.3

data/lib/amp/commands/commands/help.rb

@@ -5,25 +5,7 @@ command :help do |c|
   c.on_run do |options, args|
     output = ""
     
-    if args.empty?
-      output << "These are the following commands available:\n"
-      
-      Amp::Command.all_for_workflow(options[:global_config]["amp"]["workflow", Symbol, :hg], false).sort {|k1, k2| k1.to_s <=> k2.to_s}.each do |k, v| 
-        output << "\t#{k.to_s.ljust(30, " ")}#{v.desc}" + "\n"
-      end
-      
-      output << 'Run "amp help [command]" for more information.'
-      
-      Amp::UI.say output
-    else
-      
-      unless cmd = Amp::Command.all_for_workflow(options[:global_config]["amp"]["workflow", Symbol, :hg])[args.first.to_sym]
-        Amp::UI.say "The command #{args.first} was not found."
-      else
-        cmd.collect_options
-        cmd.educate
-      end
-      
-    end
+    cmd_name = args.empty? ? "__default__" : args.first
+    Amp::Help::HelpUI.print_entry(cmd_name, options)
   end
 end

data/lib/amp/commands/commands/init.rb

@@ -1,10 +1,22 @@
 command :init do |c|
   c.workflow :all
+  
   c.desc "Initializes a new repository in the current directory."
+  c.opt :type, "Which type of repository (git, hg)", :short => '-t', :type => :string, :default => 'hg'
+  
   c.on_run do |options, args|
     path = args.first ? args.first : '.'
     
-    Amp::Repositories::LocalRepository.new(path, true, options[:global_config])
-    puts "New repository initialized."
+    case options[:type]
+    when 'hg'
+      Amp::Repositories::Mercurial::LocalRepository.new(path, true, options[:global_config])
+    when 'git'
+      Amp::Repositories::Git::LocalRepository.new(path, true, options[:global_config])
+    else
+      raise "Unknown repostiory type #{options[:type].inspect}"
+    end
+    
+    
+    puts "New #{options[:type]} repository initialized."
   end
 end

data/lib/amp/commands/commands/templates.rb

@@ -66,20 +66,22 @@ Module.new do
           end
           Amp::UI.edit_file(filename) if filename
         when TEMPLATE_ADD_MODE
+          type = Amp::UI.ask("What VCS would you like your template to be associated with?", String)
           filename = Amp::UI.ask("What would you like to name your template? ", String)
           type = Amp::UI.ask("What kind of template? (log, commit) ", String) {|q| q.in = ["log","commit"]}
-          old_file = Amp::Support::Template["blank-#{type}"].file
-          new_file = File.join(template_directory, filename + ".erb")
+          old_file = Amp::Support::Template[type, "blank-#{type}"].file
+          new_file = File.join(template_directory, type, filename + ".erb")
           File.copy(old_file, new_file)
           Amp::UI.edit_file new_file
-          Amp::Support::FileTemplate.new(filename, new_file)
+          Amp::Support::FileTemplate.new(type, filename, new_file)
         when TEMPLATE_DELETE_MODE
           filename = nil
           Amp::UI.choose do |menu|
+            type = Amp::UI.ask("Which VCS's templates are we modifying?", String)
             menu.prompt = "Which template would you like to delete?"
             templates_for_scope(scope, repo).each do |template|
               menu.choice(template.name) do 
-                Amp::Support::Template.unregister template.name
+                Amp::Support::Template.unregister type, template.name
                 filename = template.file
               end
             end

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

@@ -1,7 +1,21 @@
 command :version do |c|
-  c.desc "Prints the current version of Amp."
   c.workflow :all
+  
+  c.desc "Prints the current version of Amp."
+  c.opt :super, "Print out a hash of the source for amp to verify its integrity"
   c.on_run do |options, args|
     puts "Amp version #{Amp::VERSION} (#{Amp::VERSION_TITLE})"
+    
+    if options[:super]
+      require 'digest/md5'
+      digest = Digest::MD5.new
+      
+      files = Dir["#{Amp::CODE_ROOT}/**/**/**/**/**/**/**/**/**/*.rb"]
+      files.each do |file|
+        open(file) {|f| digest << f.read(8192) } # read in the file in 8K chunks
+      end
+      
+      puts "\tIntegrity Digest: #{digest.hexdigest}"
+    end
   end
 end

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

@@ -8,10 +8,10 @@ command :workflow do |c|
   c.before do |opts, args|
     if args.size < 1
       puts "Usage:      amp workflow workflow_name"
-      c.break
+      false
+    else
+      true
     end
-    
-    true
   end
   
   c.on_run do |opts, args|

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

@@ -42,19 +42,19 @@ HELP
     exact = {}
     working_changeset.walk(matcher, true).each do |file, _|
       if matcher.exact? file
-        if repo.dirstate.ignore(file) && !opts[:force]
+        if repo.staging_area.ignoring_file?(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])
+      elsif !repo.staging_area.include?(file) && (!repo.staging_area.ignoring_file?(file) || opts[:force])
         Amp::UI.status "adding #{file.relative_path repo.root}"
         names << file
       end
     end
     
-    rejected = repo.add names unless opts[:"dry-run"]
+    rejected = repo.staging_area.stage names unless opts[:"dry-run"]
     
     if names.size == 1
       Amp::UI.say "File #{names.first.blue} has been added at #{Time.now}"

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

@@ -21,7 +21,7 @@ command :copy do |c|
     sources = args[0..-2]
     destination = args.last
     sources.each do |source|
-      repo.copy(source, destination, opts)
+      repo.staging_area.copy(source, destination, opts)
     end
   end
 end

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

@@ -4,8 +4,10 @@ command :rm do |c|
   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 :cached, "Removes the file only from the staging area (doesn't unlink file)"
   c.opt :recursive, "Recursively remove named directories", :short => "-r"
+  c.opt :"no-unlink", "Don't remove the file - just forget it", :short => '-s'
+  
   c.on_run do |opts, args|
     repo = opts[:repository]
     working_changeset = repo[nil]
@@ -46,7 +48,7 @@ command :rm do |c|
       (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.staging_area.remove remove, :unlink => opts[:"no-unlink"] unless opts[:"dry-run"] # forgetting occurs here
     repo.forget forget unless opts[:"dry-run"]
     
     remove += forget

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

@@ -41,7 +41,7 @@ HELP
       end
     end
     
-    rejected = repo.add names unless opts[:"dry-run"]
+    rejected = repo.staging_area.add names unless opts[:"dry-run"]
     
     
     if names.size == 1

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

@@ -61,7 +61,7 @@ EOS
       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"]
+    repo.staging_area.add(to_add) unless opts[:"dry-run"]
     
     Amp::UI.say
     # Prettified, add check later if user disables colors
@@ -80,7 +80,7 @@ EOS
       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"]
+    repo.staging_area.remove to_del unless opts[:"dry-run"]
     
   end
 end

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

@@ -7,6 +7,7 @@ command :annotate do |c|
   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.opt :number, "Show the revision number of the committed line", :short => "-n"
   c.synonyms :blame, :praise
   
   c.on_run do |opts, args|
@@ -20,11 +21,16 @@ command :annotate do |c|
       max_size = 0
       full_results = results.map do |file, line_number, line|
         revpart = ""
-        showrev = !([opts[:changeset], opts[:user], opts[:date]].any?)
+        showrev = opts[:number] || !([opts[:changeset], opts[:user], opts[:date]].any?)
         
+        # What did this line do? There is no Array#count
+        #totalparts = [opts[:user], opts[:date], opts[:changeset], showrev].count {|x| x }
         revpart += (opts[:verbose] ? file.changeset.user : file.changeset.user.split("@").first[0..15]) if opts[:user]
+        revpart += " " if opts[:user] and opts[:date] || opts[:changeset] || showrev
         revpart += Time.at(file.changeset.date.first).to_s if opts[:date]
-        revpart += " " + file.changeset.node_id.hexlify[0..11] if opts[:changeset]
+        revpart += " " if opts[:date] and opts[:changeset] || showrev
+        revpart += file.changeset.node_id.hexlify[0..11] if opts[:changeset]
+        revpart += " " if opts[:changeset] and showrev
         revpart += file.change_id.to_s if showrev
         
         if line_number

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

@@ -0,0 +1,253 @@
+command :bisect do |c|
+  c.workflow :hg
+  
+  c.desc "subdivision search of changesets"
+  c.help <<-EOS
+amp bisect [-gbsr] [-c CMD] [REV]
+  
+  This command helps to find changesets which introduce problems.
+  To use, mark the earliest changeset you know exhibits the problem
+  as bad, then mark the latest changeset which is free from the
+  problem as good. Bisect will update your working directory to a
+  revision for testing (unless the --noupdate option is specified).
+  Once you have performed tests, mark the working directory as bad
+  or good and bisect will either update to another candidate changeset
+  or announce that it has found the bad revision.
+  
+  As a shortcut, you can also use the revision argument to mark a
+  revision as good or bad without checking it out first.
+  
+  If you supply a command it will be used for automatic bisection. Its exit
+  status will be used as flag to mark revision as bad or good. In case exit
+  status is 0 the revision is marked as good, 125 - skipped, 127 (command not
+  found) - bisection will be aborted and any other status bigger than 0 will
+  mark revision as bad."
+  
+  Where options are:
+EOS
+  
+  c.opt :command, "The command to run to test", :short => '-c', :type => :string, :default => 'ruby'
+  c.opt :"dirty-room", "Eval the ruby code in -f in the context of this amp binary (faster than shelling out)", :short => '-d'
+  c.opt :file, "The file to run with --command (which defaults to ruby) for testing", :short => '-f', :type => :string
+  c.opt :"no-update", "Don't update the working directory during tests", :short => '-U'
+  c.opt :revs, "The revision range to search in", :short => '-r', :type => :string, :default => '0'
+  
+  c.before do |opts, args|
+    # Set the command to be the command and the file joined together in
+    # perfect harmony. If file isn't set, command will still work.
+    # If command isn't set, it defaults to 'ruby' up in the command parsing
+    # so actually it's always set unless there's a problem between the keyboard
+    # and chair. I'm sorry this isn't cross platform. Find room in your heart
+    # to forgive me.
+    opts[:command] = "#{opts[:command]} #{opts[:file]} 1>/dev/null 2>/dev/null"
+    
+    if opts[:"dirty-room"]
+      raise "The --dirty-room option needs --file as well" unless opts[:file]
+    end
+    
+    # If we have to preserve the working directory, then copy
+    # it to a super secret location and do the work there
+    if opts[:"no-update"]
+      require 'fileutils'
+      
+      opts[:testing_repo] = "../.amp_bisect_#{Time.now}"
+      FileUtils.cp_r repo.path, opts[:testing_repo]
+    end
+    
+    true
+  end
+  
+  c.after do |opts, args|
+    if opts[:"no-update"]
+      FileUtils.rm_rf opts[:testing_repo]
+    end
+  end
+  
+  c.on_run do |opts, args|
+    #################################
+    # VARIABLE PREP
+    #################################
+    # Set up some variables and make
+    # $display be set to false.
+    # Also set up what the proc is to
+    # test each revision. Assign a cute
+    # phrase to tell the user what's going
+    # on.
+    # 
+    
+    repo = opts[:repository]
+    old  = $display
+    $display = false # so revert won't be so chatty!
+    
+    # This is the sample to run. The proc needs to return true
+    # or false
+    if opts[:command]
+      using = "use `#{opts[:command].red}`"
+      run_sample = proc { system opts[:command] }
+    elsif opts[:"dirty-room"]
+      using = "evaluate #{opts[:file]} in this Ruby interpreter"
+      run_sample = proc { eval File.read(opts[:file]) }
+    else
+      raise "Must have the --command or --dirty-room option set!"
+    end
+    
+    last_good, last_bad = *c.parse_revision_range(opts[:revs])
+    last_bad ||= repo.size - 1
+    history = [last_bad]  # KILLME
+    
+    test_rev  = last_bad
+    is_good   = {} # {revision :: integer => good? :: boolean}
+    last_good.upto(last_bad) {|i| is_good[i] = nil }
+    
+    ########################################
+    # COMPLIMENT WHOEVER IS READING THE CODE
+    ########################################
+    
+    # Hey! That's a really nice shirt. Where'd you get it?
+    Amp::UI.say "Sweet computer, btw. I'm really digging this hardware.\n"
+    
+    
+    ########################################
+    # EXPLICITLY SAY WHAT WE'RE DOING
+    ########################################
+    Amp::UI.say <<-EOS
+OK! Terve! Today we're going to be bisecting your repository find a bug.
+Let's see... We're set to #{using} to do some bug hunting between revisions
+#{last_good.to_s.red} and #{last_bad.to_s.red}.
+
+Enough talk, let's go Orkin-Man on this bug!
+========
+EOS
+    
+    
+    #############################################
+    # BINARY SEARCH
+    #############################################
+    # Here's where we actually do the work. We're
+    # just going through in a standard binary
+    # search method. I haven't actually written
+    # a BS method in a long time so I don't know
+    # if this is official, but it works.
+    # 
+    
+    until (last_good - last_bad).abs < 1
+      repo.clean test_rev
+      
+      # keep the user updated
+      pretty_print is_good 
+      
+      # if the code sample works
+      if run_sample[]
+        is_good[test_rev] = true # then it's a success and mark it as such
+        break if test_rev == last_good
+        last_good = test_rev
+      else
+        is_good[test_rev] = false
+        last_bad = test_rev
+      end
+      
+      test_rev = (last_good + last_bad) / 2
+      history << test_rev
+    end
+    puts # clear the progress bar business
+    
+    ############################################
+    # CLEANING UP
+    ############################################
+    # Restore the working directory to its proper
+    # state and restore the $display variable.
+    # Report on the results of the binary search
+    # and say whether there is a bug, and if there
+    # is a bug, say where it starts.
+    # 
+    
+    repo.clean(repo.size - 1)
+    $display = old # and put things as they were
+    
+    if is_good[last_bad]
+      Amp::UI.say "The selected range of history passes the test. No bug found."
+    else
+      Amp::UI.say "Revision #{last_bad} has the bug!"
+    end
+  end
+  
+  def pretty_print(hash)
+    print("\b" * hash.size * 3)
+    print "\r"
+    print '['
+    hash.keys.sort[0..-2].each do |key|
+      case hash[key]
+      when true
+        print 'o, '
+      when false
+        print 'x, '
+      when nil
+        print '_, '
+      end
+    end
+    case hash[hash.keys.sort.last]
+    when true
+      print 'o'
+    when false
+      print 'x'
+    when nil
+      print '_'
+    end
+    print ']'
+  end
+  
+  # c.on_run do |opts, args|
+  #   repo = opts[:repository]
+  #   
+  #   # Hey! That's a really nice shirt. Where'd you get it?
+  #   last_good = 0
+  #   last_bad  = repo.size - 1
+  #   test_rev  = last_bad
+  #   is_good  = {} # {revision :: integer => good? :: boolean}
+  #   a = [true] * 1#((repo.size / 2) + 3)
+  #   a.concat([false] * (repo.size - a.size))
+  #   p a
+  #   
+  #   run_sample = proc do |test_rev|
+  #     a[test_rev]
+  #   end
+  #   
+  #   until (last_good - last_bad).abs < 1
+  #     #repo.revert [], :to => test_rev
+  #     p [last_good, last_bad]
+  #     
+  #     # if the code sample works
+  #     if run_sample[test_rev]
+  #       is_good[test_rev] = true # then it's a success and mark it as such
+  #       break if test_rev == last_good
+  #       last_good = test_rev
+  #     else
+  #       is_good[test_rev] = false
+  #       last_bad = test_rev
+  #     end
+  #     
+  #     test_rev = (last_good + last_bad) / 2
+  #   end
+  #   
+  #   if is_good[last_bad]
+  #     Amp::UI.say "The selected range of history passes the test. No bug found."
+  #   else
+  #     Amp::UI.say "Revision #{last_bad} has the bug!"
+  #   end
+  # end
+end
+
+# Now for some helpers!
+module Kernel
+  def bisect_command(name, opts={})
+    command name.to_sym do |c|
+      
+      # set the default options as passed in
+      opts.each do |k, v|
+        c.default k, v
+      end
+      
+      yield self if block_given?
+    end
+  end
+end