diff --git a/lib/puppet/interface/option.rb b/lib/puppet/interface/option.rb
index c04c2bf67..5c75ffdd8 100644
--- a/lib/puppet/interface/option.rb
+++ b/lib/puppet/interface/option.rb
@@ -1,105 +1,106 @@
 require 'puppet/interface'
 
 class Puppet::Interface::Option
   def initialize(parent, *declaration, &block)
     @parent   = parent
     @optparse = []
 
     # Collect and sort the arguments in the declaration.
     dups = {}
     declaration.each do |item|
       if item.is_a? String and item.to_s =~ /^-/ then
         unless item =~ /^-[a-z]\b/ or item =~ /^--[^-]/ then
           raise ArgumentError, "#{item.inspect}: long options need two dashes (--)"
         end
         @optparse << item
 
         # Duplicate checking...
         name = optparse_to_name(item)
         if dup = dups[name] then
           raise ArgumentError, "#{item.inspect}: duplicates existing alias #{dup.inspect} in #{@parent}"
         else
           dups[name] = item
         end
       else
         raise ArgumentError, "#{item.inspect} is not valid for an option argument"
       end
     end
 
     if @optparse.empty? then
       raise ArgumentError, "No option declarations found while building"
     end
 
     # Now, infer the name from the options; we prefer the first long option as
     # the name, rather than just the first option.
     @name = optparse_to_name(@optparse.find do |a| a =~ /^--/ end || @optparse.first)
     @aliases = @optparse.map { |o| optparse_to_name(o) }
 
     # Do we take an argument?  If so, are we consistent about it, because
     # incoherence here makes our life super-difficult, and we can more easily
     # relax this rule later if we find a valid use case for it. --daniel 2011-03-30
     @argument = @optparse.any? { |o| o =~ /[ =]/ }
     if @argument and not @optparse.all? { |o| o =~ /[ =]/ } then
       raise ArgumentError, "Option #{@name} is inconsistent about taking an argument"
     end
 
     # Is our argument optional?  The rules about consistency apply here, also,
     # just like they do to taking arguments at all. --daniel 2011-03-30
-    @optional_argument = @optparse.any? { |o| o.include? "[" }
-    if @optional_argument and not @optparse.all? { |o| o.include? "[" } then
+    @optional_argument = @optparse.any? { |o| o=~/[ =]\[/ }
+    @optional_argument and raise ArgumentError, "Options with optional arguments are not supported"
+    if @optional_argument and not @optparse.all? { |o| o=~/[ =]\[/ } then
       raise ArgumentError, "Option #{@name} is inconsistent about the argument being optional"
     end
   end
 
   # to_s and optparse_to_name are roughly mirrored, because they are used to
   # transform options to name symbols, and vice-versa.  This isn't a full
   # bidirectional transformation though. --daniel 2011-04-07
   def to_s
     @name.to_s.tr('_', '-')
   end
 
   def optparse_to_name(declaration)
     unless found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/) then
       raise ArgumentError, "Can't find a name in the declaration #{declaration.inspect}"
     end
     name = found.captures.first.tr('-', '_')
     raise "#{name.inspect} is an invalid option name" unless name.to_s =~ /^[a-z]\w*$/
     name.to_sym
   end
 
 
   def takes_argument?
     !!@argument
   end
   def optional_argument?
     !!@optional_argument
   end
   def required?
     !!@required
   end
 
   attr_reader   :parent, :name, :aliases, :optparse
   attr_accessor :required, :desc
 
   attr_accessor :before_action
   def before_action=(proc)
     proc.is_a? Proc or raise ArgumentError, "before action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
     @before_action =
       @parent.__send__(:__decorate, :before, __decoration_name(:before), proc)
   end
 
   attr_accessor :after_action
   def after_action=(proc)
     proc.is_a? Proc or raise ArgumentError, "after action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
     @after_action =
       @parent.__send__(:__decorate, :after, __decoration_name(:after), proc)
   end
 
   def __decoration_name(type)
     if @parent.is_a? Puppet::Interface::Action then
       :"option #{name} from #{parent.name} #{type} decoration"
     else
       :"option #{name} #{type} decoration"
     end
   end
 end
diff --git a/spec/shared_behaviours/things_that_declare_options.rb b/spec/shared_behaviours/things_that_declare_options.rb
index ac358eacd..5300a159a 100755
--- a/spec/shared_behaviours/things_that_declare_options.rb
+++ b/spec/shared_behaviours/things_that_declare_options.rb
@@ -1,141 +1,145 @@
 # encoding: UTF-8
 shared_examples_for "things that declare options" do
   it "should support options without arguments" do
-    subject = add_options_to { option "--bar" }
-    subject.should be_option :bar
+    thing = add_options_to { option "--bar" }
+    thing.should be_option :bar
   end
 
   it "should support options with an empty block" do
-    subject = add_options_to do
+    thing = add_options_to do
       option "--foo" do
         # this section deliberately left blank
       end
     end
-    subject.should be
-    subject.should be_option :foo
+    thing.should be
+    thing.should be_option :foo
   end
 
   { "--foo=" => :foo }.each do |input, option|
     it "should accept #{name.inspect}" do
-      subject = add_options_to { option input }
-      subject.should be_option option
+      thing = add_options_to { option input }
+      thing.should be_option option
     end
   end
 
   it "should support option documentation" do
     text = "Sturm und Drang (German pronunciation: [ˈʃtʊʁm ʊnt ˈdʁaŋ]) …"
 
-    subject = add_options_to do
+    thing = add_options_to do
       option "--foo" do
         desc text
       end
     end
 
-    subject.get_option(:foo).desc.should == text
+    thing.get_option(:foo).desc.should == text
   end
 
   it "should list all the options" do
-    subject = add_options_to do
+    thing = add_options_to do
       option "--foo"
       option "--bar"
     end
-    subject.options.should =~ [:foo, :bar]
+    thing.options.should =~ [:foo, :bar]
   end
 
   it "should detect conflicts in long options" do
     expect {
       add_options_to do
         option "--foo"
         option "--foo"
       end
     }.should raise_error ArgumentError, /Option foo conflicts with existing option foo/i
   end
 
   it "should detect conflicts in short options" do
     expect {
       add_options_to do
         option "-f"
         option "-f"
       end
     }.should raise_error ArgumentError, /Option f conflicts with existing option f/
   end
 
   ["-f", "--foo"].each do |option|
     ["", " FOO", "=FOO", " [FOO]", "=[FOO]"].each do |argument|
       input = option + argument
       it "should detect conflicts within a single option like #{input.inspect}" do
         expect {
           add_options_to do
             option input, input
           end
         }.should raise_error ArgumentError, /duplicates existing alias/
       end
     end
   end
 
 
   # Verify the range of interesting conflicts to check for ordering causing
   # the behaviour to change, or anything exciting like that.
   [ %w{--foo}, %w{-f}, %w{-f --foo}, %w{--baz -f},
     %w{-f --baz}, %w{-b --foo}, %w{--foo -b}
   ].each do |conflict|
     base = %w{--foo -f}
     it "should detect conflicts between #{base.inspect} and #{conflict.inspect}" do
       expect {
         add_options_to do
           option *base
           option *conflict
         end
       }.should raise_error ArgumentError, /conflicts with existing option/
     end
   end
 
   it "should fail if we are not consistent about taking an argument" do
     expect { add_options_to do option "--foo=bar", "--bar" end }.
       should raise_error ArgumentError, /inconsistent about taking an argument/
   end
 
-  it "should accept optional arguments" do
-    subject = add_options_to do option "--foo=[baz]", "--bar=[baz]" end
-    [:foo, :bar].each do |name|
-      subject.should be_option name
-    end
+  it "should not accept optional arguments" do
+    expect do
+      thing = add_options_to do option "--foo=[baz]", "--bar=[baz]" end
+      [:foo, :bar].each do |name|
+        thing.should be_option name
+      end
+    end.to raise_error(ArgumentError, /optional arguments are not supported/)
   end
 
   describe "#takes_argument?" do
     it "should detect an argument being absent" do
-      subject = add_options_to do option "--foo" end
-      subject.get_option(:foo).should_not be_takes_argument
+      thing = add_options_to do option "--foo" end
+      thing.get_option(:foo).should_not be_takes_argument
     end
-    ["=FOO", " FOO", "=[FOO]", " [FOO]"].each do |input|
+    ["=FOO", " FOO"].each do |input|
       it "should detect an argument given #{input.inspect}" do
-        subject = add_options_to do option "--foo#{input}" end
-        subject.get_option(:foo).should be_takes_argument
+        thing = add_options_to do option "--foo#{input}" end
+        thing.get_option(:foo).should be_takes_argument
       end
     end
   end
 
   describe "#optional_argument?" do
     it "should be false if no argument is present" do
       option = add_options_to do option "--foo" end.get_option(:foo)
       option.should_not be_takes_argument
       option.should_not be_optional_argument
     end
 
     ["=FOO", " FOO"].each do |input|
       it "should be false if the argument is mandatory (like #{input.inspect})" do
         option = add_options_to do option "--foo#{input}" end.get_option(:foo)
       option.should be_takes_argument
       option.should_not be_optional_argument
       end
     end
 
     ["=[FOO]", " [FOO]"].each do |input|
-      it "should be true if the argument is optional (like #{input.inspect})" do
-        option = add_options_to do option "--foo#{input}" end.get_option(:foo)
-      option.should be_takes_argument
-      option.should be_optional_argument
+      it "should fail if the argument is optional (like #{input.inspect})" do
+        expect do
+          option = add_options_to do option "--foo#{input}" end.get_option(:foo)
+          option.should be_takes_argument
+          option.should be_optional_argument
+        end.to raise_error(ArgumentError, /optional arguments are not supported/)
       end
     end
   end
 end
diff --git a/spec/unit/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index eaf60b434..7e13d4be6 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -1,218 +1,217 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
 
 class Puppet::Application::FaceBase::Basetest < Puppet::Application::FaceBase
 end
 
 describe Puppet::Application::FaceBase do
   before :all do
     Puppet::Face.define(:basetest, '0.0.1') do
       option("--[no-]boolean")
       option("--mandatory MANDATORY")
-      option("--optional [OPTIONAL]")
 
       action :foo do
         option("--action")
         when_invoked { |*args| args.length }
       end
     end
   end
 
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
     app.command_line.stubs(:subcommand_name).returns('subcommand')
     Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
       app.find_global_settings_argument("--ca-location").should be_nil
     end
   end
 
   describe "#parse_options" do
     before :each do
       app.command_line.stubs(:args).returns %w{}
     end
 
     describe "parsing the command line" do
       context "with just an action" do
         before :all do
           # We have to stub Signal.trap to avoid a crazy mess where we take
           # over signal handling and make it impossible to cancel the test
           # suite run.
           #
           # It would be nice to fix this elsewhere, but it is actually hard to
           # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
           Signal.stubs(:trap)
           app.command_line.stubs(:args).returns %w{foo}
           app.preinit
           app.parse_options
         end
 
         it "should set the face based on the type" do
           app.face.name.should == :basetest
         end
 
         it "should set the format based on the face default" do
           app.format.should == :pson
         end
 
         it "should find the action" do
           app.action.should be
           app.action.name.should == :foo
         end
       end
 
       it "should use the default action if not given any arguments" do
         app.command_line.stubs(:args).returns []
         action = stub(:options => [])
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
         app.stubs(:main)
         app.run
         app.action.should == action
         app.arguments.should == [ { } ]
       end
 
       it "should use the default action if not given a valid one" do
         app.command_line.stubs(:args).returns %w{bar}
         action = stub(:options => [])
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
         app.stubs(:main)
         app.run
         app.action.should == action
         app.arguments.should == [ 'bar', { } ]
       end
 
       it "should have no action if not given a valid one and there is no default action" do
         app.command_line.stubs(:args).returns %w{bar}
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
         app.run
         app.action.should be_nil
         app.arguments.should == [ 'bar', { } ]
       end
 
       it "should report a sensible error when options with = fail" do
         app.command_line.stubs(:args).returns %w{--action=bar foo}
         expect { app.preinit; app.parse_options }.
           to raise_error OptionParser::InvalidOption, /invalid option: --action/
       end
 
       it "should fail if an action option is before the action" do
         app.command_line.stubs(:args).returns %w{--action foo}
         expect { app.preinit; app.parse_options }.
           to raise_error OptionParser::InvalidOption, /invalid option: --action/
       end
 
       it "should fail if an unknown option is before the action" do
         app.command_line.stubs(:args).returns %w{--bar foo}
         expect { app.preinit; app.parse_options }.
           to raise_error OptionParser::InvalidOption, /invalid option: --bar/
       end
 
       it "should fail if an unknown option is after the action" do
         app.command_line.stubs(:args).returns %w{foo --bar}
         expect { app.preinit; app.parse_options }.
           to raise_error OptionParser::InvalidOption, /invalid option: --bar/
       end
 
       it "should accept --bar as an argument to a mandatory option after action" do
         app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
         app.preinit
         app.parse_options
         app.action.name.should == :foo
         app.options.should == { :mandatory => "--bar" }
       end
 
       it "should accept --bar as an argument to a mandatory option before action" do
         app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
         app.preinit
         app.parse_options
         app.action.name.should == :foo
         app.options.should == { :mandatory => "--bar" }
       end
 
       it "should not skip when --foo=bar is given" do
         app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
         expect { app.preinit; app.parse_options }.
           to raise_error OptionParser::InvalidOption, /invalid option: --bar/
       end
 
       { "boolean options before" => %w{--trace foo},
         "boolean options after"  => %w{foo --trace}
       }.each do |name, args|
         it "should accept global boolean settings #{name} the action" do
           app.command_line.stubs(:args).returns args
           app.preinit
           app.parse_options
           Puppet[:trace].should be_true
         end
       end
 
       { "before" => %w{--syslogfacility user1 foo},
         " after" => %w{foo --syslogfacility user1}
       }.each do |name, args|
         it "should accept global settings with arguments #{name} the action" do
           app.command_line.stubs(:args).returns args
           app.preinit
           app.parse_options
           Puppet[:syslogfacility].should == "user1"
         end
       end
     end
   end
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == [{ :mandatory => "--bar" }]
     end
 
     it "should pass positional arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo bar baz quux}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
     end
   end
 
   describe "#main" do
     before :each do
       app.expects(:exit).with(0)
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
       app.format    = :pson
       app.arguments = ["myname", "myarg"]
     end
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
       app.main
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
       Puppet::Face[:help, :current].expects(:help).with(:basetest, *app.arguments)
       app.stubs(:puts)          # meh.  Don't print nil, thanks. --daniel 2011-04-12
       app.main
     end
 
     it "should use its render method to render any result" do
       app.expects(:render).with(app.arguments.length + 1)
       app.stubs(:puts)          # meh.  Don't print nil, thanks. --daniel 2011-04-12
       app.main
     end
   end
 end