delano-drydock 0.3.0 → 0.3.1

data/CHANGES.txt

@@ -0,0 +1,16 @@
+DRYDOCK, CHANGES
+
+#### 0.3 (2009-02-05) ###############################
+
+* Added support for custom Drydock::Commands objects
+* Global and command-specific options are now available as 
+  attributes of the Drydock::Commands class instance.
+* Automatic execution
+* Now in a single file (lib/drydock.rb)
+* Started adding tests
+* Improved documentation
+
+#### 0.2 (2008-12-27) ###############################
+
+* Initial release
+* Forked from bmizerany/frylock

data/README.rdoc

@@ -1,56 +1,69 @@
-= Drydock - Easy Command line apps
+= Drydock - v0.3
 
-Inspired by "github-gem":http://github.com/defunkt/github-gem
-
-Inspired by "bmizerany-frylock":http://github.com/bmizerany/frylock/tree
+Inspired by github-gem and bmizerany-frylock.
 
 == Overview
 
-Drydock is a DSL for command line apps.
+Drydock is a seaworthy DSL for command line apps. It is contained in a single .rb which can be copied directly into your project. 
 
 == Install
 
-git clone git://github.com/delano/drydock.git
+One of:
+
+* gem install drydock
+* copy lib/drydock.rb into your lib directory. 
 
+Or for GitHub fans:
+
+* git clone git://github.com/delano/drydock.git
+* gem install delano-drydock
 
 == Examples
 
 See bin/example for more. 
 
-<pre><code>
-require 'rubygems'
-require 'drydock'
+	require 'rubygems'
+	require 'drydock'
 
-default :welcome
+	default :welcome
 
-before do
-# You can execute a block before the requests command is executed. Instance
-# variables defined here will be available to all commands.
-end
+	before do
+	# You can execute a block before the requests command is executed. Instance
+	# variables defined here will be available to all commands.
+	end
 
-command :welcome do
-# Example: ruby bin/example
+	command :welcome do
+	# Example: ruby bin/example
 
-  puts "Meatwad: Science is a mystery to man, isn't it Frylock?"
-  print "Frylock: At least we have some commands: "
+	  puts "Meatwad: Science is a mystery to man, isn't it Frylock?"
+	  print "Frylock: At least we have some commands: "
   
-  # The commands method returns a hash of Frylock::Command objects
-  puts commands.keys.inject([]) { |list, command| list << command.to_s }.sort.join(', ')
-end
-
-option :f, :found, "A boolean value. Did you find the car?"
-command :findcar do |options|
-# +options+ is a hash containing the options defined above
-# Example: ruby bin/example -f findcar
+	  # The commands method returns a hash of Frylock::Command objects
+	  puts commands.keys.inject([]) { |list, command| list << command.to_s }.sort.join(', ')
+	end
+
+	option :f, :found, "A boolean value. Did you find the car?"
+	command :findcar do |options|
+	# +options+ is a hash containing the options defined above
+	# Example: ruby bin/example -f findcar
   
-  puts "Frylock: So, did they ever find your car?"
+	  puts "Frylock: So, did they ever find your car?"
   
-  # The keys to the hash are the long string from the option definition.
-  # If only the short string is provided, those will be used instead (i.e. :f). 
-  puts (!options[:found]) ? "Carl: No" : 
-    "Carl: Oh, they found part of it, hangin' from a trestle near the turnpike."
-end
-</code></pre>
+	  # The keys to the hash are the long string from the option definition.
+	  # If only the short string is provided, those will be used instead (i.e. :f). 
+	  puts (!options[:found]) ? "Carl: No" : 
+	    "Carl: Oh, they found part of it, hangin' from a trestle near the turnpike."
+	end
+
+== More Information
+
+http://www.youtube.com/watch?v=m_wFEB4Oxlo
+
+== Credits
+
+* Delano Mandelbaum (delano@solutious.com)
+* Bernie Kopell (bernie@solutious.com)
+
 
 == License
 

data/Rakefile

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'hanna/rdoctask'
+require 'fileutils'
+include FileUtils
+ 
+task :default => :test
+ 
+# SPECS ===============================================================
+ 
+desc 'Run specs with unit test style output'
+task :test do |t|
+  sh "ruby tests/*_test.rb"
+end
+
+# PACKAGE =============================================================
+
+
+require File.dirname(__FILE__) + "/lib/drydock"
+load "drydock.gemspec"
+
+version = Drydock::VERSION.to_s
+
+Drydock.run = false
+
+Rake::GemPackageTask.new(@spec) do |p|
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :release => [ :rdoc, :package ]
+
+task :install => [ :rdoc, :package ] do
+	sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{name}}
+end
+
+
+# Rubyforge Release / Publish Tasks ==================================
+
+desc 'Publish website to rubyforge'
+task 'publish:doc' => 'doc/index.html' do
+  sh 'scp -rp doc/* rubyforge.org:/var/www/gforge-projects/drydock/'
+end
+puts "rubyforge add_release drydock drydock #{@spec.version} pkg/drydock-#{@spec.version}.gem "
+task 'publish:gem' => [:package] do |t|
+  sh <<-end
+    rubyforge add_release -o Any -a CHANGES.txt -f -n README.rdoc drydock drydock #{@spec.version} pkg/drydock-#{@spec.version}.gem &&
+    rubyforge add_file -o Any -a CHANGES.txt -f -n README.rdoc drydock drydock #{@spec.version} pkg/drydock-#{@spec.version}.tgz 
+  end
+end
+
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'doc'
+	t.title    = "Drydock, A seaworthy DSL for command-line apps."
+	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('LICENSE.txt')
+	t.rdoc_files.include('README.rdoc')
+	t.rdoc_files.include('CHANGES.txt')
+	t.rdoc_files.include('bin/*')
+	t.rdoc_files.include('lib/*.rb')
+end
+
+CLEAN.include [ 'pkg', '*.gem', '.config', 'doc' ]
+
+
+

data/bin/example

@@ -1,19 +1,19 @@
 #!/usr/bin/env ruby
 
-DRYDOCK_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-$: << File.join(DRYDOCK_HOME, 'lib')
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..')), 'lib'
 
-require 'rubygems'
 require 'drydock'
 
 default :welcome
 
-
 before do
 # You can execute a block before the requests command is executed. Instance
 # variables defined here will be available to all commands.
 end
 
+after do
+# And this will be called after the command. 
+end
 
 command :welcome do
 # Example: ruby bin/example
@@ -27,15 +27,15 @@ end
 
 
 option :f, :found, "A boolean value. Did you find the car?"
-command :findcar do |options|
-# +options+ is a hash containing the options defined above
+command :findcar do |obj|
+# +obj+ is the Drylock::Command object instance. It contains accessors for all options.
 # Example: ruby bin/example -f findcar
   
   puts "Frylock: So, did they ever find your car?"
   
   # The keys to the hash are the long string from the option definition.
   # If only the short string is provided, those will be used instead (i.e. :f). 
-  puts (!options[:found]) ? "Carl: No" : 
+  puts (!obj.found) ? "Carl: No" : 
     "Carl: Oh, they found part of it, hangin' from a trestle near the turnpike."
 end
 
@@ -51,17 +51,28 @@ global_option :v, :verbose, "Verbosity level (i.e. -vvv is greater than -v)" do
 end
 
 
-usage "ruby bin/example [--seconds] [-vv] time"
-command :date do |options, argv, global_options| 
-# +argv+ contains the unnamed arguments
-# +global_options+ contains hash of the options defined with global_options
-  
+usage "#{$0} [-s] [-vv] date"
+command :date do |obj, argv| 
+# +argv+ is an array containing the unnamed arguments
   require 'time'
   now = Time.now
-  puts "More verbosely, the date is now: " if (global_options[:verbose] || 0) >= 2
-  puts (global_options[:seconds]) ? now.to_i : now.to_s
+  puts "(Not verbose enough. Try adding a -v.)" if (obj.verbose || 0) == 1
+  puts "More verbosely, the date is now: " if (obj.verbose || 0) >= 2
+  puts (obj.seconds) ? now.to_i : now.to_s
 end
 
+usage "#{$0} rogue"
+ignore :options
+command :rogue do |obj, argv|
+# You can use ignore :options to tell Drydock to not process the 
+# command-specific options. 
+  if argv.empty?
+    puts "Had you supplied some arguments, I would have ignored them."
+  else
+    puts "Hi! You supplied some arguments but I ignored them."
+    puts "They're all still here in this array: %s" % argv.join(', ')
+  end
+end
 
 option :c, :check, "Check response codes for each URI"
 option :d, :delim, String, "Output delimiter"
@@ -73,31 +84,31 @@ option :t, :timeout, Float, "Timeout value for HTTP request" do |v|
 end
 
 usage 'echo "http://github.com/" | ruby bin/example process -c -d " " -t 15 http://solutious.com/'
-command :processuris do |options, argv, global_options, stdin, cmd|
-# +stdin+ is either an IO object or a custom object defined with a stdin block (see below)
+command :processuri do |obj, argv, stdin|
 # +cmd+ is the string used to evoke this command. Useful with alias_command (see below).
+# +stdin+ is either an IO object or a custom object defined with a stdin block (see below)
 
   require 'net/http'
   require 'uri'
   require 'timeout'
   
   uris = [stdin, argv].flatten        # Combine the argv and stdin arrays
-  delim = options[:delim] || ','
-  timeout = options[:timeout] || 5
+  delim = obj.delim || ','
+  timeout = obj.timeout || 5
   code = :notchecked                  # The default code when :check is false
   
   if uris.empty?
     puts "Frylock: You didn't provide any URIs. "
-    puts "Master Shake: Ya, see #{$0} #{cmd} -h"
+    puts "Master Shake: Ya, see #{$0} #{obj.alias} -h"
     exit 0
   end
   
   uris.each_with_index do |uri, index|
-    code = response_code(uri, timeout) if (options[:check])
+    code = response_code(uri, timeout) if (obj.check)
     puts [index+1, uri, code].join(delim)
   end
 end
-alias_command :process, :processuris
+alias_command :checkuri, :processuri
 
 
 
@@ -139,32 +150,3 @@ def response_code(uri_str, duration=5)
   response
 end
 
-
-at_exit do
-# This is an example of how to call Frylock in your script. 
-  begin    
-    Drydock.run!(ARGV, STDIN) 
-    
-  rescue Drydock::UnknownCommand => ex
-    STDERR.puts "Frylock: I don't know what the #{ex.name} command is. #{$/}"
-    STDERR.puts "Master Shake: I'll tell you what it is, friends... it's shut up and let me eat it."
-    
-  rescue Drydock::NoCommandsDefined => ex
-    STDERR.puts "Frylock: Carl, I don't want it. And I'd appreciate it if you'd define at least one command. #{$/}"
-    STDERR.puts "Carl: Fryman, don't be that way! This sorta thing happens every day! People just don't... you know, talk about it this loud."
-  
-  rescue Drydock::InvalidArgument => ex
-    STDERR.puts "Frylock: Shake, how many arguments have you not provided a value for this year? #{$/}"
-    STDERR.puts "Master Shake: A *lot* more than *you* have! (#{@args.join(', ')})"
-  
-  rescue Drydock::MissingArgument => ex
-    STDERR.puts "Frylock: I don't know what #{ex.args.join(', ')} is. #{$/}"
-    STDERR.puts "Master Shake: I'll tell you what it is, friends... it's shut up and let me eat it."
-  
-  rescue => ex
-    STDERR.puts "Master Shake: Okay, but when we go in, watch your step. "
-    STDERR.puts "Frylock: Why?"
-    STDERR.puts "Meatwad: [explosion] #{ex.message}"
-    STDERR.puts ex.backtrace
-  end
-end

data/drydock.gemspec

@@ -0,0 +1,53 @@
+@spec = Gem::Specification.new do |s|
+  s.name = %q{drydock}
+  s.version = "0.3.1"
+  s.specification_version = 1 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  s.authors = ["Delano Mandelbaum"]
+  s.date = %q{2008-08-17}
+  s.description = %q{A seaworthy DSL for writing command line apps inspired by Blake Mizerany's Frylock}
+  s.email = %q{delano@solutious.com}
+  s.files = %w(
+    CHANGES.txt
+    LICENSE.txt
+    README.rdoc
+    Rakefile
+    bin/example
+    drydock.gemspec
+    lib/drydock.rb
+    test/command_test.rb
+    doc
+    doc/classes
+    doc/classes/Drydock
+    doc/classes/Drydock/Command.html
+    doc/classes/Drydock/InvalidArgument.html
+    doc/classes/Drydock/MissingArgument.html
+    doc/classes/Drydock/NoCommandsDefined.html
+    doc/classes/Drydock/UnknownCommand.html
+    doc/classes/Drydock.html
+    doc/created.rid
+    doc/files
+    doc/files/bin
+    doc/files/bin/example.html
+    doc/files/CHANGES_txt.html
+    doc/files/lib
+    doc/files/lib/drydock_rb.html
+    doc/files/LICENSE_txt.html
+    doc/files/README_rdoc.html
+    doc/fr_class_index.html
+    doc/fr_file_index.html
+    doc/fr_method_index.html
+    doc/index.html
+    doc/rdoc-style.css
+  )
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/delano/drydock}
+  s.extra_rdoc_files = %w[README.rdoc LICENSE.txt CHANGES.txt]
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Drydock: a seaworthy DSL for command-line apps", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.1.1}
+  s.summary = %q{A seaworthy DSL for writing command line apps}
+  
+  s.rubyforge_project = "drydock"
+end

data/lib/drydock.rb

@@ -1,133 +1,368 @@
 require 'optparse'
 require 'ostruct'
-require 'pp'
-
-require 'drydock/exceptions'
 
+#
+#
 module Drydock
+  # The base class for all command objects. There is an instance of this class
+  # for every command defined. Global and command-specific options are added
+  # as attributes to this class dynamically. 
+  # 
+  # i.e. "example -v date -f yaml"
+  #
+  #     global_option :v, :verbose, "I want mooooore!"
+  #     option :f, :format, String, "Long date format"
+  #     command :date do |obj|
+  #         puts obj.verbose  #=> true
+  #         puts obj.format  #=> "yaml"
+  #     end
+  #
+  # You can inherit from this class to create your own: EatFood < Drydock::Command.
+  # And then specific your class in the command definition:
+  #
+  #     command :eat => EatFood do |obj|; ...; end
+  #
   class Command
-    attr_reader :cmd, :index
-    def initialize(cmd, index, &b)
-      @cmd = (cmd.kind_of?(Symbol)) ? cmd.to_s : cmd
-      @index = index
+    attr_reader :cmd, :alias
+    # +cmd+ is the short name of this command.
+    # +b+ is the block associated to this command.
+    def initialize(cmd, &b)
+      @cmd = (cmd.kind_of?(Symbol)) ? cmd : cmd.to_sym
       @b = b
     end
     
-    def call(cmd_str, argv, stdin, global_options, options)
-      block_args = [options, argv, global_options, stdin, cmd_str, self]
-      @b.call(*block_args[0..(@b.arity-1)])
+    # Execute the block.
+    # 
+    # +cmd_str+ is the short name used to evoke this command. It will equal @cmd
+    # unless an alias was used used to evoke this command.
+    # +argv+ an array of unnamed arguments. If ignore :options was declared this
+    # will contain the arguments exactly as they were defined on the command-line.
+    # +stdin+ contains the output of stdin do; ...; end otherwise it's a STDIN IO handle.
+    # +global_options+ a hash of the global options specified on the command-line
+    # +options+ a hash of the command-specific options specific on the command-line.
+    def call(cmd_str=nil, argv=[], stdin=[], global_options={}, options={})
+      @alias = cmd_str.nil? ? @cmd : cmd_str
+      global_options.merge(options).each_pair do |n,v|
+        self.send("#{n}=", v)
+      end
+      block_args = [self, argv, stdin] # TODO: review order
+      @b.call(*block_args[0..(@b.arity-1)]) # send only as many args as defined
     end
+    
+    # The name of the command
     def to_s
       @cmd.to_s
     end
   end
 end
 
+module Drydock
+  class UnknownCommand < RuntimeError
+    attr_reader :name
+    def initialize(name)
+      @name = name || :unknown
+    end
+    def message
+      "Unknown command: #{@name}"
+    end
+  end
+  class NoCommandsDefined < RuntimeError
+    def message
+      "No commands defined"
+    end
+  end
+  class InvalidArgument < RuntimeError
+    attr_accessor :args
+    def initialize(args)
+      @args = args || []
+    end
+    def message
+      "Unknown option: #{@args.join(", ")}"
+    end
+  end
+  class MissingArgument < InvalidArgument
+    def message
+      "Option requires a value: #{@args.join(", ")}"
+    end
+  end
+end
+
+# Drydock is a DSL for command-line apps. 
+# See bin/example for usage examples. 
 module Drydock
   extend self
   
-  FORWARDED_METHODS = %w(command before alias_command global_option global_usage usage option stdin default commands).freeze
+  VERSION = 0.3
+  
+ private
+  # Stolen from Sinatra!
+  def delegate(*args)
+    args.each do |m|
+      eval(<<-end_eval, binding, "(__Drydock__)", __LINE__)
+        def #{m}(*args, &b)
+          Drydock.#{m}(*args, &b)
+        end
+      end_eval
+    end
+  end
+  
+  delegate :before, :after, :alias_command, :commands
+  delegate :global_option, :global_usage, :usage, :command
+  delegate :debug, :option, :stdin, :default, :ignore, :command_alias
+  
+  @@debug = false
+  @@has_run = false
+  @@run = true
+  
+ public
+  # Enable or disable debug output.
+  #
+  #    debug :on
+  #    debug :off
+  #
+  # Calling without :on or :off will toggle the value. 
+  #
+  def debug(toggle=false)
+    if toggle.is_a? Symbol
+      @@debug = true if toggle == :on
+      @@debug = false if toggle == :off
+    else
+      @@debug = (!@@debug)
+    end
+  end
+  # Returns true if debug output is enabled. 
+  def debug?
+    @@debug
+  end
   
+  # Define a default command. 
+  #
+  #     default :task
+  #
   def default(cmd)
-    @default_command = canonize(cmd)
+    @@default_command = canonize(cmd)
   end
   
+  # Define a block for processing STDIN before the command is called. 
+  # The command block receives the return value of this block in a named argument:
+  #
+  #     command :task do |obj, argv, stdin|; ...; end
+  #
+  # If a stdin block isn't defined, +stdin+ above will be the STDIN IO handle. 
   def stdin(&b)
-    @stdin_block = b
+    @@stdin_block = b
   end
+  
+  # Define a block to be called before the command. 
+  # This is useful for opening database connections, etc...
   def before(&b)
-    @before_block = b
+    @@before_block = b
   end
   
-  # global_usage
-  # ex: usage "Usage: frylla [global options] command [command options]"
+  # Define a block to be called after the command. 
+  # This is useful for stopping, closing, etc... the stuff in the before block. 
+  def after(&b)
+    @@after_block = b
+  end
+  
+  # Define the default global usage banner. This is displayed
+  # with "script -h". 
   def global_usage(msg)
-    @global_opts_parser ||= OptionParser.new 
-    @global_options ||= OpenStruct.new
+    @@global_options ||= OpenStruct.new
+    global_opts_parser.banner = "USAGE: #{msg}"
+  end
   
-    @global_opts_parser.banner = msg
+  # Define a command-specific usage banner. This is displayed
+  # with "script command -h"
+  def usage(msg)
+    get_current_option_parser.banner = "USAGE: #{msg}"
   end
   
-
+  # Grab the options parser for the current command or create it if it doesn't exist.
+  def get_current_option_parser
+    @@command_opts_parser ||= []
+    @@command_index ||= 0
+    (@@command_opts_parser[@@command_index] ||= OptionParser.new)
+  end
   
-  # process_arguments
+  # Tell the Drydock parser to ignore something. 
+  # Drydock will currently only listen to you if you tell it to "ignore :options", 
+  # otherwise it will ignore you!
+  # 
+  # +what+ the thing to ignore. When it equals :options Drydock will not parse
+  # the command-specific arguments. It will pass the Command object the list of
+  # arguments. This is useful when you want to parse the arguments in some a way
+  # that's too crazy, dangerous for Drydock to handle automatically.  
+  def ignore(what=:nothing)
+    @@command_opts_parser[@@command_index] = :ignore if what == :options || what == :all
+  end
+  
+  # Define a global option. See +option+ for more info. 
+  def global_option(*args, &b)
+    args.unshift(global_opts_parser)
+    global_option_names << option_parser(args, &b)
+  end
+  
+  # Define a command-specific option. 
+  # 
+  # +args+ is passed directly to OptionParser.on so it can contain anything
+  # that's valid to that method. Some examples:
+  # [:h, :help, "Displays this message"]
+  # [:m, :max, Integer, "Maximum threshold"]
+  # ['-l x,y,z', '--lang=x,y,z', Array, "Requested languages"]
+  # If a class is included, it will tell OptionParser to expect a value 
+  # otherwise it assumes a boolean value.
   #
-  # Split the +argv+ array into global args and command args and 
-  # find the command name. 
-  # i.e. ./script -H push -f (-H is a global arg, push is the command, -f is a command arg)
-  # returns [global_options, cmd, command_options, argv]
-  def process_arguments(argv)
-    global_options = command_options = {}
-    cmd = nil     
+  # All calls to +option+ must come before the command they're associated
+  # to. Example:
+  # 
+  #     option :l, :longname, String, "Description" do; ...; end
+  #     command :task do |obj|; ...; end
+  #
+  # When calling your script with a specific command-line option, the value
+  # is available via obj.longname inside the command block. 
+  #
+  def option(*args, &b)
+    args.unshift(get_current_option_parser)
+    current_command_option_names << option_parser(args, &b)
+  end
+  
+  # Define a command. 
+  # 
+  #     command :task do
+  #       ...
+  #     end
+  # 
+  # A custom command class can be specified using Hash syntax. The class
+  # must inherit from Drydock::Command (class CustomeClass < Drydock::Command)
+  #
+  #     command :task => CustomCommand do
+  #       ...
+  #     end
+  #
+  def command(*cmds, &b)
+    @@command_index ||= 0
+    @@command_opts_parser ||= []
+    @@command_option_names ||= []
+    cmds.each do |cmd| 
+      if cmd.is_a? Hash
+        c = cmd.values.first.new(cmd.keys.first, &b)
+      else
+        c = Drydock::Command.new(cmd, &b)
+      end
+      commands[c.cmd] = c
+      command_index_map[c.cmd] = @@command_index
+      @@command_index += 1
+    end
     
-    global_parser = @global_opts_parser
+  end
+  
+  # Used to create an alias to a defined command. 
+  # Here's an example:
+  #
+  #    command :task do; ...; end
+  #    alias_command :pointer, :task
+  #
+  # Either name can be used on the command-line:
+  #
+  #    $ script task [options]
+  #    $ script pointer [options]
+  #
+  # Inside of the command definition, you have access to the
+  # command name that was used via obj.alias. 
+  def alias_command(aliaz, cmd)
+    return unless commands.has_key? cmd
+    @@commands[aliaz] = commands[cmd]
+  end
+  alias :command_alias :alias_command
+  
+  # An array of the currently defined Drydock::Command objects
+  def commands
+    @@commands ||= {}
+  end
+  
+  # Returns true if automatic execution is enabled. 
+  def run?
+    @@run
+  end
+  
+  # Disable automatic execution (enabled by default)
+  #
+  #     Drydock.run = false
+  def run=(v)
+    @@run = (v == true) ? true : false 
+  end
+  
+  # Return true if a command has been executed.
+  def has_run?
+    @@has_run
+  end
+  
+  # Execute the given command.
+  # By default, Drydock automatically executes itself and provides handlers for known errors.
+  # You can override this functionality by calling +Drydock.run!+ yourself. Drydock
+  # will only call +run!+ once. 
+  def run!(argv=[], stdin=STDIN)
+    return if has_run?
+    @@has_run = true
+    raise NoCommandsDefined.new unless commands
+    @@global_options, cmd_name, @@command_options, argv = process_arguments(argv)
     
-    global_options = global_parser.getopts(argv)
-    global_options = global_options.keys.inject({}) do |hash, key|
-       hash[key.to_sym] = global_options[key]
-       hash
-    end
+    cmd_name ||= default_command
     
-    cmd_name = (argv.empty?) ? @default_command : argv.shift
     raise UnknownCommand.new(cmd_name) unless command?(cmd_name)
     
-    cmd = get_command(cmd_name) 
-    command_parser = @command_opts_parser[cmd.index]
+    stdin = (defined? @@stdin_block) ? @@stdin_block.call(stdin, []) : stdin
+    @@before_block.call if defined? @@before_block
     
-    command_options = command_parser.getopts(argv) if (!argv.empty? && command_parser)
-    command_options = command_options.keys.inject({}) do |hash, key|
-       hash[key.to_sym] = command_options[key]
-       hash
-    end
+    call_command(cmd_name, argv, stdin)
     
-    [global_options, cmd_name, command_options, argv]
+    @@after_block.call if defined? @@after_block
+    
+  rescue OptionParser::InvalidOption => ex
+    raise Drydock::InvalidArgument.new(ex.args)
+  rescue OptionParser::MissingArgument => ex
+    raise Drydock::MissingArgument.new(ex.args)
   end
   
-
+ private 
   
-  def usage(msg)
-    get_current_option_parser.banner = msg
+  # Executes the block associated to +cmd+
+  def call_command(cmd, argv=[], stdin=nil)
+    return unless command?(cmd)
+    get_command(cmd).call(cmd, argv, stdin, @@global_options || {}, @@command_options || {})
   end
   
-  # get_current_option_parser
-  #
-  # Grab the options parser for the current command or create it if it doesn't exist.
-  def get_current_option_parser
-    @command_opts_parser ||= []
-    @command_index ||= 0
-    (@command_opts_parser[@command_index] ||= OptionParser.new)
-  end
+  # Returns the Drydock::Command object with the name +cmd+
+  def get_command(cmd)
+    return unless command?(cmd)
+    @@commands[canonize(cmd)]
+  end 
   
-  def global_option(*args, &b)
-    @global_opts_parser ||= OptionParser.new
-    args.unshift(@global_opts_parser)
-    option_parser(args, &b)
+  # Returns true if a command with the name +cmd+ has been defined. 
+  def command?(cmd)
+    name = canonize(cmd)
+    (@@commands || {}).has_key? name
   end
   
-  def option(*args, &b)
-    args.unshift(get_current_option_parser)
-    option_parser(args, &b)
+  # Canonizes a string to the symbol format for command names
+  def canonize(cmd)
+    return unless cmd
+    return cmd if cmd.kind_of?(Symbol)
+    cmd.tr('-', '_').to_sym
   end
   
-  # option_parser
-  #
   # Processes calls to option and global_option. Symbols are converted into 
-  # OptionParser style strings (:h and :help become '-h' and '--help'). If a 
-  # class is included, it will tell OptionParser to expect a value otherwise
-  # it assumes a boolean value.
-  #
-  # +args+ is passed directly to OptionParser.on so it can contain anything
-  # that's valid to that method. Some examples:
-  # [:h, :help, "Displays this message"]
-  # [:m, :max, Integer, "Maximum threshold"]
-  # ['-l x,y,z', '--lang=x,y,z', Array, "Requested languages"]
+  # OptionParser style strings (:h and :help become '-h' and '--help'). 
   def option_parser(args=[], &b)
     return if args.empty?
     opts_parser = args.shift
     
+    arg_name = ''
     symbol_switches = []
     args.each_with_index do |arg, index|
       if arg.is_a? Symbol
+        arg_name = arg.to_s if arg.to_s.size > arg_name.size
         args[index] = (arg.to_s.length == 1) ? "-#{arg.to_s}" : "--#{arg.to_s}"
         symbol_switches << args[index]
       elsif arg.kind_of?(Class)
@@ -145,88 +380,103 @@ module Drydock
         result = (b.nil?) ? v : b.call(*block_args[0..(b.arity-1)])
       end
     end
-  end
-  
-  def command(*cmds, &b)
-    @command_index ||= 0
-    @command_opts_parser ||= []
-    cmds.each do |cmd| 
-      c = Command.new(cmd, @command_index, &b)
-      (@commands ||= {})[cmd] = c
-    end
     
-    @command_index += 1
+    arg_name
   end
   
-  def alias_command(aliaz, cmd)
-    return unless @commands.has_key? cmd
-    @commands[aliaz] = @commands[cmd]
-  end
   
-  def run!(argv, stdin=nil)
-    raise NoCommandsDefined.new unless @commands
-    @global_options, cmd_name, @command_options, argv = process_arguments(argv)
-    
-    cmd_name ||= @default_command
+  # Split the +argv+ array into global args and command args and 
+  # find the command name. 
+  # i.e. ./script -H push -f (-H is a global arg, push is the command, -f is a command arg)
+  # returns [global_options, cmd, command_options, argv]
+  def process_arguments(argv=[])
+    global_options = command_options = {}
+    cmd = nil     
     
+    global_options = global_opts_parser.getopts(argv)
+          
+    cmd_name = (argv.empty?) ? @@default_command : argv.shift
     raise UnknownCommand.new(cmd_name) unless command?(cmd_name)
     
-    stdin = (defined? @stdin_block) ? @stdin_block.call(stdin, []) : stdin
-    @before_block.call if defined? @before_block
+    cmd = get_command(cmd_name) 
     
+    command_parser = @@command_opts_parser[get_command_index(cmd_name)]
+    command_options = {}
     
-    call_command(cmd_name, argv, stdin)
+    # We only need to parse the options out of the arguments when
+    # there are args available, there is a valid parser, and 
+    # we weren't requested to ignore the options. 
+    if !argv.empty? && command_parser && command_parser != :ignore
+      command_options = command_parser.getopts(argv)
+    end
     
+    # Add accessors to the Drydock::Command object 
+    # for the global and command specific options
+    [global_option_names, (command_option_names[get_command_index(cmd_name)] || [])].flatten.each do |n|
+      unless cmd.respond_to?(n)
+        cmd.class.send(:define_method, n) do
+          instance_variable_get("@#{n}")
+        end
+      end
+      unless cmd.respond_to?("#{n}=")
+        cmd.class.send(:define_method, "#{n}=") do |val|
+          instance_variable_set("@#{n}", val)
+        end
+      end
+    end
     
-  rescue OptionParser::InvalidOption => ex
-    raise Drydock::InvalidArgument.new(ex.args)
-  rescue OptionParser::MissingArgument => ex
-    raise Drydock::MissingArgument.new(ex.args)
+    [global_options, cmd_name, command_options, argv]
   end
   
-  
-  def call_command(cmd_str, argv=[], stdin=nil)
-    return unless command?(cmd_str)
-    get_command(cmd_str).call(cmd_str, argv, stdin, @global_options, @command_options)
+  def global_option_names
+    @@global_option_names ||= []
   end
   
-  def get_command(cmd)
-    return unless command?(cmd)
-    @commands[canonize(cmd)]
-  end 
+  # Grab the current list of command-specific option names. This is a list of the
+  # long names. 
+  def current_command_option_names
+    @@command_option_names ||= []
+    @@command_index ||= 0
+    (@@command_option_names[@@command_index] ||= [])
+  end
   
-  def commands
-    @commands
+  def command_index_map
+    @@command_index_map ||= {}
   end
   
-  def run
-    @run || true
+  def get_command_index(cmd)
+    command_index_map[canonize(cmd)] || -1
   end
   
-  def run=(v)
-    @run = v
+  def command_option_names
+    @@command_option_names ||= []
   end
   
-  def command?(cmd)
-    name = canonize(cmd)
-    (@commands || {}).has_key? name
+  def global_opts_parser
+    @@global_opts_parser ||= OptionParser.new
   end
-  def canonize(cmd)
-    return unless cmd
-    return cmd if cmd.kind_of?(Symbol)
-    cmd.tr('-', '_').to_sym
+  
+  def default_command
+    @@default_command ||= nil
   end
   
 end
 
-Drydock::FORWARDED_METHODS.each do |m|
-  eval(<<-end_eval, binding, "(Drydock)", __LINE__)
-    def #{m}(*args, &b)
-      Drydock.#{m}(*args, &b)
-    end
-  end_eval
+include Drydock
+
+trap ("SIGINT") do
+  puts "#{$/}Exiting..."
+  exit 1
 end
 
 
+at_exit {
+  begin
+    Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+  rescue => ex
+    STDERR.puts "ERROR: #{ex.message}"
+    STDERR.puts ex.backtrace if Drydock.debug?
+  end
+}
 
   

data/test/command_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + "/../lib/drydock"
+require "rubygems"
+require "test/spec"
+require "mocha"
+
+class Test::Unit::TestCase
+  def test_command_direct(cmd, argv, &b)
+    Drydock::Command.new(cmd, &b).call(*argv)
+  end
+  def test_command(*args, &b)
+    command(*args, &b)
+  end
+end
+
+class JohnWestSmokedOysters < Drydock::Command; end;
+
+Drydock.run = false
+
+context "command" do
+  
+  setup do 
+    @mock = mock() 
+  end
+  
+  specify "should know a command alias" do
+    @mock.expects(:called).with(:eat_alias)
+    test_command_direct(:eat, [:eat_alias]) { |obj,argv| 
+      @mock.called(obj.alias) 
+    }
+  end
+  
+  specify "should accept a custom command class" do
+    @mock.expects(:called).with(JohnWestSmokedOysters)
+    test_command(:eat => JohnWestSmokedOysters) { |obj,argv| 
+      @mock.called(obj.class) 
+    }
+    Drydock.run!(['eat'])
+  end
+  
+end

metadata

@@ -1,11 +1,10 @@
 --- !ruby/object:Gem::Specification 
 name: delano-drydock
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Delano Mandelbaum
-- Blake Mizerany
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -14,7 +13,7 @@ date: 2008-08-17 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: Command line apps made easy
+description: A seaworthy DSL for writing command line apps inspired by Blake Mizerany's Frylock
 email: delano@solutious.com
 executables: []
 
@@ -23,12 +22,39 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 - LICENSE.txt
+- CHANGES.txt
 files: 
+- CHANGES.txt
 - LICENSE.txt
 - README.rdoc
+- Rakefile
 - bin/example
-- lib/drydock/exceptions.rb
+- drydock.gemspec
 - lib/drydock.rb
+- test/command_test.rb
+- doc
+- doc/classes
+- doc/classes/Drydock
+- doc/classes/Drydock/Command.html
+- doc/classes/Drydock/InvalidArgument.html
+- doc/classes/Drydock/MissingArgument.html
+- doc/classes/Drydock/NoCommandsDefined.html
+- doc/classes/Drydock/UnknownCommand.html
+- doc/classes/Drydock.html
+- doc/created.rid
+- doc/files
+- doc/files/bin
+- doc/files/bin/example.html
+- doc/files/CHANGES_txt.html
+- doc/files/lib
+- doc/files/lib/drydock_rb.html
+- doc/files/LICENSE_txt.html
+- doc/files/README_rdoc.html
+- doc/fr_class_index.html
+- doc/fr_file_index.html
+- doc/fr_method_index.html
+- doc/index.html
+- doc/rdoc-style.css
 has_rdoc: true
 homepage: http://github.com/delano/drydock
 post_install_message: 
@@ -36,7 +62,7 @@ rdoc_options:
 - --line-numbers
 - --inline-source
 - --title
-- "Drydock: Easy command-line apps"
+- "Drydock: a seaworthy DSL for command-line apps"
 - --main
 - README.rdoc
 require_paths: 
@@ -55,10 +81,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: drydock
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 1
-summary: Command line apps made easy
+summary: A seaworthy DSL for writing command line apps
 test_files: []
 

data/lib/drydock/exceptions.rb

@@ -1,24 +0,0 @@
-module Drylock
-  
-  class UnknownCommand < RuntimeError
-    attr_reader :name
-    def initialize(name)
-      @name = name || :unknown
-    end
-  end
-  
-  class NoCommandsDefined < RuntimeError
-  end
-  
-  class InvalidArgument < RuntimeError
-    attr_accessor :args
-    def initialize(args)
-      # We grab just the name of the argument
-      @args = args || []
-    end
-  end
-  
-  class MissingArgument < InvalidArgument
-  end
-  
-end