clamp 0.6.3 → 0.6.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZGNkZmM3NzM5ZDJjNDM2ZGIxZWNhNGIzZmM1ZDJjZGZjZmE1ODUwNQ==
-  data.tar.gz: !binary |-
-    OWI1Mzc1OWQwOTgzMjMxNjVjODE2ZGQwYzk5NmZjNzdkYTEwOTA0OQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NGFjOTY4MTQ3OTg2NDZhMjA3OWE5MmEzYTVlM2VmMzc0NjAxYWUwNDAxZThi
-    MGY1MDMwNWE2NGY0ZDNhYjZkZTQ4MGEzNWU4Y2RhZTAzMDVkMjEyZjIwNzY1
-    YmMxNWQ3NzY2MTIwMWZjM2UwNGEyMmU5ODllY2I5MGFhMzY2MWM=
-  data.tar.gz: !binary |-
-    OWNjMTNkOGNkYjZiMjNlNmRiODc4MWFmMzRhOWJmODIwZjBmNDkzNWVhZGQ2
-    MzExZDg3ZTMwNDBjZjkxZDZkZGFiYzU1YzQ5NGM0ZDVhYjAyN2U3NTc0M2Qz
-    MzRiZTVlMTJkOTU4YjkxZTVjMTIxNGIzNWY1OTI5OTVmYmYyODA=
+SHA1:
+  metadata.gz: 0222cf7a03642506d668988d57a60b992accc073
+  data.tar.gz: 9d0314d698965b297003ebca1ad6a31183c91fac
+SHA512:
+  metadata.gz: c9cbcdeded12d74963a8a00681f715640d185f6a0ee6faa285cf9b03b8f00721115a35664602f06b2ea40e8fd670be3546338f624b24feae7d450f1a659ad9e0
+  data.tar.gz: 4d304f351b33bd4eeb034837b3174d06898dd02eb5349db2142be751634b5885b0bc2160654b7af3a97392582fcab705968c2b7de72b37bb1828b885eef6c76e

data/.autotest

@@ -1,3 +1,5 @@
+require "autotest/bundler"
+
 Autotest.add_hook :initialize do |at|
 
   at.add_exception ".git"

data/.travis.yml

@@ -4,3 +4,5 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.5
+  - 2.2.0

data/CHANGES.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.6.4 (2015-02-26)
+
+* Ensure computed defaults are only computed once.
+
+## 0.6.3 (2013-11-14)
+
+* Specify (MIT) license.
+
 ## 0.6.2 (2013-11-06)
 
 * Refactoring around multi-valued attributes.

data/Gemfile

@@ -3,7 +3,7 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
-  gem "rake"
-  gem "rspec"
-  gem "rr"
+  gem "rake", "~> 10.4"
+  gem "rspec", "~> 3.1.0"
+  gem "rr", "~> 1.1.2"
 end

data/README.md

@@ -1,7 +1,9 @@
-
-Clamp  [![Build Status](https://secure.travis-ci.org/mdub/clamp.png?branch=master)](http://travis-ci.org/mdub/clamp)
+Clamp
 =====
 
+[![Gem Version](https://badge.fury.io/rb/clamp.png)](http://badge.fury.io/rb/clamp)
+[![Build Status](https://secure.travis-ci.org/mdub/clamp.png?branch=master)](http://travis-ci.org/mdub/clamp)
+
 "Clamp" is a minimal framework for command-line utilities.
 
 It handles boring stuff like parsing the command-line, and generating help, so you can get on with making your command actually do stuff.
@@ -197,7 +199,7 @@ Clamp will verify that all required (ie. non-optional) parameters are present, a
 ### Validation
 
 Both `option` and `parameter` accept an optional block.  If present, the block will be
-called with the raw string argument, and is expected to validate it.  The value returned by the block will be assigned to the underlying attribute, so it's also a good place to coerce the String to a different type, if appropriate.  
+called with the raw string argument, and is expected to validate it.  The value returned by the block will be assigned to the underlying attribute, so it's also a good place to coerce the String to a different type, if appropriate.
 
 For example:
 
@@ -314,6 +316,18 @@ class InitCommand < Clamp::Command
 end
 ```
 
+Like options, subcommands may have aliases:
+
+```ruby
+Clamp do
+
+  subcommand ["initialize", "init"], "Initialize the repository" do
+    # ...
+  end
+
+end
+```
+
 ### Default subcommand
 
 You can set a default subcommand, at the class level, as follows:

data/Rakefile

@@ -8,5 +8,5 @@ task "default" => "spec"
 
 RSpec::Core::RakeTask.new do |t|
   t.pattern = 'spec/**/*_spec.rb'
-  t.rspec_opts = ["--colour", "--format", "nested"]
+  t.rspec_opts = ["--colour", "--format", "documentation"]
 end

data/examples/fubar

@@ -8,7 +8,7 @@ Clamp do
 
   subcommand "foo", "Foo!" do
 
-    subcommand "bar", "Baaaa!" do
+    subcommand ["bar", "bah", "baa"], "Baaaa!" do
 
       def execute
         puts "FUBAR"

data/lib/clamp/attribute/instance.rb

@@ -32,11 +32,8 @@ module Clamp
 
       # default implementation of read_method
       def _read
-        if self.defined?
-          get
-        else
-          default
-        end
+        set(default) unless self.defined?
+        get
       end
 
       # default implementation of append_method

data/lib/clamp/command.rb

@@ -103,6 +103,13 @@ module Clamp
       raise e
     end
 
+    def signal_error(message, options = {})
+      status = options.fetch(:status, 1)
+      e = ExecutionError.new(message, self, status)
+      e.set_backtrace(caller)
+      raise e
+    end
+
     def request_help
       raise HelpWanted, self
     end
@@ -130,6 +137,9 @@ module Clamp
           exit(1)
         rescue Clamp::HelpWanted => e
           puts e.command.help
+        rescue Clamp::ExecutionError => e
+          $stderr.puts "ERROR: #{e.message}"
+          exit(e.status)
         end
       end
 

data/lib/clamp/errors.rb

@@ -26,4 +26,16 @@ module Clamp
 
   end
 
+  # raise to signal error during execution
+  class ExecutionError < RuntimeError
+
+    def initialize(message, command, status = 1)
+      super(message, command)
+      @status = status
+    end
+
+    attr_reader :status
+
+  end
+
 end

data/lib/clamp/version.rb

@@ -1,3 +1,3 @@
 module Clamp
-  VERSION = "0.6.3".freeze
+  VERSION = "0.6.4".freeze
 end

data/spec/clamp/command_group_spec.rb

@@ -5,7 +5,7 @@ describe Clamp::Command do
   extend CommandFactory
   include OutputCapture
 
-  describe "with subcommands" do
+  context "with subcommands" do
 
     given_command "flipflop" do
 
@@ -30,19 +30,19 @@ describe Clamp::Command do
     it "delegates to sub-commands" do
 
       command.run(["flip"])
-      stdout.should =~ /FLIPPED/
+      expect(stdout).to match /FLIPPED/
 
       command.run(["flop"])
-      stdout.should =~ /FLOPPED/
+      expect(stdout).to match /FLOPPED/
 
     end
 
     context "executed with no subcommand" do
 
       it "triggers help" do
-        lambda do
+        expect do
           command.run([])
-        end.should raise_error(Clamp::HelpWanted)
+        end.to raise_error(Clamp::HelpWanted)
       end
 
     end
@@ -50,25 +50,25 @@ describe Clamp::Command do
     describe "#help" do
 
       it "shows subcommand parameters in usage" do
-        command.help.should include("flipflop [OPTIONS] SUBCOMMAND [ARG] ...")
+        expect(command.help).to include("flipflop [OPTIONS] SUBCOMMAND [ARG] ...")
       end
 
       it "lists subcommands" do
         help = command.help
-        help.should =~ /Subcommands:/
-        help.should =~ /flip +flip it/
-        help.should =~ /flop +flop it/
+        expect(help).to match /Subcommands:/
+        expect(help).to match /flip +flip it/
+        expect(help).to match /flop +flop it/
       end
 
       it "handles new lines in subcommand descriptions" do
-        command.help.should =~ /flop +flop it\n +for extra flop/
+        expect(command.help).to match /flop +flop it\n +for extra flop/
       end
 
     end
 
   end
 
-  describe "with an aliased subcommand" do
+  context "with an aliased subcommand" do
 
     given_command "blah" do
 
@@ -87,10 +87,10 @@ describe Clamp::Command do
     it "responds to both aliases" do
 
       command.run(["say", "boo"])
-      stdout.should =~ /boo/
+      expect(stdout).to match /boo/
 
       command.run(["talk", "jive"])
-      stdout.should =~ /jive/
+      expect(stdout).to match /jive/
 
     end
 
@@ -98,14 +98,14 @@ describe Clamp::Command do
 
       it "lists all aliases" do
         help = command.help
-        help.should =~ /say, talk .* Say something/
+        expect(help).to match /say, talk .* Say something/
       end
 
     end
 
   end
 
-  describe "with nested subcommands" do
+  context "with nested subcommands" do
 
     given_command "fubar" do
 
@@ -123,12 +123,12 @@ describe Clamp::Command do
 
     it "delegates multiple levels" do
       command.run(["foo", "bar"])
-      stdout.should =~ /FUBAR/
+      expect(stdout).to match /FUBAR/
     end
 
   end
 
-  describe "with a default subcommand" do
+  context "with a default subcommand" do
 
     given_command "admin" do
 
@@ -148,14 +148,14 @@ describe Clamp::Command do
 
       it "invokes the default subcommand" do
         command.run([])
-        stdout.should =~ /All good/
+        expect(stdout).to match /All good/
       end
 
     end
 
   end
 
-  describe "with a default subcommand, declared the old way" do
+  context "with a default subcommand, declared the old way" do
 
     given_command "admin" do
 
@@ -173,18 +173,18 @@ describe Clamp::Command do
 
       it "invokes the default subcommand" do
         command.run([])
-        stdout.should =~ /All good/
+        expect(stdout).to match /All good/
       end
 
     end
 
   end
 
-  describe "declaring a default subcommand after subcommands" do
+  context "declaring a default subcommand after subcommands" do
 
     it "is not supported" do
 
-      lambda do
+      expect do
         Class.new(Clamp::Command) do
 
           subcommand "status", "Show status" do
@@ -198,13 +198,13 @@ describe Clamp::Command do
           self.default_subcommand = "status"
 
         end
-      end.should raise_error(/default_subcommand must be defined before subcommands/)
+      end.to raise_error(/default_subcommand must be defined before subcommands/)
 
     end
 
   end
 
-  describe "with subcommands, declared after a parameter" do
+  context "with subcommands, declared after a parameter" do
 
     given_command "with" do
 
@@ -221,7 +221,7 @@ describe Clamp::Command do
     it "allows the parameter to be specified first" do
 
       command.run(["dummy", "spit"])
-      stdout.strip.should == "spat the dummy"
+      expect(stdout.strip).to eql "spat the dummy"
 
     end
 
@@ -260,28 +260,28 @@ describe Clamp::Command do
 
     it "accepts options defined in superclass (specified after the subcommand)" do
       command.run(["move", "--direction", "north"])
-      stdout.should =~ /walking north/
+      expect(stdout).to match /walking north/
     end
 
     it "accepts options defined in superclass (specified before the subcommand)" do
       command.run(["--direction", "north", "move"])
-      stdout.should =~ /walking north/
+      expect(stdout).to match /walking north/
     end
 
     it "accepts options defined in included modules" do
       command.run(["move", "--speed", "very quickly"])
-      stdout.should =~ /walking home very quickly/
+      expect(stdout).to match /walking home very quickly/
     end
 
     it "has access to command context" do
       command = command_class.new("go", :motion => "wandering")
       command.run(["move"])
-      stdout.should =~ /wandering home/
+      expect(stdout).to match /wandering home/
     end
 
   end
 
-  describe "with a subcommand, with options" do
+  context "with a subcommand, with options" do
 
     given_command 'weeheehee' do
       option '--json', 'JSON', 'a json blob' do |option|
@@ -297,7 +297,7 @@ describe Clamp::Command do
 
     it "only parses options once" do
       command.run(['--json', '{"a":"b"}', 'woohoohoo'])
-      stdout.should == 'parsing!'
+      expect(stdout).to eql 'parsing!'
     end
 
   end

data/spec/clamp/command_spec.rb

@@ -5,6 +5,7 @@ describe Clamp::Command do
 
   extend CommandFactory
   include OutputCapture
+  include SetEnv
 
   given_command("cmd") do
 
@@ -17,7 +18,7 @@ describe Clamp::Command do
   describe "#help" do
 
     it "describes usage" do
-      command.help.should =~ /^Usage:\n    cmd.*\n/
+      expect(command.help).to match /^Usage:\n    cmd.*\n/
     end
 
   end
@@ -29,7 +30,7 @@ describe Clamp::Command do
     end
 
     it "executes the #execute method" do
-      stdout.should_not be_empty
+      expect(stdout).to_not be_empty
     end
 
   end
@@ -38,25 +39,25 @@ describe Clamp::Command do
 
     it "declares option argument accessors" do
       command.class.option "--flavour", "FLAVOUR", "Flavour of the month"
-      command.flavour.should == nil
+      expect(command.flavour).to eql nil
       command.flavour = "chocolate"
-      command.flavour.should == "chocolate"
+      expect(command.flavour).to eql "chocolate"
     end
 
-    describe "with type :flag" do
+    context "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)
+        expect(command).to respond_to(:verbose?)
+        expect(command).to_not respond_to(:verbose)
       end
 
     end
 
-    describe "with explicit :attribute_name" do
+    context "with explicit :attribute_name" do
 
       before do
         command.class.option "--foo", "FOO", "A foo", :attribute_name => :bar
@@ -64,17 +65,17 @@ describe Clamp::Command do
 
       it "uses the specified attribute_name name to name accessors" do
         command.bar = "chocolate"
-        command.bar.should == "chocolate"
+        expect(command.bar).to eql "chocolate"
       end
 
       it "does not attempt to create the default accessors" do
-        command.should_not respond_to(:foo)
-        command.should_not respond_to(:foo=)
+        expect(command).to_not respond_to(:foo)
+        expect(command).to_not respond_to(:foo=)
       end
 
     end
 
-    describe "with default method" do
+    context "with default method" do
 
       before do
         command.class.option "--port", "PORT", "port"
@@ -86,97 +87,95 @@ describe Clamp::Command do
       end
 
       it "sets the specified default value" do
-        command.port.should == 4321
+        expect(command.port).to eql 4321
       end
 
     end
 
-    describe "with :default value" do
+    context "with :default value" do
 
       before do
         command.class.option "--port", "PORT", "port to listen on", :default => 4321
       end
 
       it "declares default method" do
-        command.default_port.should == 4321
+        expect(command.default_port).to eql 4321
       end
 
       describe "#help" do
 
         it "describes the default value" do
-          command.help.should include("port to listen on (default: 4321)")
+          expect(command.help).to include("port to listen on (default: 4321)")
         end
 
       end
 
     end
 
-    describe "with :multivalued" do
+    context "with :multivalued" do
 
       before do
         command.class.option "--flavour", "FLAVOUR", "flavour(s)", :multivalued => true, :attribute_name => :flavours
       end
 
       it "defaults to empty array" do
-        command.flavours.should == []
+        expect(command.flavours).to eql []
       end
 
       it "supports multiple values" do
         command.parse(%w(--flavour chocolate --flavour vanilla))
-        command.flavours.should == %w(chocolate vanilla)
+        expect(command.flavours).to eql %w(chocolate vanilla)
       end
 
       it "generates a single-value appender method" do
         command.append_to_flavours("mud")
         command.append_to_flavours("pie")
-        command.flavours.should == %w(mud pie)
+        expect(command.flavours).to eql %w(mud pie)
       end
 
       it "generates a multi-value setter method" do
         command.append_to_flavours("replaceme")
         command.flavours = %w(mud pie)
-        command.flavours.should == %w(mud pie)
+        expect(command.flavours).to eql %w(mud pie)
       end
 
     end
 
-    describe "with :environment_variable" do
+    context "with :environment_variable" do
+
+      let(:environment_value) { nil }
+      let(:args) { [] }
 
       before do
         command.class.option "--port", "PORT", "port to listen on", :default => 4321, :environment_variable => "PORT" do |value|
           value.to_i
         end
+        set_env("PORT", environment_value)
+        command.parse(args)
       end
 
       context "when no environment variable is present" do
 
-        before do
-          ENV.delete("PORT")
-        end
-
         it "uses the default" do
-          command.parse([])
-          command.port.should == 4321
+          expect(command.port).to eql 4321
         end
 
       end
 
       context "when environment variable is present" do
 
-        before do
-          ENV["PORT"] = "12345"
-        end
+        let(:environment_value) { "12345" }
 
         it "uses the environment variable" do
-          command.parse([])
-          command.port.should == 12345
+          expect(command.port).to eql 12345
         end
 
         context "and a value is specified on the command-line" do
 
+          let(:args) { %w(--port 1500) }
+
           it "uses command-line value" do
-            command.parse(%w(--port 1500))
-            command.port.should == 1500
+            expect(command.port).to eql 1500
           end
 
         end
@@ -186,28 +185,27 @@ describe Clamp::Command do
       describe "#help" do
 
         it "describes the default value and env usage" do
-          command.help.should include("port to listen on (default: $PORT, or 4321)")
+          expect(command.help).to include("port to listen on (default: $PORT, or 4321)")
         end
 
       end
 
     end
 
-    describe "with :environment_variable and type :flag" do
+    context "with :environment_variable and type :flag" do
+
+      let(:environment_value) { nil }
 
       before do
         command.class.option "--[no-]enable", :flag, "enable?", :default => false, :environment_variable => "ENABLE"
+        set_env("ENABLE", environment_value)
+        command.parse([])
       end
 
       context "when no environment variable is present" do
 
-        before do
-          ENV.delete("ENABLE")
-        end
-
         it "uses the default" do
-          command.parse([])
-          command.enable?.should == false
+          expect(command.enable?).to eql false
         end
 
       end
@@ -216,10 +214,10 @@ describe Clamp::Command do
 
         context "when environment variable is #{truthy_value.inspect}" do
 
+          let(:environment_value) { truthy_value }
+
           it "sets the flag" do
-            ENV["ENABLE"] = truthy_value
-            command.parse([])
-            command.enable?.should == true
+            expect(command.enable?).to eql true
           end
 
         end
@@ -230,10 +228,10 @@ describe Clamp::Command do
 
         context "when environment variable is #{falsey_value.inspect}" do
 
+          let(:environment_value) { falsey_value }
+
           it "clears the flag" do
-            ENV["ENABLE"] = falsey_value
-            command.parse([])
-            command.enable?.should == false
+            expect(command.enable?).to eql false
           end
 
         end
@@ -242,7 +240,7 @@ describe Clamp::Command do
 
     end
 
-    describe "with :required" do
+    context "with :required" do
 
       before do
         command.class.option "--port", "PORT", "port to listen on", :required => true
@@ -270,7 +268,7 @@ describe Clamp::Command do
 
     end
 
-    describe "with a block" do
+    context "with a block" do
 
       before do
         command.class.option "--port", "PORT", "Port to listen on" do |port|
@@ -279,18 +277,18 @@ describe Clamp::Command do
       end
 
       it "uses the block to validate and convert the option argument" do
-        lambda do
+        expect do
           command.port = "blah"
-        end.should raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
         command.port = "1234"
-        command.port.should == 1234
+        expect(command.port).to eql 1234
       end
 
     end
 
   end
 
-  describe "with options declared" do
+  context "with options declared" do
 
     before do
       command.class.option ["-f", "--flavour"], "FLAVOUR", "Flavour of the month"
@@ -306,126 +304,126 @@ describe Clamp::Command do
 
     describe "#parse" do
 
-      describe "with an unrecognised option" do
+      context "with an unrecognised option" do
 
         it "raises a UsageError" do
-          lambda do
+          expect do
             command.parse(%w(--foo bar))
-          end.should raise_error(Clamp::UsageError)
+          end.to raise_error(Clamp::UsageError)
         end
 
       end
 
-      describe "with options" do
+      context "with options" do
 
         before do
           command.parse(%w(--flavour strawberry --nuts --color blue))
         end
 
         it "maps the option values onto the command object" do
-          command.flavour.should == "strawberry"
-          command.color.should == "blue"
-          command.nuts?.should == true
+          expect(command.flavour).to eql "strawberry"
+          expect(command.color).to eql "blue"
+          expect(command.nuts?).to eql true
         end
 
       end
 
-      describe "with short options" do
+      context "with short options" do
 
         before do
           command.parse(%w(-f strawberry -c blue))
         end
 
         it "recognises short options as aliases" do
-          command.flavour.should == "strawberry"
-          command.color.should == "blue"
+          expect(command.flavour).to eql "strawberry"
+          expect(command.color).to eql "blue"
         end
 
       end
 
-      describe "with a value appended to a short option" do
+      context "with a value appended to a short option" do
 
         before do
           command.parse(%w(-fstrawberry))
         end
 
         it "works as though the value were separated" do
-          command.flavour.should == "strawberry"
+          expect(command.flavour).to eql "strawberry"
         end
 
       end
 
-      describe "with combined short options" do
+      context "with combined short options" do
 
         before do
           command.parse(%w(-nf strawberry))
         end
 
         it "works as though the options were separate" do
-          command.flavour.should == "strawberry"
-          command.nuts?.should == true
+          expect(command.flavour).to eql "strawberry"
+          expect(command.nuts?).to eql true
         end
 
       end
 
-      describe "with option arguments attached using equals sign" do
+      context "with option arguments attached using equals sign" do
 
         before do
           command.parse(%w(--flavour=strawberry --color=blue))
         end
 
         it "works as though the option arguments were separate" do
-          command.flavour.should == "strawberry"
-          command.color.should == "blue"
+          expect(command.flavour).to eql "strawberry"
+          expect(command.color).to eql "blue"
         end
 
       end
 
-      describe "with option-like things beyond the arguments" do
+      context "with option-like things beyond the arguments" do
 
         it "treats them as positional arguments" do
           command.parse(%w(a b c --flavour strawberry))
-          command.arguments.should == %w(a b c --flavour strawberry)
+          expect(command.arguments).to eql %w(a b c --flavour strawberry)
         end
 
       end
 
-      describe "with multi-line arguments that look like options" do
+      context "with multi-line arguments that look like options" do
 
         before do
           command.parse(["foo\n--flavour=strawberry", "bar\n-cblue"])
         end
 
         it "treats them as positional arguments" do
-          command.arguments.should == ["foo\n--flavour=strawberry", "bar\n-cblue"]
-          command.flavour.should be_nil
-          command.color.should be_nil
+          expect(command.arguments).to eql ["foo\n--flavour=strawberry", "bar\n-cblue"]
+          expect(command.flavour).to be_nil
+          expect(command.color).to be_nil
         end
 
       end
 
-      describe "with an option terminator" do
+      context "with an option terminator" do
 
         it "considers everything after the terminator to be an argument" do
           command.parse(%w(--color blue -- --flavour strawberry))
-          command.arguments.should == %w(--flavour strawberry)
+          expect(command.arguments).to eql %w(--flavour strawberry)
         end
 
       end
 
-      describe "with --flag" do
+      context "with --flag" do
 
         before do
           command.parse(%w(--nuts))
         end
 
         it "sets the flag" do
-          command.nuts?.should be_true
+          expect(command.nuts?).to be true
         end
 
       end
 
-      describe "with --no-flag" do
+      context "with --no-flag" do
 
         before do
           command.nuts = true
@@ -433,48 +431,48 @@ describe Clamp::Command do
         end
 
         it "clears the flag" do
-          command.nuts?.should be_false
+          expect(command.nuts?).to be false
         end
 
       end
 
-      describe "with --help" do
+      context "with --help" do
 
         it "requests help" do
-          lambda do
+          expect do
             command.parse(%w(--help))
-          end.should raise_error(Clamp::HelpWanted)
+          end.to raise_error(Clamp::HelpWanted)
         end
 
       end
 
-      describe "with -h" do
+      context "with -h" do
 
         it "requests help" do
-          lambda do
+          expect do
             command.parse(%w(-h))
-          end.should raise_error(Clamp::HelpWanted)
+          end.to raise_error(Clamp::HelpWanted)
         end
 
       end
 
-      describe "when a bad option value is specified on the command-line" do
+      context "when a bad option value is specified on the command-line" do
 
         it "signals a UsageError" do
-          lambda do
+          expect do
             command.parse(%w(--scoops reginald))
-          end.should raise_error(Clamp::UsageError, /^option '--scoops': invalid value for Integer/)
+          end.to raise_error(Clamp::UsageError, /^option '--scoops': invalid value for Integer/)
         end
 
       end
 
-      describe "when a bad option value is specified in the environment" do
+      context "when a bad option value is specified in the environment" do
 
         it "signals a UsageError" do
           ENV["DEFAULT_SCOOPS"] = "marjorie"
-          lambda do
+          expect do
             command.parse([])
-          end.should raise_error(Clamp::UsageError, /^\$DEFAULT_SCOOPS: invalid value for Integer/)
+          end.to raise_error(Clamp::UsageError, /^\$DEFAULT_SCOOPS: invalid value for Integer/)
         end
 
       end
@@ -484,44 +482,44 @@ describe Clamp::Command do
     describe "#help" do
 
       it "indicates that there are options" do
-        command.help.should include("cmd [OPTIONS]")
+        expect(command.help).to include("cmd [OPTIONS]")
       end
 
       it "includes option details" do
-        command.help.should =~ %r(--flavour FLAVOUR +Flavour of the month)
-        command.help.should =~ %r(--color COLOR +Preferred hue)
+        expect(command.help).to match %r(--flavour FLAVOUR +Flavour of the month)
+        expect(command.help).to match %r(--color COLOR +Preferred hue)
       end
 
       it "handles new lines in option descriptions" do
-        command.help.should =~ %r(--\[no-\]nuts +Nuts \(or not\)\n +May include nuts)
+        expect(command.help).to match %r(--\[no-\]nuts +Nuts \(or not\)\n +May include nuts)
       end
 
     end
 
   end
 
-  describe "with an explicit --help option declared" do
+  context "with an explicit --help option declared" do
 
     before do
       command.class.option ["--help"], :flag, "help wanted"
     end
 
     it "does not generate implicit help option" do
-      lambda do
+      expect do
         command.parse(%w(--help))
-      end.should_not raise_error
-      command.help.should be_true
+      end.to_not raise_error
+      expect(command.help?).to be true
     end
 
     it "does not recognise -h" do
-      lambda do
+      expect do
         command.parse(%w(-h))
-      end.should raise_error(Clamp::UsageError)
+      end.to raise_error(Clamp::UsageError)
     end
 
   end
 
-  describe "with an explicit -h option declared" do
+  context "with an explicit -h option declared" do
 
     before do
       command.class.option ["-h", "--humidity"], "PERCENT", "relative humidity" do |n|
@@ -530,13 +528,13 @@ describe Clamp::Command do
     end
 
     it "does not map -h to help" do
-      command.help.should_not =~ %r( -h[, ].*help)
+      expect(command.help).to_not match %r( -h[, ].*help)
     end
 
     it "still recognises --help" do
-      lambda do
+      expect do
         command.parse(%w(--help))
-      end.should raise_error(Clamp::HelpWanted)
+      end.to raise_error(Clamp::HelpWanted)
     end
 
   end
@@ -545,12 +543,12 @@ describe Clamp::Command do
 
     it "declares option argument accessors" do
       command.class.parameter "FLAVOUR", "flavour of the month"
-      command.flavour.should == nil
+      expect(command.flavour).to eql nil
       command.flavour = "chocolate"
-      command.flavour.should == "chocolate"
+      expect(command.flavour).to eql "chocolate"
     end
 
-    describe "with explicit :attribute_name" do
+    context "with explicit :attribute_name" do
 
       before do
         command.class.parameter "FOO", "a foo", :attribute_name => :bar
@@ -558,32 +556,32 @@ describe Clamp::Command do
 
       it "uses the specified attribute_name name to name accessors" do
         command.bar = "chocolate"
-        command.bar.should == "chocolate"
+        expect(command.bar).to eql "chocolate"
       end
 
     end
 
-    describe "with :default value" do
+    context "with :default value" do
 
       before do
         command.class.parameter "[ORIENTATION]", "direction", :default => "west"
       end
 
       it "sets the specified default value" do
-        command.orientation.should == "west"
+        expect(command.orientation).to eql "west"
       end
 
       describe "#help" do
 
         it "describes the default value" do
-          command.help.should include("direction (default: \"west\")")
+          expect(command.help).to include("direction (default: \"west\")")
         end
 
       end
 
     end
 
-    describe "with a block" do
+    context "with a block" do
 
       before do
         command.class.parameter "PORT", "port to listen on" do |port|
@@ -592,16 +590,16 @@ describe Clamp::Command do
       end
 
       it "uses the block to validate and convert the argument" do
-        lambda do
+        expect do
           command.port = "blah"
-        end.should raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
         command.port = "1234"
-        command.port.should == 1234
+        expect(command.port).to eql 1234
       end
 
     end
 
-    describe "with ellipsis" do
+    context "with ellipsis" do
 
       before do
         command.class.parameter "FILE ...", "files"
@@ -609,53 +607,83 @@ describe Clamp::Command do
 
       it "accepts multiple arguments" do
         command.parse(%w(X Y Z))
-        command.file_list.should == %w(X Y Z)
+        expect(command.file_list).to eql %w(X Y Z)
       end
 
     end
 
-    describe "optional, with ellipsis" do
+    context "optional, with ellipsis" do
 
       before do
         command.class.parameter "[FILE] ...", "files"
       end
 
-      it "default to an empty list" do
+      it "defaults to an empty list" do
         command.parse([])
-        command.default_file_list.should == []
-        command.file_list.should == []
+        expect(command.default_file_list).to eql []
+        expect(command.file_list).to eql []
+      end
+
+      it "is mutable" do
+        command.parse([])
+        command.file_list << "treasure"
+        expect(command.file_list).to eql ["treasure"]
       end
 
     end
 
-    describe "with :environment_variable value" do
+    context "with :environment_variable" do
 
       before do
         command.class.parameter "[FILE]", "a file", :environment_variable => "FILE",
           :default => "/dev/null"
       end
 
-      it "should use the default if neither flag nor env var are present" do
-        command.parse([])
-        command.file.should == "/dev/null"
+      let(:args) { [] }
+      let(:environment_value) { nil }
+
+
+      before do
+        set_env("FILE", environment_value)
+        command.parse(args)
       end
 
-      it "should use the env value if present (instead of default)" do
-        ENV["FILE"] = "/etc/motd"
-        command.parse([])
-        command.file.should == ENV["FILE"]
+      context "when neither argument nor environment variable are present" do
+
+        it "uses the default" do
+          expect(command.file).to eql "/dev/null"
+        end
+
       end
 
-      it "should use the the flag value if present (instead of env)" do
-        ENV["FILE"] = "/etc/motd"
-        command.parse(%w(/bin/sh))
-        command.file.should == "/bin/sh"
+      context "when environment variable is present" do
+
+        let(:environment_value) { "/etc/motd" }
+
+        describe "and no argument is provided" do
+
+          it "uses the environment variable" do
+            expect(command.file).to eql "/etc/motd"
+          end
+
+        end
+
+        describe "and an argument is provided" do
+
+          let(:args) { ["/dev/null"] }
+
+          it "uses the argument" do
+            expect(command.file).to eql "/dev/null"
+          end
+
+        end
+
       end
 
       describe "#help" do
 
         it "describes the default value and env usage" do
-          command.help.should include(%{ (default: $FILE, or "/dev/null")})
+          expect(command.help).to include(%{ (default: $FILE, or "/dev/null")})
         end
 
       end
@@ -664,16 +692,16 @@ describe Clamp::Command do
 
   end
 
-  describe "with no parameters declared" do
+  context "with no parameters declared" do
 
     describe "#parse" do
 
-      describe "with arguments" do
+      context "with arguments" do
 
         it "raises a UsageError" do
-          lambda do
+          expect do
             command.parse(["crash"])
-          end.should raise_error(Clamp::UsageError, "too many arguments")
+          end.to raise_error(Clamp::UsageError, "too many arguments")
         end
 
       end
@@ -682,7 +710,7 @@ describe Clamp::Command do
 
   end
 
-  describe "with parameters declared" do
+  context "with parameters declared" do
 
     before do
       command.class.parameter "X", "x\nxx"
@@ -692,58 +720,58 @@ describe Clamp::Command do
 
     describe "#parse" do
 
-      describe "with arguments for all parameters" do
+      context "with arguments for all parameters" do
 
         before do
           command.parse(["crash", "bang", "wallop"])
         end
 
         it "maps arguments onto the command object" do
-          command.x.should == "crash"
-          command.y.should == "bang"
-          command.z.should == "wallop"
+          expect(command.x).to eql "crash"
+          expect(command.y).to eql "bang"
+          expect(command.z).to eql "wallop"
         end
 
       end
 
-      describe "with insufficient arguments" do
+      context "with insufficient arguments" do
 
         it "raises a UsageError" do
-          lambda do
+          expect do
             command.parse(["crash"])
-          end.should raise_error(Clamp::UsageError, "parameter 'Y': no value provided")
+          end.to raise_error(Clamp::UsageError, "parameter 'Y': no value provided")
         end
 
       end
 
-      describe "with optional argument omitted" do
+      context "with optional argument omitted" do
 
         it "defaults the optional argument" do
           command.parse(["crash", "bang"])
-          command.x.should == "crash"
-          command.y.should == "bang"
-          command.z.should == "ZZZ"
+          expect(command.x).to eql "crash"
+          expect(command.y).to eql "bang"
+          expect(command.z).to eql "ZZZ"
         end
 
       end
 
-      describe "with multi-line arguments" do
+      context "with multi-line arguments" do
 
         it "parses them correctly" do
           command.parse(["foo\nhi", "bar", "baz"])
-          command.x.should == "foo\nhi"
-          command.y.should == "bar"
-          command.z.should == "baz"
+          expect(command.x).to eql "foo\nhi"
+          expect(command.y).to eql "bar"
+          expect(command.z).to eql "baz"
         end
 
       end
 
-      describe "with too many arguments" do
+      context "with too many arguments" do
 
         it "raises a UsageError" do
-          lambda do
+          expect do
             command.parse(["crash", "bang", "wallop", "kapow"])
-          end.should raise_error(Clamp::UsageError, "too many arguments")
+          end.to raise_error(Clamp::UsageError, "too many arguments")
         end
 
       end
@@ -753,17 +781,17 @@ describe Clamp::Command do
     describe "#help" do
 
       it "indicates that there are parameters" do
-        command.help.should include("cmd [OPTIONS] X Y [Z]")
+        expect(command.help).to include("cmd [OPTIONS] X Y [Z]")
       end
 
       it "includes parameter details" do
-        command.help.should =~ %r(X +x)
-        command.help.should =~ %r(Y +y)
-        command.help.should =~ %r(\[Z\] +z \(default: "ZZZ"\))
+        expect(command.help).to match %r(X +x)
+        expect(command.help).to match %r(Y +y)
+        expect(command.help).to match %r(\[Z\] +z \(default: "ZZZ"\))
       end
 
       it "handles new lines in option descriptions" do
-        command.help.should =~ %r(X +x\n +xx)
+        expect(command.help).to match %r(X +x\n +xx)
       end
 
     end
@@ -771,7 +799,7 @@ describe Clamp::Command do
 
   end
 
-  describe "with explicit usage" do
+  context "with explicit usage" do
 
     given_command("blah") do
 
@@ -782,14 +810,14 @@ describe Clamp::Command do
     describe "#help" do
 
       it "includes the explicit usage" do
-        command.help.should include("blah FOO BAR ...\n")
+        expect(command.help).to include("blah FOO BAR ...\n")
       end
 
     end
 
   end
 
-  describe "with multiple usages" do
+  context "with multiple usages" do
 
     given_command("put") do
 
@@ -801,15 +829,15 @@ describe Clamp::Command do
     describe "#help" do
 
       it "includes both potential usages" do
-        command.help.should include("put THIS HERE\n")
-        command.help.should include("put THAT THERE\n")
+        expect(command.help).to include("put THIS HERE\n")
+        expect(command.help).to include("put THAT THERE\n")
       end
 
     end
 
   end
 
-  describe "with a banner" do
+  context "with a banner" do
 
     given_command("punt") do
 
@@ -825,8 +853,8 @@ describe Clamp::Command do
     describe "#help" do
 
       it "includes the banner" do
-        command.help.should =~ /^  Punt is an example command/
-        command.help.should =~ /^  The prefix/
+        expect(command.help).to match /^  Punt is an example command/
+        expect(command.help).to match /^  The prefix/
       end
 
     end
@@ -844,10 +872,10 @@ describe Clamp::Command do
       end
       @xyz = %w(x y z)
       command.class.run("cmd", @xyz)
-      stdout.should == @xyz.inspect
+      expect(stdout).to eql @xyz.inspect
     end
 
-    describe "invoked with a context hash" do
+    context "invoked with a context hash" do
 
       it "makes the context available within the command" do
         command.class.class_eval do
@@ -856,12 +884,40 @@ describe Clamp::Command do
           end
         end
         command.class.run("xyz", [], :foo => "bar")
-        stdout.should == "bar"
+        expect(stdout).to eql "bar"
+      end
+
+    end
+
+    context "when there's a CommandError" do
+
+      before do
+
+        command.class.class_eval do
+          def execute
+            signal_error "Oh crap!", :status => 456
+          end
+        end
+
+        begin
+          command.class.run("cmd", [])
+        rescue SystemExit => e
+          @system_exit = e
+        end
+
+      end
+
+      it "outputs the error message" do
+        expect(stderr).to include "ERROR: Oh crap!"
+      end
+
+      it "exits with the specified status" do
+        expect(@system_exit.status).to eql 456
       end
 
     end
 
-    describe "when there's a UsageError" do
+    context "when there's a UsageError" do
 
       before do
 
@@ -880,25 +936,25 @@ describe Clamp::Command do
       end
 
       it "outputs the error message" do
-        stderr.should include "ERROR: bad dog!"
+        expect(stderr).to include "ERROR: bad dog!"
       end
 
       it "outputs help" do
-        stderr.should include "See: 'cmd --help'"
+        expect(stderr).to include "See: 'cmd --help'"
       end
 
       it "exits with a non-zero status" do
-        @system_exit.should_not be_nil
-        @system_exit.status.should == 1
+        expect(@system_exit).to_not be_nil
+        expect(@system_exit.status).to eql 1
       end
 
     end
 
-    describe "when help is requested" do
+    context "when help is requested" do
 
       it "outputs help" do
         command.class.run("cmd", ["--help"])
-        stdout.should include "Usage:"
+        expect(stdout).to include "Usage:"
       end
 
     end
@@ -919,7 +975,7 @@ describe Clamp::Command do
 
     it "inherits options from it's superclass" do
       command.parse(["--verbose"])
-      command.should be_verbose
+      expect(command).to be_verbose
     end
 
   end