cli 1.3.1 → 1.4.0

data/spec/option_spec.rb

@@ -6,56 +6,56 @@ describe CLI do
 			ps = CLI.new do
 				option :location
 			end.parse(['--location', 'singapore'])
-			ps.location.should be_a String
-			ps.location.should == 'singapore'
+      expect(ps.location).to be_a String
+      expect(ps.location).to eq 'singapore'
 		end
 
 		it "should handle short option names" do
 			ps = CLI.new do
 				option :location, :short => :l
 			end.parse(['-l', 'singapore'])
-			ps.location.should be_a String
-			ps.location.should == 'singapore'
+      expect(ps.location).to be_a String
+      expect(ps.location).to eq 'singapore'
 		end
 
 		it "should support casting" do
 			ps = CLI.new do
 				option :size, :cast => Integer
 			end.parse(['--size', '24'])
-			ps.size.should be_a Integer
-			ps.size.should == 24
+      expect(ps.size).to be_a Integer
+      expect(ps.size).to eq 24
 		end
 
 		it "casting should fail if not proper integer given" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :size, :cast => Integer
 				end.parse(['--size', '24.99'])
-			}.should raise_error(CLI::ParsingError::CastError)
+			}.to raise_error(CLI::ParsingError::CastError)
 		end
 
 		it "casting should fail if not proper float given" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :size, :cast => Float
 				end.parse(['--size', '24.99x'])
-			}.should raise_error(CLI::ParsingError::CastError)
+			}.to raise_error(CLI::ParsingError::CastError)
 		end
 
 		it "casting should fail if there is error in cast lambda" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :size, :cast => lambda{|v| fail 'test'}
 				end.parse(['--size', '24.99x'])
-			}.should raise_error(CLI::ParsingError::CastError)
+			}.to raise_error(CLI::ParsingError::CastError)
 		end
 
 		it "should support casting of multiple options" do
 			ps = CLI.new do
 				options :size, :cast => Integer
 			end.parse(['--size', '24', '--size', '10'])
-			ps.size.should be_a Array
-			ps.size.should == [24, 10]
+      expect(ps.size).to be_a Array
+      expect(ps.size).to eq [24, 10]
 		end
 
 		it "should support casting of multiple options with default" do
@@ -63,22 +63,22 @@ describe CLI do
 				options :log_file, :cast => Pathname, :default => 'test.log'
 			end.parse(['--log-file', 'server.log', '--log-file', 'error.log'])
 
-			ps.log_file.should be_a Array
-			ps.log_file.length.should == 2
+      expect(ps.log_file).to be_a Array
+      expect(ps.log_file.length).to eq 2
 
-			ps.log_file.first.should be_a Pathname
-			ps.log_file.first.to_s.should == 'server.log'
+      expect(ps.log_file.first).to be_a Pathname
+      expect(ps.log_file.first.to_s).to eq 'server.log'
 
-			ps.log_file.last.should be_a Pathname
-			ps.log_file.last.to_s.should == 'error.log'
+      expect(ps.log_file.last).to be_a Pathname
+      expect(ps.log_file.last.to_s).to eq 'error.log'
 		end
 
 		it "should support casting with lambda" do
 			ps = CLI.new do
 				option :size, :cast => lambda{|v| v.to_i + 2}
 			end.parse(['--size', '24'])
-			ps.size.should be_a Integer
-			ps.size.should == 26
+      expect(ps.size).to be_a Integer
+      expect(ps.size).to eq 26
 		end
 
 		it "should support casting with class" do
@@ -92,8 +92,8 @@ describe CLI do
 			ps = CLI.new do
 				option :text, :cast => Upcaser
 			end.parse(['--text', 'hello world'])
-			ps.text.should be_a Upcaser
-			ps.text.value.should == 'HELLO WORLD'
+      expect(ps.text).to be_a Upcaser
+      expect(ps.text.value).to eq 'HELLO WORLD'
 		end
 
 		it "should handle default values" do
@@ -101,10 +101,10 @@ describe CLI do
 				option :location, :default => 'singapore'
 				option :size, :cast => Integer, :default => 23
 			end.parse([])
-			ps.location.should be_a String
-			ps.location.should == 'singapore'
-			ps.size.should be_a Integer
-			ps.size.should == 23
+      expect(ps.location).to be_a String
+      expect(ps.location).to eq 'singapore'
+      expect(ps.size).to be_a Integer
+      expect(ps.size).to eq 23
 		end
 
 		it "default value is casted" do
@@ -112,25 +112,25 @@ describe CLI do
 				option :location, :default => 'singapore'
 				option :size, :cast => Integer, :default => 23
 			end.parse([])
-			ps.location.should be_a String
-			ps.location.should == 'singapore'
-			ps.size.should be_a Integer
-			ps.size.should == 23
+      expect(ps.location).to be_a String
+      expect(ps.location).to eq 'singapore'
+      expect(ps.size).to be_a Integer
+      expect(ps.size).to eq 23
 		end
 
 		it "not given and not defined options should be nil" do
 			ps = CLI.new do
 				option :size, :cast => Integer
 			end.parse([])
-			ps.size.should be_nil
-			ps.gold.should be_nil
+      expect(ps.size).to be_nil
+      expect(ps.gold).to be_nil
 		end
 
 		it "not given option that can be specified multiple times should be an empty array" do
 			ps = CLI.new do
 				options :size, :cast => Integer
 			end.parse([])
-			ps.size.should == []
+      expect(ps.size).to eq []
 		end
 
 		it "should handle multiple long and short intermixed options" do
@@ -142,62 +142,62 @@ describe CLI do
 				option :not_given
 				option :size
 			end.parse(['-l', 'singapore', '--power-up', 'yes', '-s', '24', '--size', 'XXXL'])
-			ps.group.should == 'red'
-			ps.power_up.should == 'yes'
-			ps.speed.should == 24
-			ps.not_given.should be_nil
-			ps.size.should == 'XXXL'
-			ps.gold.should be_nil
+      expect(ps.group).to eq 'red'
+      expect(ps.power_up).to eq 'yes'
+      expect(ps.speed).to eq 24
+      expect(ps.not_given).to be_nil
+      expect(ps.size).to eq 'XXXL'
+      expect(ps.gold).to be_nil
 		end
 
 		it "should support options that can be specified multiple times" do
 			ps = CLI.new do
 				options :power_up, :short => :p
 			end.parse(['--power-up', 'fire'])
-			ps.power_up.should == ['fire']
+      expect(ps.power_up).to eq ['fire']
 
 			ps = CLI.new do
 				options :power_up, :short => :p
 			end.parse(['--power-up', 'fire', '-p', 'water', '--power-up', 'air', '-p', 'ground'])
-			ps.power_up.should == ['fire', 'water', 'air', 'ground']
+      expect(ps.power_up).to eq ['fire', 'water', 'air', 'ground']
 		end
 
 		it "should support options that can be specified multiple times can have single default" do
 			ps = CLI.new do
 				options :power_up, :short => :p, :default => 'fire'
 			end.parse([])
-			ps.power_up.should == ['fire']
+      expect(ps.power_up).to eq ['fire']
 		end
 
 		it "should support options that can be specified multiple times can have multiple defaults" do
 			ps = CLI.new do
 				options :power_up, :short => :p, :default => ['fire', 'air']
 			end.parse([])
-			ps.power_up.should == ['fire', 'air']
+      expect(ps.power_up).to eq ['fire', 'air']
 		end
 
 		it "should raise error if not symbol and optional hash is passed" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					option 'number'
 				end
-			}.should raise_error CLI::ParserError::NameArgumetNotSymbolError, "option name has to be of type Symbol, got String"
+			}.to raise_error CLI::ParserError::NameArgumetNotSymbolError, "option name has to be of type Symbol, got String"
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :number, :test
 				end
-			}.should raise_error CLI::ParserError::OptionsArgumentNotHashError, "option options has to be of type Hash, got Symbol"
+			}.to raise_error CLI::ParserError::OptionsArgumentNotHashError, "option options has to be of type Hash, got Symbol"
 		end
 
 		it "should raise error on missing option argument" do
 			ps = CLI.new do
 				option :location
 			end
-			
-			lambda {
+
+			expect {
 				ps.parse(['--location'])
-			}.should raise_error CLI::ParsingError::MissingOptionValueError, 'missing value for option --location'
+			}.to raise_error CLI::ParsingError::MissingOptionValueError, 'missing value for option --location'
 		end
 
 		it "should raise error on missing mandatory option" do
@@ -208,10 +208,10 @@ describe CLI do
 				option :group, :default => 'red'
 				option :speed, :short => :s, :cast => Integer
 			end
-			
-			lambda {
+
+			expect {
 				ps.parse([])
-			}.should raise_error CLI::ParsingError::MandatoryOptionsNotSpecifiedError, "mandatory options not specified: --size, --weight"
+			}.to raise_error CLI::ParsingError::MandatoryOptionsNotSpecifiedError, "mandatory options not specified: --size, --weight"
 		end
 
 		it "by default option value should be nil" do
@@ -221,15 +221,14 @@ describe CLI do
 				option :weight, :required => true
 				option :group, :default => 'red'
 			end
-			
+
 			o = ps.parse(['--weight', '123'])
 
-			o.location.should be_nil
-			o.speed.should be_nil
+      expect(o.location).to be_nil
+      expect(o.speed).to be_nil
 
-			o.weight.should == '123'
-			o.group.should == 'red'
+      expect(o.weight).to eq '123'
+      expect(o.group).to eq 'red'
 		end
 	end
 end
-

data/spec/separator_spec.rb

@@ -11,12 +11,12 @@ describe CLI do
 				argument :test
 			end.parse(['-l', 'singapore', '--debug', '--', '--verbose'])
 
-			ps.help.should be_nil
-			ps.location.should == 'singapore'
-			ps.group.should == 'red'
-			ps.debug.should be_true
-			ps.test.should == '--verbose'
-			ps.verbose.should be_nil
+      expect(ps.help).to be_nil
+      expect(ps.location).to eq 'singapore'
+      expect(ps.group).to eq 'red'
+      expect(ps.debug).to be true
+      expect(ps.test).to eq '--verbose'
+      expect(ps.verbose).to be_nil
 
 			ps = CLI.new do
 				option :location, :short => :l
@@ -26,11 +26,11 @@ describe CLI do
 				argument :test
 			end.parse(['-l', 'singapore', '--debug', '--help'])
 
-			ps.location.should be_nil
-			ps.group.should be_nil
-			ps.debug.should be_nil
-			ps.verbose.should be_nil
-			ps.help.should_not be_nil
+      expect(ps.location).to be_nil
+      expect(ps.group).to be_nil
+      expect(ps.debug).to be_nil
+      expect(ps.verbose).to be_nil
+      expect(ps.help).not_to be_nil
 
 			ps = CLI.new do
 				option :location, :short => :l
@@ -43,15 +43,14 @@ describe CLI do
 				argument :test3
 			end.parse(['-l', 'singapore', '--debug', '--', '--help', '--version', '-m'])
 
-			ps.help.should be_nil
-			ps.location.should == 'singapore'
-			ps.group.should == 'red'
-			ps.debug.should be_true
-			ps.test.should == '--help'
-			ps.test2.should == '--version'
-			ps.test3.should == '-m'
-			ps.verbose.should be_nil
+      expect(ps.help).to be_nil
+      expect(ps.location).to eq 'singapore'
+      expect(ps.group).to eq 'red'
+      expect(ps.debug).to be true
+      expect(ps.test).to eq '--help'
+      expect(ps.test2).to eq '--version'
+      expect(ps.test3).to eq '-m'
+      expect(ps.verbose).to be_nil
 		end
 	end
 end
-

data/spec/stdin_spec.rb

@@ -5,23 +5,23 @@ describe CLI do
 	describe 'STDIN handling' do
 		before :all do
 			@yaml = <<EOF
---- 
-:parser: 
+---
+:parser:
   :successes: 41
   :failures: 0
 EOF
 		end
 
 		it "should be nil if not specified" do
-			ps = CLI.new.parse
-			ps.stdin.should be_nil
+			ps = CLI.new.parse([])
+      expect(ps.stdin).to be_nil
 		end
 
 		it "should return IO if stdin is defined" do
 			ps = CLI.new do
 				stdin
-			end.parse
-			ps.stdin.should be_a IO
+			end.parse([])
+      expect(ps.stdin).to be_a IO
 		end
 
 		it "should support casting to module responding to load" do
@@ -31,10 +31,10 @@ EOF
 			end
 
 			stdin_write(@yaml) do
-				ps = ss.parse
+				ps = ss.parse([])
 			end
 
-			ps.stdin.should == {:parser=>{:successes=>41, :failures=>0}}
+      expect(ps.stdin).to eq({:parser=>{:successes=>41, :failures=>0}})
 		end
 
 		it "should support casting with lambda" do
@@ -44,10 +44,10 @@ EOF
 			end
 
 			stdin_write('hello world') do
-				ps = ss.parse
+				ps = ss.parse([])
 			end
 
-			ps.stdin.should == 'HELLO WORLD'
+      expect(ps.stdin).to eq 'HELLO WORLD'
 		end
 
 		it "should support casting with custom class" do
@@ -64,12 +64,11 @@ EOF
 			end
 
 			stdin_write('hello world') do
-				ps = ss.parse
+				ps = ss.parse([])
 			end
 
-			ps.stdin.should be_a Upcaser
-			ps.stdin.value.should == 'HELLO WORLD'
+      expect(ps.stdin).to be_a Upcaser
+      expect(ps.stdin.value).to eq 'HELLO WORLD'
 		end
 	end
 end
-

data/spec/switch_spec.rb

@@ -7,8 +7,8 @@ describe CLI do
 				switch :location
 				switch :unset
 			end.parse(['--location'])
-			ps.location.should be_true
-			ps.unset.should be_nil
+      expect(ps.location).to be true
+      expect(ps.unset).to be_nil
 		end
 
 		it "should handle short switch names" do
@@ -16,47 +16,46 @@ describe CLI do
 				switch :location, :short => :l
 				switch :unset, :short => :u
 			end.parse(['-l'])
-			ps.location.should be_true
-			ps.unset.should be_nil
+      expect(ps.location).to be true
+      expect(ps.unset).to be_nil
 		end
 
 		it "should raise error if not symbol and optional hash is passed" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch 'number'
 				end.parse([])
-			}.should raise_error CLI::ParserError::NameArgumetNotSymbolError, "switch name has to be of type Symbol, got String"
+			}.to raise_error CLI::ParserError::NameArgumetNotSymbolError, "switch name has to be of type Symbol, got String"
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch :number, :test
 				end
-			}.should raise_error CLI::ParserError::OptionsArgumentNotHashError, "switch options has to be of type Hash, got Symbol"
+			}.to raise_error CLI::ParserError::OptionsArgumentNotHashError, "switch options has to be of type Hash, got Symbol"
 		end
 
 		it "shoud raise error is short name is invalid" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch :location, :short => "l"
 				end
-			}.should raise_error CLI::ParserError::ShortNameNotSymbolError, 'short name for --location has to be of type Symbol, got String'
+			}.to raise_error CLI::ParserError::ShortNameNotSymbolError, 'short name for --location has to be of type Symbol, got String'
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch :location, :short => :abc
 				end
-			}.should raise_error CLI::ParserError::ShortNameIsInvalidError, 'short name for --location has to be one letter symbol, got :abc'
+			}.to raise_error CLI::ParserError::ShortNameIsInvalidError, 'short name for --location has to be one letter symbol, got :abc'
 		end
 
 		it "should raise error on unrecognized switch" do
 			ps = CLI.new do
 				option :location
 			end
-			
-			lambda {
+
+			expect {
 				ps.parse(['--xxx'])
-			}.should raise_error CLI::ParsingError::UnknownSwitchError, 'unknown switch --xxx'
+			}.to raise_error CLI::ParsingError::UnknownSwitchError, 'unknown switch --xxx'
 		end
 	end
 end
-