excavator 0.0.1

data/lib/excavator/runner.rb

@@ -0,0 +1,107 @@
+require 'excavator'
+module Excavator
+  class Runner
+
+    # Runner specific vars
+    attr_accessor :command_paths
+    attr_accessor :commands
+    attr_reader :current_namespace
+
+    def initialize
+      @namespace = Namespace.new(:default)
+      @current_namespace = @namespace
+    end
+
+    def cwd
+      Excavator.cwd
+    end
+
+    def namespaces
+      @namespaces
+    end
+
+    def namespace
+      @namespace
+    end
+
+    def current_namespace
+      @current_namespace
+    end
+
+    def in_namespace(name)
+      ns = @current_namespace.namespace(name)
+      ns = @current_namespace << Excavator.namespace_class.new(name) unless ns
+      @current_namespace = ns
+      yield
+      @current_namespace = ns.parent
+    end
+
+    def clear_commands!
+      self.commands = {}
+    end
+
+    def run(*args)
+      args.flatten!
+
+      name = args.delete_at(0)
+      load_commands
+
+      if (name.nil? && args.size == 0) || display_help?(name)
+        display_help
+        return
+      end
+
+      command = find_command name
+      command.execute *args
+    end
+
+    def find_command(cmd)
+      *namespaces, command_name = cmd.to_s.split(':').collect {|c| c.to_sym }
+      cur_namespace = current_namespace
+      namespaces.each do |n|
+        cur_namespace = cur_namespace.namespace(n)
+      end
+
+      cur_namespace.command(command_name)
+    end
+
+    def display_help?(command_name)
+      ["-h", "-?", "--help", "help"].include?(command_name)
+    end
+
+    def display_help
+      table_view = Excavator::TableView.new do |t|
+        t.title "#{File.basename($0)} commands:\n"
+        t.header "Command"
+        t.header "Description"
+        t.divider "\t"
+
+        namespace.commands_and_descriptions.sort.each do |command|
+          t.record *command
+        end
+      end
+
+      puts table_view
+    end
+
+    def load_commands
+      command_paths.each do |path|
+        Dir["#{path.to_s}/**/*.rb"].each { |file| load file }
+      end
+    end
+
+    def last_command
+      @last_command ||= Excavator.command_class.new(
+        self, :namespace => current_namespace
+      )
+    end
+
+    def clear_last_command!
+      @last_command = nil
+    end
+
+    def command_paths
+      @command_paths = Excavator.command_paths || [cwd.join("commands")]
+    end
+  end # Runner
+end

data/lib/excavator/table_view.rb

@@ -0,0 +1,90 @@
+require 'excavator'
+module Excavator
+  class TableView
+    class InvalidDataForHeaders < StandardError; end
+
+    DEFAULT_DIVIDER = " | "
+
+    def initialize(options = {})
+      @options = options
+      @_title = ""
+      @_headers = []
+      @_records = []
+      @col_widths = Hash.new { |hash, key| hash[key] = 0 }
+      @divider = options[:divider] || DEFAULT_DIVIDER
+
+      yield self if block_given?
+    end
+
+    def title(t = nil)
+      if t.nil?
+        @_title = t
+      else
+        @_title = t
+      end
+    end
+
+    def header(*headers)
+      headers.flatten!
+
+      headers.each do |h|
+        index = @_headers.size
+        @_headers << h
+        @col_widths[h] = h.to_s.size
+      end
+    end
+
+    def divider(str)
+      @divider = str
+    end
+
+    def record(*args)
+      args.flatten!
+      if args.size != @_headers.size
+        raise InvalidDataForHeaders.new(<<-MSG)
+          Number of columns for record (#{args.size}) does not match number
+          of headers (#{@_headers.size})
+        MSG
+      end
+      update_column_widths Hash[*@_headers.zip(args).flatten]
+      @_records << args
+    end
+
+    def to_s
+      out = ""
+      out << @_title << "\n" if !@_title.nil? && @_title != ""
+
+      print_headers out
+
+      @_records.each_with_index do |record|
+        record.each_with_index do |val, i|
+          out << column_formats[i] % val
+          out << @divider if i != (record.size - 1)
+        end
+        out << "\n"
+      end
+      out << "\n"
+
+      out
+    end
+
+    def update_column_widths(hash)
+      hash.each do |key, val|
+        @col_widths[key] = val.size if val && val.size > @col_widths[key]
+      end
+    end
+
+    def print_headers(out)
+      @_headers.each_with_index do |h, i|
+        out << column_formats[i] % h
+        out << @divider if i != (@_headers.size - 1)
+      end
+      out << "\n"
+    end
+
+    # Internal
+    def column_formats
+      @col_widths.collect { |h, width| "%-#{width}s" }
+    end
+  end
+end

data/lib/excavator/version.rb

@@ -0,0 +1,3 @@
+module Excavator
+  VERSION = "0.0.1"
+end

data/test/fixtures/commands/test.rb

@@ -0,0 +1,18 @@
+command :test do
+  puts "test command"
+end
+
+desc "A command with an argument"
+param :region, :default => "west"
+command :command_with_arg do
+  puts params[:region]
+end
+
+namespace :first do
+  namespace :second do
+    command :third do
+      puts "third"
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+basedir = Pathname.new(File.dirname(__FILE__)).join("..").expand_path
+$LOAD_PATH.unshift(basedir.join("lib").to_s)
+require 'excavator'
+
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/mock'
+
+require 'ruby-debug'
+Debugger.start
+
+module TestHelpers
+  def basedir
+    Pathname.new(__FILE__).join("..", "..").expand_path
+  end
+end
+
+# I like #context more than #describe
+alias :context :describe
+
+class MiniTest::Spec
+  include TestHelpers
+  class << self
+    # Oh Rails, you have a strangle hold on my conventions ...
+    alias :test :it
+    alias :setup :before
+    alias :teardown :after
+  end
+end
+

data/test/unit/command_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+context "Command" do
+  include Excavator
+
+  setup do
+    Excavator.reset!
+    @runner = Excavator.runner
+  end
+
+  test "execute a command" do
+    cmd = Command.new(@runner, :name => "test", :block => proc { puts "test"})
+    out, error = capture_io do
+      cmd.execute
+    end
+    assert_match /test/, out
+  end
+
+  test "command arguments available in #params" do
+    cmd = Command.new(
+      @runner,
+      :name => "test",
+      :param_definitions => [Param.new(:name)],
+      :block => proc { puts params[:name] }
+    )
+    out, error = capture_io do
+      cmd.execute("--name", "hello, world!")
+    end
+    assert_match /hello, world!/, out
+  end
+
+  test "passing in two named parameters" do
+    cmd = Command.new(
+      @runner,
+      :name => "test",
+      :param_definitions => [Param.new(:arg1), Param.new(:arg2)],
+      :block => proc { puts "#{params[:arg1]}#{params[:arg2]}" }
+    )
+    out, error = capture_io do
+      cmd.execute("--arg1", "1", "--arg2", "2")
+    end
+    assert_match /12/, out
+  end
+
+
+  test "#execute_with_params runs a command's block" do
+    cmd = Command.new(Excavator.runner).tap do |c|
+      c.name = "test"
+      c.add_param(Param.new(:name))
+      c.add_param(Param.new(:server))
+      c.block = Proc.new do
+        [params[:name], params[:server]]
+      end
+    end
+
+    results = cmd.execute_with_params :name => "paydro", :server => "web"
+    assert_equal ["paydro", "web"], results
+  end
+
+  test "#execute_with_params throws error when missing param" do
+    cmd = Command.new(Excavator.runner).tap do |c|
+      c.name = "test"
+      c.add_param(Param.new(:name))
+      c.add_param(Param.new(:server))
+      c.block = Proc.new do
+        [params[:name], params[:server]]
+      end
+    end
+
+    error = assert_raises MissingParamsError do
+      cmd.execute_with_params :name => "paydro"
+    end
+    assert error.params.include?(:server)
+  end
+end # Command
+

data/test/unit/dsl_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+context "DSL command creation and execution" do
+  include Excavator::DSL
+
+  setup do
+    Excavator.reset!
+    @runner = Excavator.runner
+  end
+
+  test "create a command" do
+    refute @runner.find_command("test")
+    cmd = command(:test) { puts "test" }
+    assert cmd = @runner.find_command("test")
+  end
+
+  test "creating command clears out #last_command for a new command" do
+    cmd1 = command(:first) {}
+    refute_equal cmd1.object_id, @runner.last_command.object_id
+  end
+
+  test "adding a description to a command" do
+    desc "test desc"
+    command(:test) {}
+    assert_equal "test desc", @runner.find_command("test").desc
+  end
+
+  test "create a namespaced command" do
+    cmd = nil
+    namespace :outer do
+      cmd = command(:test) { }
+    end
+
+    assert found_cmd = @runner.find_command("outer:test")
+    assert_equal cmd.object_id, found_cmd.object_id
+  end
+
+  test "command has access to it's namespace" do
+    cmd = nil
+    b = nil
+    namespace :a do
+      namespace :b do
+        cmd = command(:inside) {}
+      end
+    end
+    assert_equal :inside, cmd.name
+    assert_equal :b, cmd.namespace.name
+  end
+end

data/test/unit/environment_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+context "Environment" do
+  include Excavator
+  include Excavator::DSL
+
+  setup do
+    Excavator.reset!
+    Excavator.command_paths = [
+      basedir.join("test", "fixtures", "commands")
+    ]
+  end
+
+  test "execute another command" do
+    cmd = command(:first) { execute :second }
+    command(:second) { "called from second" }
+    assert_equal "called from second", cmd.execute
+  end
+
+  test "execute command with params" do
+    cmd = command(:run_another_cmd) do
+      execute :my_name, :name => 'paydro'
+    end
+
+    param :name
+    command(:my_name) { params[:name] }
+
+    assert_equal "paydro", cmd.execute
+  end
+
+end # Environment
+
+context "Environment#modify" do
+  include Excavator
+
+  module OtherCommands
+    def hello
+      "world"
+    end
+  end
+
+  setup do
+    env_class = Class.new(Excavator::Environment)
+    Excavator.environment_class = env_class
+    @class = env_class
+  end
+
+  teardown do
+    Excavator.environment_class = nil
+  end
+
+  test "modify environment with modules" do
+    @class.modify OtherCommands
+    assert_equal "world", @class.new.hello
+  end
+
+  test "modify environment with a block" do
+    @class.modify do
+      include OtherCommands
+    end
+
+    assert_equal "world", @class.new.hello
+  end
+end