amp 0.5.0

data/test/dirstate_tests/test_dir_state.rb

@@ -0,0 +1,192 @@
+require "test/unit"
+require File.expand_path(File.join(File.dirname(__FILE__), "../../lib/amp"))
+
+# easyness
+class String
+  def dir_local; File.expand_path(File.join(File.dirname(__FILE__), self)); end
+end
+
+
+class TestDirState < Test::Unit::TestCase
+  
+  def setup
+    f = File.open File.join(File.dirname(__FILE__), "hgrc")
+    @config = PythonConfig::ConfigParser.new f
+    opener = Amp::Opener.new File.expand_path(File.dirname(__FILE__))
+    opener.default = :open_file
+    @state = Amp::Repositories::DirState.new File.expand_path(File.dirname(__FILE__)), @config, opener
+    @files = []
+  end
+  
+  def teardown
+    @files ||= []
+    @files.map {|f| File.delete f.dir_local }
+    @files = []
+  end
+  
+  def test_root
+    assert_equal File.expand_path(File.dirname(__FILE__)), @state.root
+  end
+  
+  def test_config
+    assert_equal @config,  @state.config
+  end
+  
+  def test_parents_equals
+    @state.parents = ["asdfasdf", Amp::RevlogSupport::Node::NULL_ID]
+    
+    assert_equal ["asdfasdf", Amp::RevlogSupport::Node::NULL_ID], @state.parents
+    
+    @state.parents = "asdfasdf"
+    
+    assert_equal ["asdfasdf", Amp::RevlogSupport::Node::NULL_ID], @state.parents
+  end
+  
+  def test_dirty?
+    @state.parents = ["asdfasdf", Amp::RevlogSupport::Node::NULL_ID] # something to dirty it up
+    
+    assert @state.dirty?
+  end
+  
+  def test_dirty
+    add_file "elephant"
+    @state.dirty "elephant"
+    
+    assert @state["elephant"].dirty?
+  end
+  
+  def test_maybe_dirty
+    add_file "eels"
+    @state.maybe_dirty "eels"
+    
+    assert !@state.copy_map["eels"]
+    assert @state["eels"].maybe_dirty?
+  end
+  
+  def test_branch_equals
+    @files << 'branch'
+    @state.branch = "monkey!"
+    
+    text = File.read "branch".dir_local
+    assert_equal text, "monkey!\n"
+    assert_equal text.chomp, @state.branch
+  end
+  
+  def test_copy
+    add_file "buttmunch"
+    @state.copy "buttmunch" => "arsemunch"
+    
+    assert_equal "buttmunch", @state.copy_map["arsemunch"]
+    assert @state.dirty?
+    
+    @state.copy "arsemunch" => "buttmunch"
+    
+    assert @state.copy_map["buttmunch"]
+    assert @state.copy_map["arsemunch"]
+  end
+  
+  def test_add
+    add_file "test"
+    
+    assert @state.files.include?("test")
+    assert !@state.copy_map["test"]
+  end
+  
+  # shouldn't actually happen IRL, but let's make sure we have
+  # the same quirks
+  def test_remove
+    add_file "monkey" # make sure it's in @files
+    @state.remove "monkey"
+    
+    assert @state["monkey"].removed?
+  end
+  
+  def test_forget
+    add_file "taco"
+    @state.forget "taco"
+    
+    assert @state["taco"].untracked?
+  end
+  
+  def test_merge
+    add_file "burritos"
+    @state.merge "burritos"
+    
+    assert @state["burritos"].merged? 
+  end
+  
+  def test_normal
+    add_file "poop"
+    @state.normal "poop"
+    
+    assert @state["poop"].normal?
+    assert !@state.copy_map["poop"]
+  end
+  
+  def test_clear
+    add_file "poopy"
+    @state.clear
+    
+    assert @state.files.empty?
+  end
+  
+  def test_rebuild
+    #add_file "testy"
+    
+    files = @state.files.dup
+    rents = @state.parents.dup
+    
+    @state.rebuild rents, files
+    assert_equal files, @state.files
+  end
+  
+  def test_write
+    add_file "oh_nuit"
+    @state.write
+    
+    info = File.read("dirstate".dir_local)
+    info.force_encoding("ASCII-8BIT")  if RUBY_VERSION >= "1.9"
+    string = "\000\000\000\000\000\000\000" +
+             "\000\000\000\000\000\000\000" +
+             "\000\000\000\000\000\000\000" +
+             "\000\000\000\000\000\000\000" +
+             "\000\000\000\000\000\000\000" +
+             "\000\000\000\000\000a\000\000" +
+             "\000\000\377\377\377\377\377" +
+             "\377\377\377\000\000\000\aoh_nuit"
+    assert_equal string, info
+  end
+  
+  def test_parse
+    @files = []
+    # some fake data
+    open "dirstate".dir_local, "w" do |f|
+      string = "\000\000\000\000\000\000\000" +
+               "\000\000\000\000\000\000\000" +
+               "\000\000\000\000\000\000\000" +
+               "\000\000\000\000\000\000\000" +
+               "\000\000\000\000\000\000\000" +
+               "\000\000\000\000\000a\000\000" +
+               "\000\000\377\377\377\377\377" +
+               "\377\377\377\000\000\000\aoh_nuit"
+      f.write string
+    end
+    
+    @state.send :read!
+    
+    assert_equal({"oh_nuit" => Amp::Repositories::DirStateEntry.new(:added, 0, -1, -1)}, @state.files)
+    assert_equal({}, @state.copy_map)
+  end
+
+  private
+  def add_file(name)
+    open name.dir_local, "w" do |f|
+      f.puts "testyness!"
+    end
+    
+    @state.add name
+    (@files ||= []) << name
+  end
+
+end
+

data/test/functional_tests/resources/.hgignore

@@ -0,0 +1,2 @@
+syntax: regexp
+.*?lolcats\.rb$

data/test/functional_tests/resources/STYLE.txt

@@ -0,0 +1,25 @@
+The Amp Commandments:
+    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.
+    3. Thou shalt preface thine variables with _ only when thou needest,
+       lest ye face judgement for this most grave sin.
+    4. Thine variables should have descriptive names, for thine ruby must
+       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.
+    8. Thou shalt use parentheses in thine defintions of methods, for the
+       consistency of the codes in this repository. Sir William Morgan will
+       have to change the style of himself, for his is strange yet beautiful
+       but still unwanted like a D of the ST kind.
+    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 good.
+    11. Name thine motherfucking variables motherfucking descriptively.

data/test/functional_tests/resources/command.rb

@@ -0,0 +1,372 @@
+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
+      @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
+    # 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
+    # @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+`
+    # 
+    # @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.
+    def break
+      @break = true
+    end
+    
+    ##
+    # Called by the dispatcher to execute the command. You really don't need to
+    # override this. The `@break` instance variable can be set by anything, which
+    # will halt the chain.
+    # 
+    # @param options The global options, merged with the command-specific 
+    #                options, as decided by the dispatcher.
+    # @param arguments The list of arguments, passed after the options. Could 
+    #                  be a filename, for example.
+    # @return [Amp::Command] the command being run
+    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 volt_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