clamp 0.0.7 → 0.0.9

data/lib/clamp/parameter.rb

@@ -0,0 +1,63 @@
+module Clamp
+
+  class Parameter
+
+    def initialize(name, description, options = {})
+      @name = name
+      @description = description
+      infer_attribute_name_and_multiplicity
+      if options.has_key?(:attribute_name)
+        @attribute_name = options[:attribute_name].to_s 
+      end
+    end
+
+    attr_reader :name, :description, :attribute_name
+    
+    def help
+      [name, description]
+    end
+
+    def consume(arguments)
+      if required? && arguments.empty?
+        raise ArgumentError, "no value provided"
+      end
+      if multivalued?
+        arguments.shift(arguments.length)
+      else
+        arguments.shift
+      end
+    end
+    
+    private
+
+    def infer_attribute_name_and_multiplicity
+      case @name
+      when /^\[(\S+)\]$/
+        @attribute_name = $1
+      when /^\[(\S+)\] ...$/
+        @attribute_name = "#{$1}_list"
+        @multivalued = true
+      when /^(\S+) ...$/
+        @attribute_name = "#{$1}_list"
+        @multivalued = true
+        @required = true
+      when /^\S+$/
+        @attribute_name = @name
+        @required = true
+      else
+        raise "invalid parameter name: '#{name}'"
+      end
+      @attribute_name = @attribute_name.downcase.tr('-', '_')
+    end
+    
+    def multivalued?
+      @multivalued
+    end
+
+    def required?
+      @required
+    end
+    
+  end
+
+end

data/lib/clamp/parameter/declaration.rb

@@ -0,0 +1,24 @@
+require 'clamp/attribute_declaration'
+require 'clamp/parameter'
+
+module Clamp
+  class Parameter
+
+    module Declaration
+
+      include AttributeDeclaration
+
+      def parameters
+        @parameters ||= []
+      end
+
+      def parameter(name, description, options = {}, &block)
+        parameter = Parameter.new(name, description, options)
+        parameters << parameter
+        define_accessors_for(parameter, &block)
+      end
+
+    end
+
+  end
+end

data/lib/clamp/parameter/parsing.rb

@@ -0,0 +1,30 @@
+module Clamp
+  class Parameter
+
+    module Parsing
+
+      protected
+      
+      def parse_parameters
+
+        return false if self.class.parameters.empty?
+
+        self.class.parameters.each do |parameter|
+          begin
+            value = parameter.consume(arguments)
+            send("#{parameter.attribute_name}=", value)
+          rescue ArgumentError => e
+            signal_usage_error "parameter '#{parameter.name}': #{e.message}"
+          end
+        end
+
+        unless arguments.empty?
+          signal_usage_error "too many arguments"
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/clamp/subcommand/declaration.rb

@@ -0,0 +1,35 @@
+module Clamp
+
+  class Subcommand < Struct.new(:name, :description, :subcommand_class)
+
+    def help
+      [name, description]
+    end
+
+    module Declaration
+
+      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
+
+end

data/lib/clamp/subcommand/execution.rb

@@ -0,0 +1,32 @@
+module Clamp
+  class Subcommand
+
+    module Execution
+
+      protected
+      
+      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
+
+      private
+
+      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
+
+    end
+
+  end
+end

data/lib/clamp/version.rb

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

data/spec/clamp/command_group_spec.rb

@@ -83,6 +83,11 @@ describe Clamp::Command do
       stdout.should =~ /walking north/
     end
 
+    it "accepts parents options (specified before the subcommand)" do
+      @command.run(["--direction", "north", "walk"])
+      stdout.should =~ /walking north/
+    end
+
     it "has access to command context" do
       @command.run(["walk"])
       stdout.should =~ /wandering south by default/

data/spec/clamp/command_spec.rb

@@ -27,25 +27,6 @@ describe Clamp::Command do
 
   end
 
-  describe "#parse" do
-
-    it "sets arguments" do
-      @command.parse(%w(a b c))
-      @command.arguments.should == %w(a b c)
-    end
-
-    describe "with an unrecognised option" do
-
-      it "raises a UsageError" do
-        lambda do
-          @command.parse(%w(--foo bar))
-        end.should raise_error(Clamp::UsageError)
-      end
-
-    end
-
-  end
-
   describe "#run" do
 
     before do
@@ -72,6 +53,19 @@ describe Clamp::Command do
       @command.flavour.should == "chocolate"
     end
 
+    describe "with type :flag" do
+
+      before do
+        @command.class.option "--verbose", :flag, "Be heartier"
+      end
+
+      it "declares a predicate-style reader" do
+        @command.should respond_to(:verbose?)
+        @command.should_not respond_to(:verbose)
+      end
+
+    end
+    
     describe "with explicit :attribute_name" do
 
       before do
@@ -102,26 +96,56 @@ describe Clamp::Command do
 
     end
 
-  end
+    describe "with a block" do
 
+      before do
+        @command.class.option "--port", "PORT", "Port to listen on" do |port|
+          Integer(port)
+        end
+      end
+
+      it "uses the block to validate and convert the option argument" do
+        lambda do
+          @command.port = "blah"
+        end.should raise_error(ArgumentError)
+        @command.port = "1234"
+        @command.port.should == 1234
+      end
+
+    end
+
+  end
+  
   describe "with options declared" do
 
     before do
       @command.class.option "--flavour", "FLAVOUR", "Flavour of the month"
       @command.class.option "--color", "COLOR", "Preferred hue"
+      @command.class.option "--[no-]nuts", :flag, "Nuts (or not)"
     end
 
     describe "#parse" do
 
+      describe "with an unrecognised option" do
+
+        it "raises a UsageError" do
+          lambda do
+            @command.parse(%w(--foo bar))
+          end.should raise_error(Clamp::UsageError)
+        end
+
+      end
+
       describe "with options" do
 
         before do
-          @command.parse(%w(--flavour strawberry --color blue a b c))
+          @command.parse(%w(--flavour strawberry --nuts --color blue a b c))
         end
 
-        it "extracts the option values" do
+        it "maps the option values onto the command object" do
           @command.flavour.should == "strawberry"
           @command.color.should == "blue"
+          @command.nuts?.should == true
         end
 
         it "retains unconsumed arguments" do
@@ -148,6 +172,53 @@ describe Clamp::Command do
 
       end
 
+      describe "with --flag" do
+
+        before do
+          @command.parse(%w(--nuts))
+        end
+
+        it "sets the flag" do
+          @command.nuts?.should be_true
+        end
+
+      end
+
+      describe "with --no-flag" do
+
+        before do
+          @command.nuts = true
+          @command.parse(%w(--no-nuts))
+        end
+
+        it "clears the flag" do
+          @command.nuts?.should be_false
+        end
+
+      end
+
+      describe "when option-writer raises an ArgumentError" do
+        
+        before do
+          @command.class.class_eval do
+            
+            def color=(c)
+              unless c == "black"
+                raise ArgumentError, "sorry, we're out of #{c}"
+              end
+            end
+            
+          end
+        end
+          
+        it "re-raises it as a UsageError" do
+          lambda do
+            @command.parse(%w(--color red))
+          end.should raise_error(Clamp::UsageError, /^option '--color': sorry, we're out of red/)
+        end
+
+      end
+
     end
 
     describe "#help" do
@@ -165,117 +236,124 @@ describe Clamp::Command do
 
   end
 
-  describe "with a flag option declared" do
+  describe ".parameter" do
 
-    before do
-      @command.class.option "--verbose", :flag, "Be heartier"
+    it "declares option argument accessors" do
+      @command.class.parameter "FLAVOUR", "flavour of the month"
+      @command.flavour.should == nil
+      @command.flavour = "chocolate"
+      @command.flavour.should == "chocolate"
     end
 
-    it "declares a predicate-style reader" do
-      @command.should respond_to(:verbose?)
-      @command.should_not respond_to(:verbose)
-    end
+    describe "with explicit :attribute_name" do
 
-    describe "#parse" do
+      before do
+        @command.class.parameter "FOO", "a foo", :attribute_name => :bar
+      end
 
-      describe "with option" do
+      it "uses the specified attribute_name name to name accessors" do
+        @command.bar = "chocolate"
+        @command.bar.should == "chocolate"
+      end
 
-        before do
-          @command.parse(%w(--verbose foo))
-        end
+    end
 
-        it "sets the flag" do
-          @command.should be_verbose
-        end
+    describe "with a block" do
 
-        it "does not consume an argument" do
-          @command.arguments.should == %w(foo)
+      before do
+        @command.class.parameter "PORT", "port to listen on" do |port|
+          Integer(port)
         end
+      end
 
+      it "uses the block to validate and convert the argument" do
+        lambda do
+          @command.port = "blah"
+        end.should raise_error(ArgumentError)
+        @command.port = "1234"
+        @command.port.should == 1234
       end
 
     end
 
   end
 
-  describe "with a negatable flag option declared" do
+  describe "with no parameters declared" do
 
+    describe "#parse" do
+    
+      it "retains arguments for handling by #execute" do
+        @command.parse(["crash", "bang", "wallop"])
+        @command.arguments.should == ["crash", "bang", "wallop"]
+      end
+      
+    end
+    
+  end
+
+  describe "with parameters declared" do
+    
     before do
-      @command.class.option "--[no-]sync", :flag, "Synchronise"
+      @command.class.parameter "X", "x"
+      @command.class.parameter "Y", "y"
+      @command.class.parameter "[Z]", "z"
     end
 
     describe "#parse" do
-
-      describe "with --flag" do
-
+      
+      describe "with arguments for all parameters" do
+        
         before do
-          @command.parse(%w(--sync))
+          @command.parse(["crash", "bang", "wallop"])
         end
 
-        it "sets the flag" do
-          @command.sync?.should be_true
+        it "maps arguments onto the command object" do
+          @command.x.should == "crash"
+          @command.y.should == "bang"
+          @command.z.should == "wallop"
         end
 
-      end
-
-      describe "with --no-flag" do
-
-        before do
-          @command.sync = true
-          @command.parse(%w(--no-sync))
-        end
-
-        it "clears the flag" do
-          @command.sync?.should be_false
+        it "consumes all the arguments" do
+          @command.arguments.should == []
         end
-
+        
       end
 
-    end
-
-  end
-
-  describe ".option, with a block" do
-
-    before do
-      @command.class.option "--port", "PORT", "Port to listen on" do |port|
-        Integer(port)
+      describe "with insufficient arguments" do
+        
+        it "raises a UsageError" do
+          lambda do
+            @command.parse(["crash"])
+          end.should raise_error(Clamp::UsageError, "parameter 'Y': no value provided")
+        end
+        
       end
-    end
-
-    it "uses the block to validate and convert the option argument" do
-      lambda do
-        @command.port = "blah"
-      end.should raise_error(ArgumentError)
-      @command.port = "1234"
-      @command.port.should == 1234
-    end
-
-    describe "#parse" do
 
-      describe "with a valid option argument" do
+      describe "with optional argument omitted" do
 
-        it "stores the converted value" do
-          @command.parse(%w(--port 4321))
-          @command.port.should == 4321
+        it "defaults the optional argument to nil" do
+          @command.parse(["crash", "bang"])
+          @command.x.should == "crash"
+          @command.y.should == "bang"
+          @command.z.should == nil
         end
-
+        
       end
 
-      describe "with an invalid option argument" do
-
+      describe "with too many arguments" do
+        
         it "raises a UsageError" do
           lambda do
-            @command.parse(%w(--port blah))
-          end.should raise_error(Clamp::UsageError, /^option '--port': invalid value/)
+            @command.parse(["crash", "bang", "wallop", "kapow"])
+          end.should raise_error(Clamp::UsageError, "too many arguments")
         end
-
+        
       end
-
+      
     end
-
+    
   end
-
+  
   describe "with explicit usage" do
 
     given_command("blah") do