clamp 0.0.1 → 0.0.7

data/.gitignore

@@ -3,3 +3,5 @@
 .yardoc
 doc
 pkg/*
+Gemfile.lock
+ 

data/README.markdown

@@ -17,24 +17,165 @@ Yeah, sorry.  There are a bunch of existing command-line parsing libraries out t
 Quick Start
 -----------
 
-Clamp models a command as a Ruby class, and command invocations as instances of that class.
+Clamp models a command as a Ruby class; a subclass of `Clamp::Command`.  They look something like this:
 
-"Command classes" are subclasses of `Clamp::Command`.  They look like this:
+    class SpeakCommand < Clamp::Command
 
-    class InstallCommand < Clamp::Command
+      option "--loud", :flag, "say it loud"
+      option ["-n", "--iterations"], "N", "say it N times", :default => 1 do |s|
+        Integer(s)
+      end
+
+      argument "WORDS ...", "the thing to say"
+      
+      def execute
+
+        signal_usage_error "I have nothing to say" if arguments.empty?
+        the_truth = arguments.join(" ")
+        the_truth.upcase! if loud?
+
+        iterations.times do
+          puts the_truth
+        end
+
+      end
+
+    end
+
+Class-level methods (like `option` and `argument`) are available to declare command-line options, and document usage.  
+
+The command can be invoked by instantiating the class, and asking it to run:
+
+    SpeakCommand.new("speak").run(["--loud", "a", "b", "c"])
+
+but it's more typical to use the class-level "`run`" method:
+
+    SpeakCommand.run
+    
+which takes arguments from `ARGV`, and includes some handy error-handling.
+
+Declaring options
+-----------------
+
+Options are declared using the [`option`](../Clamp/Command.option) method.  The three required arguments are:
+
+  1. the option switch (or switches),
+  2. a short description of the option argument type, and
+  3. a description of the option itself
+
+For example:
+
+    option "--flavour", "FLAVOUR", "ice-cream flavour"
+
+It works a little like `attr_accessor`, defining reader and writer methods on the command class.  The attribute name is derived from the switch (in this case, "`flavour`").  When you pass options to your command, Clamp will populate the attributes, which are then available for use in your `#execute` method.
+
+    def execute
+      puts "You chose #{flavour}.  Excellent choice!"
+    end
+
+If you don't like the inferred attribute name, you can override it:
+
+    option "--type", "TYPE", "type of widget", :attribute_name => :widget_type
+                                               # to avoid clobbering Object#type
+
+### Short/long option switches
+
+The first argument to `option` can be an array, rather than a single string, in which case all the switches are treated as aliases:
+
+    option ["-s", "--subject"], "SUBJECT", "email subject line"
+
+### Flag options
+
+Some options are just boolean flags.  Pass "`:flag`" as the second parameter to tell Clamp not to expect an option argument:
+
+    option "--verbose", :flag, "be chatty"
+
+For flag options, Clamp appends "`?`" to the generated reader method; ie. you get a method called "`verbose?`", rather than just "`verbose`".
+
+Negatable flags are easy to generate, too: 
+
+    option "--[no-]force", :flag, "be forceful (or not)"
+
+Clamp will handle both "`--force`" and "`--no-force`" options, setting the value of "`#force?`" appropriately.
+
+### Validation and conversion of option arguments
+
+If a block is passed to `option`, it will be called with the raw string option argument, and is expected to coerce that String to the correct type, e.g.
+
+    option "--port", "PORT", "port to listen on" do |s|
+      Integer(s)
+    end
+
+If the block raises an ArgumentError, Clamp will catch it, and report that the option value was bad:
+
+    !!!plain
+    ERROR: option '--port': invalid value for Integer: "blah"
+
+Declaring arguments
+-------------------
+
+The `argument` method is used to declare command arguments:
+
+    argument "FILE ...", "source files"
+    argument "DIR", "target directory"
+
+Use of `argument` is entirely for documentation purposes.  Whether or not you declare and describe your expected arguments, the actual arguments that remain after option parsing will be available as `arguments` when your `#execute` method is called.
+
+Sub-commands
+------------
+
+The `subcommand` method declares sub-commands:
+
+    class MainCommand < Clamp::Command
+
+      subcommand "init", "Initialize the repository" do
+
+        def execute
+          # ...
+        end
+
+      end
+      
+    end
+
+Clamp generates an anonymous sub-class of the current class, to represent the sub-command.  Additional options may be declared within subcommand blocks, but all options declared on the parent class are also accepted.
+
+Alternatively, you can provide an explicit sub-command class, rather than a block:
     
-      option "--force", :flag, ""
-        
+    class MainCommand < Clamp::Command
+
+      subcommand "init", "Initialize the repository", InitCommand
+      
+    end
+
+    class InitCommand < Clamp::Command
+
       def execute
-        # do something
+        # ...
       end
-        
+
     end
 
-Class-level methods are available to declare command-line options, and document usage.  
+When a command has sub-commands, Clamp will attempt to delegate based on the first command-line argument, before options are parsed.  Remaining arguments will be passed on to the sub-command.
+
+Getting help
+------------
+
+All Clamp commands support a "`--help`" option, which outputs brief usage documentation, based on those seemingly useless extra parameters that you had to pass to `option` and `argument`.
+
+    $ speak --help
+    Usage:
+        speak [OPTIONS] WORDS ...
+
+    Arguments:
+        WORDS ...                     the thing to say
 
-Clamp commands are invoked like so:
+    Options:
+        --loud                        say it loud
+        -n, --iterations N            say it N times
+        --help                        print help
 
-    InstallCommand.run
+Contributing to Clamp
+---------------------
 
-This will instantiate a new `InstallCommand`, handle command-line args, and finally call the  `#execute` method to do the real work.
+Source-code for Clamp is [on Github](https://github.com/mdub/clamp).  

data/examples/flipflop

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+
+require "clamp"
+
+class FlipFlop < Clamp::Command
+
+  subcommand "flip", "flip it" do
+    def execute
+      puts "FLIPPED"
+    end
+  end
+
+  subcommand "flop", "flop it" do
+    def execute
+      puts "FLOPPED"
+    end
+  end
+  
+end
+
+FlipFlop.run

data/examples/icecream

@@ -0,0 +1,16 @@
+#! /usr/bin/env ruby
+
+require "clamp"
+
+class Icecream < Clamp::Command
+
+  option "--flavour", "FLAVOUR", "ice-cream flavour"
+
+  def execute
+    signal_usage_error "what flavour?" unless flavour
+    puts "You chose #{flavour}.  Excellent choice!"
+  end
+  
+end
+
+Icecream.run

data/examples/rename

@@ -17,8 +17,6 @@ class Rename < Clamp::Command
     n
   end
 
-  help_option
-  
   def initialize(name)
     super
     @times = 1

data/examples/speak

@@ -0,0 +1,28 @@
+#! /usr/bin/env ruby
+
+require "clamp"
+
+class SpeakCommand < Clamp::Command
+
+  option "--loud", :flag, "say it loud"
+  option ["-n", "--iterations"], "N", "say it N times", :default => 1 do |s|
+    Integer(s)
+  end
+
+  argument "WORDS ...", "the thing to say"
+
+  def execute
+
+    signal_usage_error "I have nothing to say" if arguments.empty?
+    the_truth = arguments.join(" ")
+    the_truth.upcase! if loud?
+
+    iterations.times do
+      puts the_truth
+    end
+
+  end
+
+end
+
+SpeakCommand.run

data/lib/clamp/command.rb

@@ -1,17 +1,22 @@
-require 'clamp/argument'
-require 'clamp/option'
+require 'clamp/help_support'
+require 'clamp/option_support'
+require 'clamp/subcommand_support'
 
 module Clamp
-  
+
   class Command
-    
-    def initialize(name)
+
+    def initialize(name, context = {})
       @name = name
+      @context = context
     end
-    
+
     attr_reader :name
     attr_reader :arguments
 
+    attr_accessor :context
+    attr_accessor :parent_command
+
     def parse(arguments)
       while arguments.first =~ /^-/
         case (switch = arguments.shift)
@@ -31,166 +36,110 @@ module Clamp
           rescue ArgumentError => e
             signal_usage_error "option '#{switch}': #{e.message}"
           end
-          
+
         end
       end
       @arguments = arguments
     end
-    
+
+    # default implementation
     def execute
-      raise "you need to define #execute"
+      if self.class.has_subcommands?
+        execute_subcommand
+      else
+        raise "you need to define #execute"
+      end
     end
-    
+
     def run(arguments)
       parse(arguments)
       execute
     end
 
     def help
-      self.class.help.gsub("__COMMAND__", name)
+      self.class.help(name)
     end
-    
+
     private
 
+    def execute_subcommand
+      signal_usage_error "no subcommand specified" if arguments.empty?
+      subcommand_name = arguments.shift
+      subcommand_class = find_subcommand_class(subcommand_name)
+      subcommand = subcommand_class.new("#{name} #{subcommand_name}", context)
+      subcommand.parent_command = self
+      subcommand.run(arguments)
+    end
+
     def find_option(switch)
       self.class.find_option(switch) || 
       signal_usage_error("Unrecognised option '#{switch}'")
     end
 
+    def find_subcommand(name)
+      self.class.find_subcommand(name) || 
+      signal_usage_error("No such sub-command '#{name}'")
+    end
+
+    def find_subcommand_class(name)
+      subcommand = find_subcommand(name)
+      subcommand.subcommand_class if subcommand
+    end
+
     def signal_usage_error(message)
       e = UsageError.new(message, self)
       e.set_backtrace(caller)
       raise e
     end
-    
-    class << self
-    
-      def options
-        @options ||= []
-      end
-      
-      def option(switches, argument_type, description, opts = {}, &block)
-        option = Clamp::Option.new(switches, argument_type, description, opts)
-        self.options << option
-        declare_option_reader(option)
-        declare_option_writer(option, &block)
-      end
-      
-      def help_option(switches = ["-h", "--help"])
-        option(switches, :flag, "print help", :attribute_name => :help_requested) do
-          raise Clamp::HelpWanted.new(self)
-        end
-      end
-        
-      def has_options?
-        !options.empty?
-      end
-      
-      def find_option(switch)
-        options.find { |o| o.handles?(switch) }
-      end
 
-      def usage(usage)
-        @usages ||= []
-        @usages << usage
-      end
+    def help_requested=(value)
+      raise Clamp::HelpWanted.new(self)
+    end
 
-      def arguments
-        @arguments ||= []
-      end
-      
-      def argument(name, description)
-        arguments << Argument.new(name, description)
-      end
+    class << self
 
-      def derived_usage
-        parts = arguments.map { |a| a.name }
-        parts.unshift("[OPTIONS]") if has_options?
-        parts.join(" ")
-      end
-      
-      def help
-        help = StringIO.new
-        help.puts "Usage:"
-        usages = @usages || [derived_usage]
-        usages.each_with_index do |usage, i|
-          help.puts "    __COMMAND__ #{usage}".rstrip
-        end
-        detail_format = "    %-29s %s"
-        unless arguments.empty?
-          help.puts "\nArguments:"
-          arguments.each do |argument|
-            help.puts detail_format % [argument.name, argument.description]
-          end
-        end
-        unless options.empty?
-          help.puts "\nOptions:"
-          options.each do |option|
-            help.puts detail_format % option.help
-          end
-        end
-        help.string
-      end
-      
-      def run(name = $0, args = ARGV)
+      include OptionSupport
+      include SubcommandSupport
+      include HelpSupport
+
+      def run(name = $0, args = ARGV, context = {})
         begin 
-          new(name).run(args)
+          new(name, context).run(args)
         rescue Clamp::UsageError => e
           $stderr.puts "ERROR: #{e.message}"
           $stderr.puts ""
-          $stderr.puts e.command.help
+          $stderr.puts "See: '#{name} --help'"
           exit(1)
         rescue Clamp::HelpWanted => e
           puts e.command.help
         end
       end
 
-      private
-      
-      def declare_option_reader(option)
-        reader_name = option.attribute_name
-        reader_name += "?" if option.flag?
-        class_eval <<-RUBY
-        def #{reader_name}
-          @#{option.attribute_name}
-        end
-        RUBY
-      end
-
-      def declare_option_writer(option, &block)
-        define_method("#{option.attribute_name}=") do |value|
-          if block
-            value = instance_exec(value, &block)
-          end
-          instance_variable_set("@#{option.attribute_name}", value)
-        end
-      end
-      
     end
-        
+
   end
-  
+
   class Error < StandardError
-    
+
     def initialize(message, command)
       super(message)
       @command = command
     end
 
     attr_reader :command
-    
+
   end
 
   # raise to signal incorrect command usage
   class UsageError < Error; end
-  
+
   # raise to request usage help
   class HelpWanted < Error
-    
+
     def initialize(command)
       super("I need help", command)
     end
-    
+
   end
-  
+
 end

data/lib/clamp/help_support.rb

@@ -0,0 +1,69 @@
+module Clamp
+
+  class Argument < Struct.new(:name, :description)
+
+    def help
+      [name, description]
+    end
+
+  end
+
+  module HelpSupport
+
+    def declared_arguments
+      @declared_arguments ||= []
+    end
+
+    def argument(name, description)
+      declared_arguments << Argument.new(name, description)
+    end
+
+    def usage(usage)
+      @declared_usage_descriptions ||= []
+      @declared_usage_descriptions << usage
+    end
+
+    attr_reader :declared_usage_descriptions
+
+    def derived_usage_description
+      parts = declared_arguments.map { |a| a.name }
+      parts.unshift("SUBCOMMAND") if has_subcommands?
+      parts.unshift("[OPTIONS]") if has_options?
+      parts.join(" ")
+    end
+
+    def usage_descriptions
+      declared_usage_descriptions || [derived_usage_description]
+    end
+
+    def help(command_name)
+      help = StringIO.new
+      help.puts "Usage:"
+      usage_descriptions.each_with_index do |usage, i|
+        help.puts "    #{command_name} #{usage}".rstrip
+      end
+      detail_format = "    %-29s %s"
+      unless declared_arguments.empty?
+        help.puts "\nArguments:"
+        declared_arguments.each do |argument|
+          help.puts detail_format % argument.help
+        end
+      end
+      unless recognised_subcommands.empty?
+        help.puts "\nSubcommands:"
+        recognised_subcommands.each do |subcommand|
+          help.puts detail_format % subcommand.help
+        end
+      end
+      if has_options?
+        help.puts "\nOptions:"
+        recognised_options.each do |option|
+          help.puts detail_format % option.help
+        end
+      end
+      help.string
+    end
+
+  end
+
+end

data/lib/clamp/option.rb

@@ -6,10 +6,15 @@ module Clamp
       @switches = Array(switches)
       @argument_type = argument_type
       @description = description
-      @attribute_name = options[:attribute_name].to_s if options.has_key?(:attribute_name)
+      if options.has_key?(:attribute_name)
+        @attribute_name = options[:attribute_name].to_s 
+      end
+      if options.has_key?(:default)
+        @default_value = options[:default]
+      end
     end
 
-    attr_reader :switches, :argument_type, :description
+    attr_reader :switches, :argument_type, :description, :default_value
 
     def attribute_name
       @attribute_name ||= long_switch.sub(/^--(\[no-\])?/, '').tr('-', '_')

data/lib/clamp/option_support.rb

@@ -0,0 +1,75 @@
+require 'clamp/option'
+
+module Clamp
+
+  module OptionSupport
+
+    def option(switches, argument_type, description, opts = {}, &block)
+      option = Clamp::Option.new(switches, argument_type, description, opts)
+      declare_option(option, &block)
+    end
+
+    def has_options?
+      !declared_options.empty?
+    end
+
+    def declared_options
+      my_declared_options + inherited_declared_options
+    end
+
+    def recognised_options
+      declared_options + standard_options
+    end
+
+    def find_option(switch)
+      recognised_options.find { |o| o.handles?(switch) }
+    end
+
+    private
+
+    def my_declared_options
+      @my_declared_options ||= []
+    end
+
+    def declare_option(option, &block)
+      my_declared_options << option
+      declare_option_reader(option)
+      declare_option_writer(option, &block)
+    end
+
+    def inherited_declared_options
+      if superclass.respond_to?(:declared_options)
+        superclass.declared_options
+      else
+        []
+      end
+    end
+
+    HELP_OPTION = Clamp::Option.new("--help", :flag, "print help", :attribute_name => :help_requested)
+
+    def standard_options
+      [HELP_OPTION]
+    end
+
+    def declare_option_reader(option)
+      reader_name = option.attribute_name
+      reader_name += "?" if option.flag?
+      define_method(reader_name) do
+        value = instance_variable_get("@#{option.attribute_name}")
+        value = option.default_value if value.nil?
+        value
+      end
+    end
+
+    def declare_option_writer(option, &block)
+      define_method("#{option.attribute_name}=") do |value|
+        if block
+          value = instance_exec(value, &block)
+        end
+        instance_variable_set("@#{option.attribute_name}", value)
+      end
+    end
+
+  end
+
+end

data/lib/clamp/subcommand_support.rb

@@ -0,0 +1,35 @@
+module Clamp
+
+  class Subcommand < Struct.new(:name, :description, :subcommand_class)
+
+    def help
+      [name, description]
+    end
+
+  end
+
+  module SubcommandSupport
+
+    def recognised_subcommands
+      @recognised_subcommands ||= []
+    end
+
+    def subcommand(name, description, subcommand_class = self, &block)
+      if block
+        # generate a anonymous sub-class
+        subcommand_class = Class.new(subcommand_class, &block)
+      end
+      recognised_subcommands << Subcommand.new(name, description, subcommand_class)
+    end
+
+    def has_subcommands?
+      !recognised_subcommands.empty?
+    end
+
+    def find_subcommand(name)
+      recognised_subcommands.find { |sc| sc.name == name }
+    end
+
+  end
+
+end

data/lib/clamp/version.rb

@@ -1,3 +1,3 @@
 module Clamp
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.7".freeze
 end

data/spec/clamp/command_group_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'stringio'
+
+describe Clamp::Command do
+
+  include OutputCapture
+
+  def self.given_command(name, &block)
+    before do
+      @command = Class.new(Clamp::Command, &block).new(name)
+    end
+  end
+
+  describe "with subcommands" do
+
+    given_command "flipflop" do
+
+      subcommand "flip", "flip it" do
+        def execute
+          puts "FLIPPED"
+        end
+      end
+
+      subcommand "flop", "flop it" do
+        def execute
+          puts "FLOPPED"
+        end
+      end
+
+    end
+
+    it "delegates to sub-commands" do
+
+      @command.run(["flip"])
+      stdout.should =~ /FLIPPED/
+
+      @command.run(["flop"])
+      stdout.should =~ /FLOPPED/
+
+    end
+
+    describe "#help" do
+      
+      it "lists subcommands" do
+        @help = @command.help
+        @help.should =~ /Subcommands:/
+        @help.should =~ /flip +flip it/
+        @help.should =~ /flop +flop it/
+      end
+      
+    end
+    
+  end
+
+  describe "each subcommand" do
+
+    before do
+
+      @command_class = Class.new(Clamp::Command) do
+
+        option "--direction", "DIR", "which way"
+
+        subcommand "walk", "step carefully in the appointed direction" do
+
+          def execute
+            if direction
+              puts "walking #{direction}"
+            else
+              puts "wandering #{context[:default_direction]} by default"
+            end
+          end
+
+        end
+
+      end
+
+      @command = @command_class.new("go", :default_direction => "south")
+
+    end
+
+    it "accepts parents options (specified after the subcommand)" do
+      @command.run(["walk", "--direction", "north"])
+      stdout.should =~ /walking north/
+    end
+
+    it "has access to command context" do
+      @command.run(["walk"])
+      stdout.should =~ /wandering south by default/
+    end
+
+  end
+
+end

data/spec/clamp/command_spec.rb

@@ -3,23 +3,7 @@ require 'stringio'
 
 describe Clamp::Command do
 
-  before do
-    $stdout = @out = StringIO.new
-    $stderr = @err = StringIO.new
-  end
-
-  after do
-    $stdout = STDOUT
-    $stderr = STDERR
-  end
-
-  def stdout
-    @out.string
-  end
-
-  def stderr
-    @err.string
-  end
+  include OutputCapture
 
   def self.given_command(name, &block)
     before do
@@ -81,34 +65,43 @@ describe Clamp::Command do
 
   describe ".option" do
 
-    before do
-      @command.class.option "--flavour", "FLAVOUR", "Flavour of the month"
-    end
-
     it "declares option argument accessors" do
+      @command.class.option "--flavour", "FLAVOUR", "Flavour of the month"
       @command.flavour.should == nil
       @command.flavour = "chocolate"
       @command.flavour.should == "chocolate"
     end
 
-  end
+    describe "with explicit :attribute_name" do
 
-  describe ".option", "with explicit :attribute_name" do
+      before do
+        @command.class.option "--foo", "FOO", "A foo", :attribute_name => :bar
+      end
 
-    before do
-      @command.class.option "--foo", "FOO", "A foo", :attribute_name => :bar
-    end
+      it "uses the specified attribute_name name to name accessors" do
+        @command.bar = "chocolate"
+        @command.bar.should == "chocolate"
+      end
+
+      it "does not attempt to create the default accessors" do
+        @command.should_not respond_to(:foo)
+        @command.should_not respond_to(:foo=)
+      end
 
-    it "uses the specified attribute_name name to name accessors" do
-      @command.bar = "chocolate"
-      @command.bar.should == "chocolate"
     end
 
-    it "does not attempt to create the default accessors" do
-      @command.should_not respond_to(:foo)
-      @command.should_not respond_to(:foo=)
+    describe "with :default value" do
+
+      given_command("cmd") do
+        option "--nodes", "N", "number of nodes", :default => 2
+      end
+
+      it "sets the specified default value" do
+        @command.nodes.should == 2
+      end
+
     end
-    
+
   end
 
   describe "with options declared" do
@@ -329,6 +322,20 @@ describe Clamp::Command do
       stdout.should == @xyz.inspect
     end
 
+    describe "invoked with a context hash" do
+      
+      it "makes the context available within the command" do
+        @command.class.class_eval do
+          def execute
+            print context[:foo]
+          end
+        end
+        @command.class.run("xyz", [], :foo => "bar")
+        stdout.should == "bar"        
+      end
+      
+    end
+    
     describe "when there's a UsageError" do
 
       before do
@@ -352,7 +359,7 @@ describe Clamp::Command do
       end
 
       it "outputs help" do
-        stderr.should include "Usage:"
+        stderr.should include "See: 'cmd --help'"
       end
 
       it "exits with a non-zero status" do
@@ -364,17 +371,8 @@ describe Clamp::Command do
 
     describe "when help is requested" do
 
-      before do
-
-        @command.class.class_eval do
-          help_option "--help"
-        end
-
-        @command.class.run("cmd", ["--help"])
-
-      end
-
       it "outputs help" do
+        @command.class.run("cmd", ["--help"])
         stdout.should include "Usage:"
       end
 
@@ -382,4 +380,23 @@ describe Clamp::Command do
 
   end
 
+  describe "subclass" do
+    
+    before do
+      @parent_command_class = Class.new(Clamp::Command) do
+        option "--verbose", :flag, "be louder"
+      end
+      @derived_command_class = Class.new(@parent_command_class) do
+        option "--iterations", "N", "number of times to go around"
+      end
+      @command = @derived_command_class.new("cmd")
+    end
+    
+    it "inherits options from it's superclass" do
+      @command.parse(["--verbose"])
+      @command.should be_verbose
+    end
+
+  end
+  
 end

data/spec/clamp/option_spec.rb

@@ -33,6 +33,19 @@ describe Clamp::Option do
 
     end
 
+    describe "#default_value" do
+
+      it "defaults to nil" do
+        @option.default_value.should == nil
+      end
+
+      it "can be overridden" do
+        @option = Clamp::Option.new("-n", "N", "iterations", :default => 1)
+        @option.default_value.should == 1
+      end
+
+    end
+
     describe "#help" do
 
       it "combines switch, argument_type and description" do

data/spec/spec_helper.rb

@@ -6,3 +6,29 @@ Rspec.configure do |config|
   config.mock_with :rr
 
 end
+
+module OutputCapture
+  
+  def self.included(target)
+
+    target.before do
+      $stdout = @out = StringIO.new
+      $stderr = @err = StringIO.new
+    end
+
+    target.after do
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+    
+  end
+
+  def stdout
+    @out.string
+  end
+
+  def stderr
+    @err.string
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: clamp
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Mike Williams
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-02 00:00:00 +11:00
+date: 2010-11-08 00:00:00 +11:00
 default_executable: 
 dependencies: []
 
@@ -33,16 +33,21 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
-- Gemfile.lock
 - README.markdown
 - Rakefile
 - clamp.gemspec
+- examples/flipflop
+- examples/icecream
 - examples/rename
+- examples/speak
 - lib/clamp.rb
-- lib/clamp/argument.rb
 - lib/clamp/command.rb
+- lib/clamp/help_support.rb
 - lib/clamp/option.rb
+- lib/clamp/option_support.rb
+- lib/clamp/subcommand_support.rb
 - lib/clamp/version.rb
+- spec/clamp/command_group_spec.rb
 - spec/clamp/command_spec.rb
 - spec/clamp/option_spec.rb
 - spec/spec_helper.rb
@@ -81,6 +86,7 @@ signing_key:
 specification_version: 3
 summary: a minimal framework for command-line utilities
 test_files: 
+- spec/clamp/command_group_spec.rb
 - spec/clamp/command_spec.rb
 - spec/clamp/option_spec.rb
 - spec/spec_helper.rb

data/Gemfile.lock

@@ -1,30 +0,0 @@
-PATH
-  remote: .
-  specs:
-    clamp (0.0.1)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.1.2)
-    rake (0.8.7)
-    rr (1.0.0)
-    rspec (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-      rspec-mocks (~> 2.0.1)
-    rspec-core (2.0.1)
-    rspec-expectations (2.0.1)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  clamp!
-  rake
-  rr (~> 1.0.0)
-  rspec (~> 2.0.1)

data/lib/clamp/argument.rb

@@ -1,6 +0,0 @@
-module Clamp
-  
-  class Argument < Struct.new(:name, :description)
-  end
-  
-end