amp-pure 0.5.0

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

@@ -0,0 +1,69 @@
+command :tag do |c|
+  c.workflow :hg
+  
+  c.desc "Tags a revision with a given tag name"
+  c.opt :rev, "Specifies which revision to tag", :short => "-r", :type => :string
+  c.opt :message, "Specifies the commit message", :short => "-m", :type => :string
+  c.opt :local, "Marks the tag as local only (not shared among repositories)", :short => "-l"
+  c.opt :remove, "Removes the tag, instead of applying it", :short => "-R"
+  c.opt :force, "Forces the tag to be applied, ignoring existing tags", :short => "-f"
+  c.opt :user, "Specifies which user to commit under", :short => "-u", :type => :string
+  c.opt :date, "Specifies which date to use", :short => "-d", :type => :string
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    user = opts[:user] || opts[:global_config].username
+    date = opts[:date] ? DateTime.parse(opts[:date]) : Time.now
+    rev  = opts[:rev]  || "."
+    message = opts[:message]
+    
+    names = args
+    if names.map! {|n| n.strip}.uniq!
+      raise abort("tag names must be unique")
+    end
+    names.each do |n|
+      if ["tip",".","null"].include? n
+        raise abort("the tag name #{n} is reserved")
+      end
+    end
+    if opts[:rev] && opts[:remove]
+      raise abort("--rev and --remove are incompatible")
+    end
+    
+    #removing a tag
+    if opts[:remove]
+      expected_type = opts[:local] ? "local" : "global"
+      names.each do |name|
+        unless repo.tag_type name
+          raise abort("tag #{name} does not exist")
+        end
+        if repo.tag_type(name) != expected_type
+          raise abort("tag #{name} is not a #{expected_type} tag")
+        end
+      end
+      rev = Amp::RevlogSupport::Node::NULL_ID
+      message ||= "Removed tag #{names.join(", ")}"
+    elsif !opts[:force]
+      names.each do |name|
+        if repo.tags[name]
+          raise abort("tag #{name} already exists" +
+                                             " (use -f to force)")
+        end
+      end
+    end
+    
+    if !rev && repo.dirstate.parents[1] != Amp::RevlogSupport::Node::NULL_ID
+      raise abort("uncommited merge - please provide" +
+                                         " a specific revision")
+    end
+    
+    node = repo[rev].node
+    
+    message ||= "Added tag #{names.join(", ")} for changeset #{node.short_hex}"
+    repo.apply_tag names, node, :message => message, 
+                                :local => opts[:local],
+                                :user => user,
+                                :date => date
+  end
+end

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

@@ -0,0 +1,27 @@
+command "tags" do |c|
+  c.workflow :hg
+  
+  c.desc "Lists the repository tags."
+  c.opt :quiet, "Prints only tag names", :short => "-q"
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    list = repo.tag_list
+    list.reverse!
+    tag_type = ""
+    list.each do |entry|
+      tag, node, revision = entry[:tag], entry[:node], entry[:revision]
+      if opts[:quiet]
+        Amp::UI.say "#{tag}"
+        next
+      end
+      if revision == -2
+        revision = repo.changelog.rev(node)
+      end
+      text = "#{revision.to_s.rjust(5)}:#{node.short_hex}"
+      tag_type = (repo.tag_type(tag) == "local") ? " local" : ""
+      
+      Amp::UI.say("#{tag.ljust(30)} #{text}#{tag_type}")  
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+command :tip do |c|
+  c.workflow :hg
+  
+  c.desc "Prints the information about the repository's tip"
+  c.opt :template, "Which template to use while printing", :short => "-t", :type => :string, :default => "default"
+  
+  c.on_run do |options, args|
+    repo = options[:repository]
+    options.merge! :template_type => :log
+    puts repo[repo.size - 1].to_templated_s(options)
+
+  end
+end

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

@@ -0,0 +1,27 @@
+command :update do |c|
+  c.workflow :hg
+  
+  c.desc "Updates the current repository to the specified (or tip-most) revision"
+  c.opt :rev, "The revision # to use for updating.", { :short => "-r", :type => :string }
+  c.opt :node, "The node ID to use for updating.", { :short => "-n", :type => :string }
+  c.opt :clean, "Remove uncommitted changes from the working directory.", { :short => "-C" }
+  
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    if opts[:rev] && opts[:node]
+      raise ArgumentError.new("Please only specify either --rev or --node.")
+    end
+    
+    rev = opts[:rev] ? opts[:rev] : opts[:node]
+    
+    # TODO: add --date option
+    if opts[:clean]
+      stats = repo.clean(rev)
+    else
+      stats = repo.update(rev)
+    end
+    
+    c.print_update_stats stats
+  end
+end

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

@@ -0,0 +1,9 @@
+command :verify do |c|
+  c.desc "Verifies the mercurial repository, checking for integrity errors"
+  c.workflow :hg
+  c.on_run do |opts, args|
+    results = opts[:repository].verify
+    puts "#{results.files} files, #{results.changesets} changesets, #{results.revisions} revisions"
+    puts "#{results.errors} integrity errors, #{results.warnings} warnings." if results.errors > 0 || results.warnings > 0
+  end
+end

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

@@ -0,0 +1,36 @@
+command :view do |c|
+  c.workflow :hg
+  
+  c.desc "Decompresses a file (or files) at a given revision and prints its data"
+  c.opt :output, "print output to file with formatted name", :type => :string
+  c.opt :rev, "specify which revision to view", :type => :string
+  
+  c.synonym :cat # mercurial notation
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    changeset = repo[opts[:rev]] # if unspecified will give nil which gives working directory anyway
+    changeset = changeset.parents.first unless opts[:rev] # parent of working dir if unspecified
+    
+    should_close = !!opts[:output]
+    
+    output_io = lambda do |filename|
+      if opts[:output]
+        path = opts[:output].gsub(/%s/, File.basename(filename)).gsub(/%d/, File.dirname(filename)).
+                             gsub(/%p/, filename)
+        File.open(path, "w")
+      else
+        $stdout
+      end
+    end
+    
+    args.each do |file|
+      versioned_file = changeset.get_file(repo.relative_join(file))
+      text           = versioned_file.data
+      output         = output_io[versioned_file.repo_path]
+      
+      output.write text # write it exactly as is
+    end
+  end
+end
+    

data/lib/amp/commands/dispatch.rb

@@ -0,0 +1,181 @@
+require 'abbrev'
+require       "amp/commands/command.rb"
+require_dir { "commands/*.rb"              }
+require_dir { "commands/commands/*.rb"     }
+
+module Amp
+  
+  ##
+  # = Dispatch
+  # This class handles parsing command-line options, finding commands, and running them.
+  class Dispatch
+    
+    ##
+    # This method essentially runs the amp executable. It first parses global options (--config)
+    # finds the subcommand (eg add, init, clone), parses the subcommand's options, merges the
+    # two, and then runs the entire thing.
+    def self.run
+      # Get the subcommands so we can stop on them
+      sub_commands = Amp::Command.all_commands.keys
+      # Get the global options (everything before the subcommand)
+      global_opts = Trollop::options do
+        banner "Amp - some more crystal, sir?"
+        version "Amp version #{Amp::VERSION} (#{Amp::VERSION_TITLE})"
+        opt :debug_opts,      "Debug the command-line options", :short => "-d", :default => false, :type => :boolean
+        opt :verbose,         "Verbose output"
+        opt :profile,         "Profile the command being run, running it the given number of times"
+        opt :repository,      "The path to the repository to use", :short => "-R", :type => :string, :default => Dir.pwd
+        opt :"pure-ruby",     "Use only pure ruby (no C-extensions)"
+        opt :testing,         "Running a test. Not for users to use"
+        stop_on_unknown
+      end
+      global_opts = global_opts.first # we don't need the parser here
+      
+      # This loads the built-in ruby profiler - it's extremely slow. Use with care.
+      if global_opts[:profile]
+        require 'profile'
+      end
+      
+      # Never load a C extension if we're in pure-ruby mode.
+      if global_opts[:"pure-ruby"]
+        $USE_RUBY = true
+      end
+      
+      global_config = Amp::AmpConfig.new
+      Amp::UI.config = global_config
+      cmd = ARGV.shift # get the subcommand
+      cmd ||= "default"
+      
+      opts_as_arr = ARGV.dup
+      
+      if global_opts[:debug_opts]
+        global_config["debug", "messages"] = true
+      end
+      
+      unless global_config["amp"]["workflow"]
+        global_config["amp"]["workflow"] = :hg
+        global_config.save! rescue Errno::EACCES
+      end
+      
+      # the options to send to the command
+      cmd_opts = {}
+      
+      # Load the repository
+      #path_to_repo = find_repo(".", cmd_opts) unless global_opts[:repository]
+      path_to_repo = ""
+      
+      if path_to_repo.empty?
+        local_config = global_config
+      else
+        local_config = AmpConfig.new(:parent_config => global_config)
+        local_config.read_file File.join(path_to_repo, ".hg", "hgrc")
+      end
+      
+      begin
+        cmd_opts[:repository] = Repositories.pick(local_config, global_opts[:repository])
+      rescue
+        unless Command::NO_REPO_ALLOWED[cmd] || Command::MAYBE_REPO_ALLOWED[cmd]
+          raise
+        end
+      end
+      
+      if cmd_opts[:repository].respond_to? :config
+        cmd_opts[:repository].config && local_config = cmd_opts[:repository].config
+      end
+      
+      workflow = local_config["amp"]["workflow"]
+      
+      if File.exists?(File.expand_path(File.join(File.dirname(__FILE__), "commands/workflows/#{workflow}/")))
+        require_dir { "amp/commands/commands/workflows/#{workflow}/**/*.rb" }
+      end
+      
+      user_amprc = File.expand_path("~/.amprc")
+      File.exist?(user_amprc) && load(user_amprc)  
+
+      path_to_ampfile = find_ampfile
+      load path_to_ampfile if path_to_ampfile
+      
+      command = pick_command cmd, local_config
+      
+      unless command
+        puts "Invalid command! #{cmd}"
+        exit(-1)
+      end
+      
+      # get the sub-command's options
+      # if there's a conflict, check to see that the newest value isn't nil
+      cmd_opts.merge!(command.collect_options) {|k, v1, v2| v2 || v1 }
+      
+      cmd_opts[:global_config] = local_config
+      if global_opts[:debug_opts]
+        require 'yaml'
+        puts "Current directory: #{Dir.pwd}"
+        puts "Global options: \n#{global_opts.inspect.to_yaml}"
+        puts "Subcommand: #{cmd.inspect}"
+        puts "Subcommand options: \n#{cmd_opts.to_yaml}"
+        puts "Remaining arguments: #{ARGV.inspect}"
+        puts "\n"
+        puts "Parsed and merged global config files:"
+        puts local_config.config.to_s
+        puts
+      end
+      
+      # Run that fucker!!!
+      begin
+        full_backtrace_please do
+          command.run cmd_opts, ARGV
+        end
+      rescue AbortError => e
+        puts e.to_s
+      end
+      
+      #Amp::Support::Logger.outdent.info("</#{command.name}>")
+    end
+    
+    ##
+    # Gets the path to the Ampfile if there is one.
+    #
+    # @return [String] the path to an Ampfile
+    def self.find_ampfile(dir=Dir.pwd)
+      rock_bottom = false
+      begin
+        rock_bottom = true if dir == "/" 
+        ["ampfile","Ampfile","ampfile.rb","Ampfile.rb"].each do |pos|
+          file = File.join(dir, pos)
+          return file if File.exist? file
+        end
+        dir = File.dirname(dir)
+      end until rock_bottom
+    end
+    
+    ##
+    # Picks a command from the list of all possible commands, based on a couple
+    # simple rules.
+    #
+    # 1. Look up the command by exact name. If no command is provided, supply "default".
+    # 2. Check for "synonyms" - "remove" is synonym'd as "rm". This check occurs inside
+    #   the call to Amp::Command[].
+    # 3. Check to see if there is only 1 command with our "cmd" as the prefix. For example,
+    #   if the user inputs "amp stat", and only one command starts with "stat" (ie "status"),
+    #   then return that command. If there is more than 1 match, then exit, showing an error
+    #   due to the ambiguity.
+    #
+    # @param [String] cmd the command to look up
+    # @return [Amp::Command] the command object that was found, or nil if none was found.
+    def self.pick_command(cmd, config)  
+      my_flow = config["amp"]["workflow"]
+      if c = Amp::Command.all_for_workflow(my_flow).keys.map {|k| k.to_s}.abbrev[cmd]
+        Amp::Command.command_for_workflow(c, my_flow)
+      else
+        prefix_list = Amp::Command.all_for_workflow(my_flow).keys.map {|k| k.to_s}.select {|k| k.start_with? cmd.to_s }
+        
+        if prefix_list.size > 1
+          puts "Ambiguous command: #{cmd}. Could mean: #{prefix_list.join(", ")}"
+          exit(-1)
+        end
+        nil
+      end
+    end
+
+  end
+end

data/lib/amp/commands/hooks.rb

@@ -0,0 +1,81 @@
+module Amp
+  
+  ##
+  # = Hook
+  # The hook class allows the end-user to easily provide hooks into the code that
+  # makes Amp go. For example, one might want to easily hook into the commit command,
+  # and send an e-mail out to your team after every commit. You could use the Hook class,
+  # as well as the Kernel-level "hook" method, to do this.
+  #
+  # Hooks are global, currently - they cannot only be applied to one repo at a time.
+  class Hook
+    @@all_hooks = Hash.new {|h, k| h[k] = []}
+    def self.all_hooks; @@all_hooks; end
+    
+    class << self
+      
+      raise "hell" if defined? DEFAULTS
+      DEFAULTS = {:throw => false}
+    
+      ##
+      # Call the hooks that run under +call+
+      # 
+      # @param [Symbol] call the location in the system where the hooks
+      #   are to be called
+      # @param [Hash] opts the options to pass to the hook
+      def run_hook(call, opts={})
+        opts = DEFAULTS.merge opts
+        all_hooks[call].each {|hook| hook[opts] }
+      end
+    end
+    
+    ##
+    # The call symbol this hook is associated with
+    attr_accessor :name
+    
+    ##
+    # The block to be executed when the hook is called
+    attr_accessor :block
+    
+    ##
+    # Registers a hook with the system. A hook is simply a proc that takes some
+    # options. The hook has a name, which specifies which action it is hooking into.
+    # Some hooks include:
+    #   :outgoing
+    #   :prechangegroup
+    #   :changegroup
+    #
+    # @param [Symbol] hook_type the type of hook
+    # @yield the given block is the action to take when the hook is executed
+    # @yieldparam opts the options that are passed to the hook. See hook.rb for details
+    #   on all possible hooks and their passed-in options.
+    def initialize(name, &block)
+      @name  = name
+      @block = block
+      @@all_hooks[name] << self
+    end
+    
+    ##
+    # Runs the hook.
+    #
+    # @param [Hash] opts the options to pass to the hook.
+    def call(opts)
+      @block.call(opts)
+    end
+    alias_method :run, :call
+    alias_method :[],  :call
+  end
+end
+
+module Kernel
+  
+  ##
+  # Adds a hook to each of the provided hook entry points.
+  # Requires a block.
+  # 
+  # @param [Symbol] names the hook entry points for which to add the block as a hook
+  # @yield The block provided is the code that will be run as a hook at a later time.
+  def hook(names, &block)
+    Amp::Hook.new(names, &block)
+  end
+end