excavator 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in excavator.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+

data/bin/excavator

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'excavator'
+Excavator.run(ARGV)

data/excavator.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "excavator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "excavator"
+  s.version     = Excavator::VERSION
+  s.authors     = ["Peter Bui"]
+  s.email       = ["peter@paydrotalks.com"]
+  s.homepage    = ""
+  s.summary     = %q{A scripting framework for *nix systems.}
+  s.description = <<DESC
+Excavator is a scripting framework for writing multi-command executables for the
+unix environment.
+DESC
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "minitest", ">= 2.10.0"
+  s.add_development_dependency "ruby-debug19"
+  s.add_development_dependency "rake"
+end

data/lib/excavator.rb

@@ -0,0 +1,80 @@
+require 'pathname'
+
+module Excavator
+  class ExcavatorError < ::StandardError; end
+
+  class MissingParamsError < ExcavatorError
+    attr_reader :params
+    def initialize(params)
+      @params = params
+      super "Missing parameters: #{params.join(", ")}."
+    end
+  end
+
+  def self.config(name, default)
+    @config   ||= {}
+    @defaults ||= {}
+    @defaults[name.to_sym] = default
+    module_eval <<-MOD, __FILE__, __LINE__  + 1
+      def self.#{name}
+        @config[:#{name}] || @defaults[:#{name}]
+      end
+
+      def self.#{name}=(val)
+        @config[:#{name}] = val
+      end
+    MOD
+  end
+
+  def self.cwd
+    @cwd ||= Pathname.new(Dir.pwd).expand_path
+  end
+
+  def self.reset!
+    self.runner = nil
+  end
+
+  def self.runner
+    @runner ||= runner_class.new
+  end
+
+  def self.runner=(runner)
+    @runner = runner
+  end
+
+  def self.run(params)
+    begin
+      runner.run(params)
+
+    rescue => e
+      $stderr.puts e.message
+      if ENV['DEBUG'] == '1'
+        e.backtrace.each { |line| $stderr.puts line }
+      end
+
+      exit 1
+    end
+  end
+
+end
+
+require 'excavator/version'
+require 'excavator/dsl'
+require 'excavator/namespace'
+require 'excavator/param'
+require 'excavator/param_parser'
+require 'excavator/command'
+require 'excavator/environment'
+require 'excavator/runner'
+require 'excavator/table_view'
+
+module Excavator
+  # Setup defaults classes
+  config :command_paths,      []
+  config :runner_class,       Runner
+  config :namespace_class,    Namespace
+  config :param_parser_class, ParamParser
+  config :param_class,        Param
+  config :command_class,      Command
+  config :environment_class,  Environment
+end

data/lib/excavator/command.rb

@@ -0,0 +1,79 @@
+require 'timeout'
+module Excavator
+  class Command
+    # Descriptors
+    attr_accessor :name, :desc, :namespace
+
+    # Block to run when command is executed
+    attr_accessor :block
+
+    # A list of Param objects
+    attr_reader :param_definitions
+
+    attr_reader :params
+    attr_reader :raw_params
+    attr_reader :unparsed_params
+
+    attr_reader :runner
+
+    def initialize(runner, options = {})
+      @runner            = runner
+      @name              = options[:name]
+      @block             = options[:block]
+      @param_definitions = options[:param_definitions] || []
+      @namespace         = options[:namespace]
+      @param_parser      = options[:param_parser] ||
+                           Excavator.param_parser_class.new
+      @params            = {}
+    end
+
+    def add_param(param)
+      self.param_definitions << param
+    end
+
+    def execute(*inputs)
+      inputs.flatten!
+      parse_params inputs
+      run
+    end
+
+    def execute_with_params(parsed_params = {})
+      parse_params [parsed_params]
+      run
+    end
+
+    protected
+
+    # Internal
+    def run
+      env = Excavator.environment_class.new(
+        :runner          => runner,
+        :params          => params,
+        :unparsed_params => unparsed_params,
+        :raw_params      => raw_params
+      )
+      env.instance_eval(&block)
+    end
+
+    # Internal
+    def parse_params(inputs)
+      build_parser
+      @raw_params = inputs.dup
+      @params = @param_parser.parse!(inputs) if param_definitions.size > 0
+      @unparsed_params = inputs
+    end
+
+    def build_parser
+      return if @parser_built
+      command_name = ""
+      command_name << "#{namespace.full_name}:" if namespace
+      command_name << name.to_s
+      @param_parser.build(
+        :name   => command_name,
+        :desc   => desc,
+        :params => param_definitions
+      )
+      @parser_built = true
+    end
+  end # Command
+end

data/lib/excavator/dsl.rb

@@ -0,0 +1,33 @@
+module Excavator
+  # Needs to depend on the runner
+  module DSL
+    def namespace(name)
+      Excavator.runner.in_namespace(name) do
+        yield
+      end
+    end
+
+    def desc(description)
+      Excavator.runner.last_command.desc = description
+    end
+
+    def param(name, options = {})
+      param = Excavator.param_class.new(name, options)
+      Excavator.runner.last_command.add_param(param)
+    end
+
+    def command(name, &block)
+      cmd = Excavator.runner.last_command
+      cmd.name = name
+      cmd.block = block
+      Excavator.runner.current_namespace << cmd
+      Excavator.runner.clear_last_command!
+      cmd
+    end
+
+  end # DSL
+end # Excavator
+
+self.extend Excavator::DSL
+
+

data/lib/excavator/environment.rb

@@ -0,0 +1,24 @@
+module Excavator
+  class Environment
+
+    def self.modify(*mods, &block)
+      mods.each { |m| include m }
+      instance_eval &block if block
+    end
+
+    attr_reader :runner, :params, :unparsed_params, :raw_params
+
+    def initialize(options = {})
+      @runner          = options[:runner]
+      @params          = options[:params]
+      @raw_params      = options[:raw_params]
+      @unparsed_params = options[:unparsed_params]
+    end
+
+    # Execute another command
+    def execute(command, params = {})
+      command = runner.find_command(command)
+      command.execute(params)
+    end
+  end
+end

data/lib/excavator/namespace.rb

@@ -0,0 +1,56 @@
+module Excavator
+  class Namespace
+    attr_reader :name
+    attr_accessor :parent
+
+    def initialize(name = nil, options = {})
+      @name = name.to_sym if name
+      @namespaces = {}
+      @commands = {}
+    end
+
+    def <<(obj)
+      if self.class === obj
+        obj.parent = self
+        @namespaces[obj.name] = obj
+      else
+        @commands[obj.name] = obj
+      end
+    end
+
+    def command(name)
+      @commands[name.to_sym]
+    end
+
+    def namespace(name)
+      @namespaces[name.to_sym]
+    end
+
+    def full_name(command_name = nil)
+      return "#{command_name}" if parent.nil?
+
+      parts = []
+      parts << parent.full_name if parent.full_name != ""
+      parts << name.to_s
+      parts << command_name.to_s if command_name
+
+      parts.compact.join(":")
+    end
+
+    def commands_and_descriptions
+      items = []
+      @commands.each do |cmd_name, cmd|
+        items << [
+          full_name(cmd_name),
+          cmd.desc
+        ]
+      end
+
+      @namespaces.each do |ns_name, ns|
+        items.push(*ns.commands_and_descriptions)
+      end
+
+      items.sort
+    end
+  end
+end

data/lib/excavator/param.rb

@@ -0,0 +1,25 @@
+module Excavator
+  class Param
+    attr_reader :name
+    attr_reader :default
+    attr_reader :desc
+    attr_accessor :short # Set by the ParamParser
+
+    def initialize(name, options = {})
+      @name     = name
+      @default  = options[:default]
+      @optional = options[:optional]
+      @desc     = options[:desc]
+      @short    = options[:short]
+    end
+
+    def required?
+      !optional?
+    end
+
+    def optional?
+      @default || (@default.nil? && @optional)
+    end
+
+  end # Param
+end

data/lib/excavator/param_parser.rb

@@ -0,0 +1,135 @@
+require 'optparse'
+module Excavator
+  class ParamParser
+
+    attr_accessor :name
+    attr_accessor :banner
+
+    def initialize
+      @parser = OptionParser.new
+      @parsed_params = {}
+      @params = []
+    end
+
+    def build(options = {})
+      @name   = options[:name] if options[:name]
+      @params = options[:params] if options[:params]
+      @desc   = options[:desc] if options[:desc]
+
+      required_params = []
+      optional_params = []
+
+      @parser.banner = @desc
+      @parser.separator ""
+      @parser.separator "USAGE: #{@name} [options]"
+      @params.each do |param|
+        opts = []
+
+        # Long option
+        opts << "--#{param.name}"
+
+        # params require an argument (for now)
+        opts << "=#{param.name.to_s.upcase}"
+
+        # Short option
+        opts << short_switch(param)
+
+        opts << param.desc if param.desc
+        opts << "Defaults to: #{param.default}" if param.default
+
+        opts << Proc.new do |val|
+          @parsed_params[param.name] = val
+        end
+
+        opts.compact!
+
+        if param.required?
+          required_params << opts
+        else
+          optional_params << opts
+        end
+      end
+
+      if required_params.size > 0
+        @parser.separator ""
+        @parser.separator "REQUIRED:"
+        required_params.each { |opts| @parser.on(*opts) }
+      end
+
+      if optional_params.size > 0
+        @parser.separator ""
+        @parser.separator "OPTIONAL:"
+        optional_params.each { |opts| @parser.on(*opts) }
+      end
+
+      @parser.separator ""
+      @parser.on_tail("-h", "--help", "This message.") do
+        puts usage
+        exit 1
+      end
+    end
+
+    def parse!(args)
+      @parsed_params = args.last.is_a?(Hash) ? args.pop : {}
+
+      @parser.parse!(args)
+      set_default_params
+      detect_missing_params!
+
+      @parsed_params
+    end
+
+    def detect_missing_params!
+      missing_params = []
+      @params.each do |p|
+        if p.required? && !@parsed_params.has_key?(p.name)
+          missing_params << p.name
+        end
+      end
+
+      raise MissingParamsError.new(missing_params) if missing_params.size > 0
+    end
+
+    def usage
+      @parser.to_s
+    end
+
+    protected
+
+    def set_default_params
+      @params.each do |param|
+        next unless param.default
+        unless @parsed_params.has_key?(param.name)
+          @parsed_params[param.name] = param.default
+        end
+      end
+    end
+
+    def short_switch(param)
+      # TODO Raise error for params with specified short switches that collide.
+      #      For now, we'll assume the user knows if they have the same
+      #      short switches when specifying them.
+      return "-#{param.short}" if param.short
+
+      param_name = param.name.to_s
+      short = nil
+      param_name.each_char do |c|
+        short = c
+        if @params.detect { |p| p != param && p.short == c }
+          short = nil if c == param_name[-1]
+          next
+        else
+          break
+        end
+      end
+
+      return nil unless short
+
+      # Set the param's short var so that later auto short switch creation
+      # can determine a collision
+      param.short = short
+
+      "-#{short}"
+    end
+  end
+end