amp 0.5.0

data/test/functional_tests/resources/version3/commands/annotate.rb

@@ -0,0 +1,45 @@
+command :annotate do |c|
+  c.desc "Shows who committed each line in a given file."
+  c.synonym :blame
+  c.opt :rev, "Which revision to annotate", :type => :integer, :default => nil, :short => "-r"
+  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 :"line-number", "Show line number of first appearance", :short => "-l"
+  c.opt :changeset, "Show the changeset stuff la la la la", :short => "-c"
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    annotate = proc do ||
+      revpart = ""
+      showrev = !([opts[:changeset], opts[:user], opts[:date]].any?)
+    end
+    
+    args.each do |arg|
+      newopts = {:line_numbers => opts[:"line-number"]}
+      results = repo.annotate(arg, opts[:rev], newopts)
+      leftparts = 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
+      end
+      
+      maxleftsize = leftparts.max {|a, b| a.size <=> b.size }.size
+      
+      results.map! do |file, line_number, line|
+        (revpart).rjust(maxleftsize) + "  " + line 
+      end
+      
+      puts results.join("LOLZ")
+    end
+  end
+end

data/test/functional_tests/resources/version3/commands/experimental/lolcats.rb

@@ -0,0 +1,17 @@
+command :lolcats do |c|
+  c.opt :cheezburger, "Add cheezburger to lolcat"
+  c.on_run do |opts, args|
+    puts "lolcats!"
+    puts "lolcats!"
+    puts "lolcats!"
+    puts "lolcats!"
+    puts "lolcats!"
+  end
+  
+  c.before do |opts, args|
+    puts "Before lolcats...."
+  end
+  c.after do |opts, args|
+    puts "After lolcats!"
+  end
+end

data/test/functional_tests/resources/version3/commands/heads.rb

@@ -0,0 +1,22 @@
+command :heads do |c|
+  c.desc "Prints the heads of the repository."
+  c.add_opt :rev, "show only heads which are descendants of rev", {:short => "-r"}
+  c.add_opt :active, "show only active heads", {:short => "-a"}
+  c.add_opt :template, "Which template to use while printing", {:short => "-t", :type => :string, :default => "default"}
+  c.on_run do |options, args|
+    repo   = options[:repository]
+    start  = options[:rev] ? repo.lookup(options[:rev]) : nil
+    closed = options[:active]
+    if args.size == 0
+      heads = repo.heads(start, :closed => closed)
+    else
+      #branch shit
+    end
+    
+    options.merge!({:template_type => :log})
+    heads.each do |n|
+      puts repo[n].to_templated_s(options)
+    end
+    
+  end
+end

data/test/functional_tests/resources/version3/commands/manifest.rb

@@ -0,0 +1,12 @@
+command :manifest do |c|
+  c.desc "Prints the manifest at a given revision (defaults to working directory)"
+  c.add_opt :rev, "Specifies the revision to check", {:short => "-r", :type => :integer}
+  c.on_run do |options, arguments|
+    revision = options[:rev]
+    repo = options[:repository]
+    
+    repo[revision].each do |k, v|
+      puts "#{k}"
+    end
+  end
+end

data/test/functional_tests/resources/version3/commands/status.rb

@@ -0,0 +1,90 @@
+command :status do |c|
+  c.desc "Prints the status of the working directory (or another revision)"
+  c.add_opt :all, "Show all files", {:short => "-A"}
+  c.add_opt :modified, "Show only modified files", {:short => "-m"}
+  c.add_opt :added,    "Show only added files", {:short => "-a"}
+  c.add_opt :deleted,  "Show only deleted files", {:short => "-D"}
+  c.add_opt :removed,  "Show only removed files", {:short => "-R"}
+  c.add_opt :clean,    "Show only files without changes", {:short => "-c"}
+  c.add_opt :unknown,  "Show only untracked files", {:short => "-u"}
+  c.add_opt :ignored,  "Show only ignored files", {:short => "-i"}
+  c.add_opt :rev,      "Selects which revision to use", {:short => "-r", :type => :string, :multi => true}
+  c.add_opt :hg,       "Print the information in hg's style"
+  c.add_opt :"no-color","Don't use color to categorize the output"
+  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
+    
+    # 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|
+            if options[:"no-color"]
+              Amp::UI.say "#{char} #{File.join(cwd, f.to_s)[1..-1]}#{stop}" unless f.nil?
+            else
+              Amp::UI.say "#{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
+        
+        Amp::UI.say("#{state.upcase.send colors[state]}" +
+            " => #{num_of_files} file#{num_of_files > 1 ? 's' : ''}")
+        
+        status[state.to_sym].each do |file|
+          Amp::UI.say "\t#{File.join(cwd, file)[1..-1]}"
+        end
+        
+        puts
+      end
+    end
+    
+  end
+end

data/test/functional_tests/resources/version4/.hgignore

@@ -0,0 +1,5 @@
+syntax: regexp
+.*?lolcats\.rb$
+
+syntax: glob
+commands/experimental/*

data/test/functional_tests/resources/version4/STYLE.txt

@@ -0,0 +1,31 @@
+The Amp Commandments Redux:
+    1. Thou shalt not useth the "for...in" syntax.
+    2. Thou shalt useth only but 80 columns, for those who useth the lord's
+       editors, vim and emacs. (emacs sucks - oh no he didn't)
+    3. Thou shalt preface thine variables with _ only when thou needest,
+       lest ye face judgement for this most grave sin. (this isn't python.
+       no __method__ is necessary!)
+    4. Thine variables should have descriptive names, for thine ruby might
+       read like the psalms.
+    5. Thine variables, longer than 6 letters and composed of two or more
+       words, shall separate those words with the lord's underscore, so thine
+       code shall flow like the Nile herself.
+    6. Thou shalt rake thine yard frequently, to be sure thine code is
+       well-documented for thine neighbors.
+    7. Thou shalt use alias_method over alias or I shall goeth Chris Brown
+       all over thou. (meh we don't need threats in the commandments.)
+    8. Thou shalt use parentheses in thine defintions of methods, for the
+       consistency of the codes in this repository.
+    9. Thine comments shall start, when above thine method definitions, with
+       2 (two) hashes, and the information, then, beginning on the line below
+       it. Thou shalt leave one blank comment line between thine comment info
+       and thine yard information.
+    10. Thou shalt make great and grand use of the yard extension. It is
+       pretty sweet.
+    11. Name thine motherfrakking vari
+
+
+VERSION 3
+
+VERSION 3
+ables motherfrakking descriptively.

data/test/functional_tests/resources/version4/command.rb

@@ -0,0 +1,376 @@
+need { 'command_support.rb' }
+module Amp
+  ##
+  # Represents a command within the Amp system. Simply instantiating a new
+  # command will make it available to the Amp executable. You configure the
+  # command by filling out a block in the command's initializer. 
+  # @example 
+  #   Command.new("add") do |c|
+  #     c.opt :include, "Paths to include", 
+  #                         :options => {:short => "-I", :multi => true}
+  #     c.opt :print_names, :desc => "Print the filenames", 
+  #               :options => {:short => "-p", 
+  #                            :default => false, 
+  #                             :type => :boolean}
+  #     c.on_run do |options, arguments|
+  #       if options[:print_names]
+  #         arguments.each do |filename|
+  #           puts filename
+  #         end
+  #       end
+  #     end
+  #     c.help "This is the help text when the user runs `amp help add`"
+  #   end
+  #
+  class Command
+    include CommandSupport
+    # All the commands registered in the system
+    @@all_commands = {}
+    
+    # Synonyms for commands. Used as a backup.
+    @@all_synonyms = {}
+    
+    # These are options that all commands support. Allows the user to put
+    # them after the subcommand.
+    GLOBAL_OPTIONS = []
+    
+    ##
+    # Returns all of the commands registered in the system.
+    # 
+    # @return [Hash] the commands, keyed by command name as a string
+    def self.all_commands
+      @@all_commands
+    end
+    
+    ##
+    # Returns all the synonyms registered in the system.
+    #
+    # @return [Hash] the synonyms, keyed by the synonym as a string
+    def self.all_synonyms
+      @@all_synonyms
+    end
+    
+    ##
+    # Returns all of the commands registered in the system.
+    # 
+    # @return [Hash] the commands, keyed by command name as a string
+    def self.[](arg)
+      return all_commands[arg] if all_commands[arg]
+      return all_synonyms[arg] if all_synonyms[arg]
+      nil
+    end
+
+    # Command-specific command-line options
+    attr_accessor :options
+    # The name of the command (eg add, init)
+    attr_accessor :name
+    # Short, 1-line description of the command
+    attr_accessor :description
+    # The options submitted
+    attr_accessor :options
+    
+    ##
+    # Creates a command in the Amp system. Simply instantiating a new
+    # command will make it available to the Amp executable. You configure the
+    # command by filling out a block in the command's initializer.
+    # 
+    # @example
+    #   Command.new("add") do |c|
+    #     c.opt :include, "Paths to include", 
+    #               :options => {:short => "-I", :multi => true}
+    #     c.opt :print_names, :desc => "Print the filenames", 
+    #               :options => {:short => "-p", :default => false, 
+    #                            :type => :boolean}
+    #     c.on_run do |options, arguments|
+    #       puts "silly!"
+    #     end
+    #   end
+    # @param name the name of the command that the user will use to call 
+    # the command
+    # @param &block a block of code where you can configure the command
+    # @yield This block configures the command. Set up options, add an on_run 
+    #        handler, and so on.
+    # @yieldparam The command itself - it is yielded so you can modify it.
+    def initialize(name)
+      # so that you can do additions to commands, just like ammending rake takss
+      name = name.to_s
+      if @@all_commands[name]
+        yield @@all_commands[name]
+        return
+      end
+      
+      @name                = name
+      @help                = ""
+      @description         = ""
+      @options             = []
+      @@all_commands[name] = self
+      @before = []
+      @after  = []
+      @break  = false
+      yield(self) if block_given?
+      @options += GLOBAL_OPTIONS
+    end
+    
+    ##
+    # Adds an command-line option to the command.
+    # 
+    # @param name the name of the command the user will type to run it
+    # @param desc the short, one-line description of the command
+    # @param options the options that configure the command-line option 
+    #                (too meta? sorry!)
+    # @option [String] options :short (nil) the short version of the option 
+    #                                       (e.g. "-I")
+    # @option [String] options :default (nil) the default value of the option.
+    # @option [Symbol] options :type (:string) the type of the option. Allows 
+    #                                     you to force Integer or URL matches.
+    # @option [Boolean] options :multi (false) can this option take multiple 
+    #                                          values?
+    def opt(name, desc='', options={})
+      @options << {:name => name, :desc => desc, :options => options}
+    end
+    alias_method :add_opt, :opt
+    
+    ##
+    # This method is how you set what the command does when it is run.
+    # 
+    # @param &block the code to run when the command runs
+    # @yield The code to run when the command is executed, after options 
+    #        are prepared.
+    # @yieldparam options The options that the dispatcher has prepared for 
+    #                     the command. Includes global and local.
+    # @yieldparam arguments All arguments passed to the command, after 
+    #                       the options.
+    # @example
+    #    Command.new("email_news") do |c|
+    #     c.on_run do |options, arguments|
+    #       arguments.each do |email_address|
+    #         send_some_email(options[:email_subject],email_address)
+    #       end
+    #     end
+    #    end
+    def on_run(&block)
+      @code = block
+    end
+    
+    ##
+    # This method lets you set a synonym (or synonyms) for this command.
+    # For example, the "remove" command has the synonym "rm". Example:
+    #   command :remove do |c|
+    #     c.synonym :rm, :destroy, :nuke
+    #   end
+    # then you can do
+    #   amp nuke badfile.rb
+    #
+    def synonym(*args)
+      args.each do |arg|
+        @@all_synonyms[arg.to_s] = self
+      end
+    end
+    
+    ##
+    # This returns the list of actions to run before the command, in order (first
+    # ones are run first). You can modify this array in any way you choose, and
+    # it is run _before_ the command is run.
+    # 
+    # @yield Extra code to run before the command is executed, after options are prepared.
+    # @yieldparam options The options that the dispatcher has prepared for the command. Includes global and local.
+    # @yieldparam arguments All arguments passed to the command, after the options.
+    # @return [Hash] an array of strings and blocks. Strings are assumed to be command
+    #                names and blocks are pieces of code to be run.
+    def before(*args, &block)
+      args.each do |arg|
+        @before << proc {|opts, args| Volt::Command[arg.to_sym].run(opts, args) }
+      end
+      
+      @before << block if block
+      @before
+    end
+    
+    ##
+    # This returns the list of actions to run after the command, in order (first
+    # ones are run first). You can modify this array in any way you choose, and
+    # it is run _after_ the command is run.
+    # 
+    # @yield Extra code to run after the command is executed, after options are prepared.
+    # @yieldparam options The options that the dispatcher has prepared for the command. Includes global and local.
+    # @yieldparam arguments All arguments passed to the command, after the options.
+    # @return [Hash] an array of strings and blocks. Strings are assumed to be command
+    #                names and blocks are pieces of code to be run.
+    def after(*args, &block)
+      args.each do |arg|
+        @after << proc {|opts, args| Volt::Command[arg.to_sym].run(opts, args) }
+      end
+      
+      @after << block if block
+      @after
+    end
+    
+    ##
+    # Sets the short description for the command. This shouuld be only 1 line,
+    # as it's what the user sees when they run `amp --help` and get the 
+    # full list of commands. `str` defaults to nil so that if no argument is
+    # passed, by default #desc will just return `@description`. If `str` is
+    # passed a string, then it will set `@description` to `str`.
+    # 
+    # @example cmd.desc "This command is useless."
+    # @example cmd.desc # => "This command is useless."
+    # @param [String, nil] str the help text to set
+    def desc(str=nil)
+      str ? @description = str : @description
+    end
+    
+    ##
+    # Sets the short description for the command. This shouuld be only 1 line,
+    # as it's what the user sees when they run `amp --help` and get the 
+    # full list of commands.
+    # 
+    # @param str the help text to set
+    alias :desc= :desc
+    
+    ##
+    # Trollop's help info for the command
+    def educate
+      # comments are the devil's work.
+        # comments are the devil's work.
+      @parser ? @parser.educate : ''
+    end
+    alias_method :education, :educate
+    
+    ##
+    # Sets the command to not laod a repository when run. Useful for purely
+    # informational commands (such as version) or initializing a new
+    # repository.
+    def no_repo
+      NO_REPO_ALLOWED[@name] = true
+    end
+    
+    # @see no_repo
+    def no_repo=(value)
+      NO_REPO_ALLOWED[@name] = value
+    end
+    
+    ##
+    # Sets the command to not require a repository to run, but try to load one.
+    # Used, for example, for the templates command, which sometimes stores
+    # comments are the devil's work.
+      # comments are the devil's work.
+      # comments are the devil's work.
+        # comments are the devil's work.
+    # information in the local repository.
+    def maybe_repo
+      MAYBE_REPO_ALLOWED[@name] = true
+    end
+    
+    # @see no_repo
+    def maybe_repo=(value)
+      MAYBE_REPO_ALLOWED[@name] = value
+    end
+    
+    ##
+    # Sets the help text for the command. This can be a very long string,
+    # as it is what the user sees when they type `amp help +name+`
+    # 
+    # @param str the help text to set
+    # comments are the devil's work.
+      # comments are the devil's work.
+    # @example cmd.help %Q{
+    #            Big help text!
+    #          }
+    def help(str=nil)
+      str ? @help << str : @help
+    end
+    
+    ##
+    # Sets the help text for the command. This can be a very long string,
+    # as it is what the user sees when they type `amp help +name+`
+    # comments are the devil's work.
+      # comments are the devil's work.
+    # 
+    # @param str the help text to set
+    alias :help= :help
+    
+    ##
+    # Parses the commands from the command line using Trollop. You probably
+    # shouldn't override this method, but if you have good reason, go for it.
+    # 
+    # @return [Hash] The parsed command-line options
+    def collect_options
+      options = @options # hack to get around the fact that
+      help    = @help    # Trollop uses instance eval
+      
+      Trollop::options do
+        # we can't use @options here because Trollop::options uses instance_eval
+        options.each do |option|
+          opt option[:name], option[:desc], option[:options]
+        end
+        
+        banner help
+      end
+      
+    end
+    
+    def inspect
+      "#<Amp::Command #{name} >"
+    end
+    
+    ##
+    # Stops this command from running any further - uses the global options.
+        # comments are the devil's work.
+          # comments are the devil's work.
+    def break
+      @break = true
+    end
+    
+    ##
+    # comments are the devil's work.
+    def run(options={}, args=[])
+      # run the before commands
+      @before.each {|cmd| cmd.run options, args; return if @break }
+      
+      @code[options, args] # and of course the actual command...
+      
+      # top it off with the after commands
+      @after.each {|cmd| cmd.run options, args; return if @break }
+      
+      self
+    end
+    
+    NO_REPO_ALLOWED = {}
+    %w(clone init help version debugcomplete debugdata debugindex 
+       debugindexdot debugdate debuginstall debugfsinfo).each do |k|
+         NO_REPO_ALLOWED[k] = true
+    end
+    
+    MAYBE_REPO_ALLOWED = {}
+    %w().each do |k|
+      MAYBE_REPO_ALLOWED[k] = true
+    end
+    
+  end
+end
+
+module Kernel
+  # shortcut
+  def command(name, &block)
+    Amp::Command.new name, &block
+  end
+  
+  # Rake style namespacing
+  # After new commands are made, alter their names
+  # so that they're "#{namespace}:#{command}"
+  def silly_namespace(name)
+    # current commands
+    commands = Amp::Command.all_commands.keys
+    
+    yield
+    
+    more_commands = Amp::Command.all_commands.keys
+    new_commands = more_commands - commands
+    
+    new_commands.each do |key|
+      command_to_modify = Amp::Command[key]
+      command_to_modify.name = "#{name}:#{key}" # construct the new name
+      Amp::Command.all_commands[command_to_modify.name] = Amp::Command.all_commands.delete(key) # and do the switch
+    end
+  end
+end