delano-drydock 0.3.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Delano Mandelbaum
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,57 @@
+= Drydock - Easy Command line apps
+
+Inspired by "github-gem":http://github.com/defunkt/github-gem
+
+Inspired by "bmizerany-frylock":http://github.com/bmizerany/frylock/tree
+
+== Overview
+
+Drydock is a DSL for command line apps.
+
+== Install
+
+git clone git://github.com/delano/drydock.git
+
+
+== Examples
+
+See bin/example for more. 
+
+<pre><code>
+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
+
+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: "
+  
+  # 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?"
+  
+  # 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>
+
+== License
+
+See LICENSE.txt

data/bin/example

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+
+DRYDOCK_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$: << File.join(DRYDOCK_HOME, '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
+
+
+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: "
+  
+  # The commands method returns a hash of Drydock::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?"
+  
+  # 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
+
+
+
+global_usage "USAGE: #{File.basename($0)} [global options] command [command options]"
+global_option :s, :seconds, "Display values in seconds"
+global_option :v, :verbose, "Verbosity level (i.e. -vvv is greater than -v)" do |v|
+# Use instance variables to maintain values between option blocks. 
+# This will increment for every -v found (i.e. -vvv)
+  @val ||= 0
+  @val += 1
+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
+  
+  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
+end
+
+
+option :c, :check, "Check response codes for each URI"
+option :d, :delim, String, "Output delimiter"
+option :t, :timeout, Float, "Timeout value for HTTP request" do |v|
+  # You can provide an block to process the option value. 
+  # This block must return the final value. 
+  v = 10 if (v > 10)
+  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)
+# +cmd+ is the string used to evoke this command. Useful with alias_command (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
+  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"
+    exit 0
+  end
+  
+  uris.each_with_index do |uri, index|
+    code = response_code(uri, timeout) if (options[:check])
+    puts [index+1, uri, code].join(delim)
+  end
+end
+alias_command :process, :processuris
+
+
+
+
+stdin do |stdin, output|
+# Pre-process STDIN for all commands. This example returns an array of lines. 
+# The command processuris uses this array.
+  
+  # We only want piped data. If this is not included  
+  # execution will wait for input from the user.
+  unless stdin.tty?   
+    
+    while !stdin.eof? do
+      line = stdin.readline
+      line.chomp!
+      (output ||= []) << line
+    end
+    
+  end
+  output
+end
+
+
+
+# response_code
+#
+# return the HTTP response code for the given URI
+# +uri+ A valid HTTP URI
+# +duration+ The timeout threshold (in seconds) for the request. 
+def response_code(uri_str, duration=5)
+  response = :unavailable
+  begin 
+    uri = (uri_str.kind_of? URI::HTTP) ? uri_str : URI.parse(uri_str) 
+    timeout(duration) do
+      response = Net::HTTP.get_response(uri).code
+    end 
+  rescue Exception => ex
+  end
+  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/lib/drydock/exceptions.rb

@@ -0,0 +1,24 @@
+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

data/lib/drydock.rb

@@ -0,0 +1,232 @@
+require 'optparse'
+require 'ostruct'
+require 'pp'
+
+require 'drydock/exceptions'
+
+module Drydock
+  class Command
+    attr_reader :cmd, :index
+    def initialize(cmd, index, &b)
+      @cmd = (cmd.kind_of?(Symbol)) ? cmd.to_s : cmd
+      @index = index
+      @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)])
+    end
+    def to_s
+      @cmd.to_s
+    end
+  end
+end
+
+module Drydock
+  extend self
+  
+  FORWARDED_METHODS = %w(command before alias_command global_option global_usage usage option stdin default commands).freeze
+  
+  def default(cmd)
+    @default_command = canonize(cmd)
+  end
+  
+  def stdin(&b)
+    @stdin_block = b
+  end
+  def before(&b)
+    @before_block = b
+  end
+  
+  # global_usage
+  # ex: usage "Usage: frylla [global options] command [command options]"
+  def global_usage(msg)
+    @global_opts_parser ||= OptionParser.new 
+    @global_options ||= OpenStruct.new
+  
+    @global_opts_parser.banner = msg
+  end
+  
+
+  
+  # process_arguments
+  #
+  # 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_parser = @global_opts_parser
+    
+    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 = (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]
+    
+    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
+    
+    [global_options, cmd_name, command_options, argv]
+  end
+  
+
+  
+  def usage(msg)
+    get_current_option_parser.banner = msg
+  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
+  
+  def global_option(*args, &b)
+    @global_opts_parser ||= OptionParser.new
+    args.unshift(@global_opts_parser)
+    option_parser(args, &b)
+  end
+  
+  def option(*args, &b)
+    args.unshift(get_current_option_parser)
+    option_parser(args, &b)
+  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"]
+  def option_parser(args=[], &b)
+    return if args.empty?
+    opts_parser = args.shift
+    
+    symbol_switches = []
+    args.each_with_index do |arg, index|
+      if arg.is_a? Symbol
+        args[index] = (arg.to_s.length == 1) ? "-#{arg.to_s}" : "--#{arg.to_s}"
+        symbol_switches << args[index]
+      elsif arg.kind_of?(Class)
+        symbol_switches.each do |arg|
+          arg << "=S"
+        end
+      end
+    end
+    
+    if args.size == 1
+      opts_parser.on(args.shift)
+    else
+      opts_parser.on(*args) do |v|
+        block_args = [v, opts_parser]
+        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
+  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
+    
+    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
+    
+    
+    call_command(cmd_name, argv, stdin)
+    
+    
+  rescue OptionParser::InvalidOption => ex
+    raise Drydock::InvalidArgument.new(ex.args)
+  rescue OptionParser::MissingArgument => ex
+    raise Drydock::MissingArgument.new(ex.args)
+  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)
+  end
+  
+  def get_command(cmd)
+    return unless command?(cmd)
+    @commands[canonize(cmd)]
+  end 
+  
+  def commands
+    @commands
+  end
+  
+  def run
+    @run || true
+  end
+  
+  def run=(v)
+    @run = v
+  end
+  
+  def command?(cmd)
+    name = canonize(cmd)
+    (@commands || {}).has_key? name
+  end
+  def canonize(cmd)
+    return unless cmd
+    return cmd if cmd.kind_of?(Symbol)
+    cmd.tr('-', '_').to_sym
+  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
+end
+
+
+
+  

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: delano-drydock
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Delano Mandelbaum
+- Blake Mizerany
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-17 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Command line apps made easy
+email: delano@solutious.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
+files: 
+- LICENSE.txt
+- README.rdoc
+- bin/example
+- lib/drydock/exceptions.rb
+- lib/drydock.rb
+has_rdoc: true
+homepage: http://github.com/delano/drydock
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- "Drydock: Easy command-line apps"
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 1
+summary: Command line apps made easy
+test_files: []
+