cli 1.3.1 → 1.4.0

data/spec/argument_spec.rb

@@ -6,97 +6,97 @@ describe CLI do
 			ps = CLI.new do
 				argument :log
 			end.parse(['/tmp'])
-			ps.log.should be_a String
-			ps.log.should == '/tmp'
+      expect(ps.log).to be_a String
+      expect(ps.log).to eq '/tmp'
 		end
 
 		it "should cast mandatory argument" do
 			ps = CLI.new do
 				argument :log, :cast => Pathname
 			end.parse(['/tmp'])
-			ps.log.should be_a Pathname
-			ps.log.to_s.should == '/tmp'
+      expect(ps.log).to be_a Pathname
+      expect(ps.log.to_s).to eq '/tmp'
 		end
 
 		it "should cast mandatory argument to numerical class" do
 			ps = CLI.new do
 				argument :number, :cast => Integer
 			end.parse(['123'])
-			ps.number.should be_a Integer
-			ps.number.should == 123
+      expect(ps.number).to be_a Integer
+      expect(ps.number).to eq 123
 
 			ps = CLI.new do
 				argument :number, :cast => Float
 			end.parse(['123'])
-			ps.number.should be_a Float
-			ps.number.should == 123.0
+      expect(ps.number).to be_a Float
+      expect(ps.number).to eq 123.0
 		end
 
 		it "casting should fail if not proper integer given" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					argument :size, :cast => Integer
 				end.parse(['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
 					argument :size, :cast => Float
 				end.parse(['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
 					argument :size, :cast => lambda{|v| fail 'test'}
 				end.parse(['24.99x'])
-			}.should raise_error(CLI::ParsingError::CastError)
+			}.to raise_error(CLI::ParsingError::CastError)
 		end
 
 		it "should cast default value" do
 			ps = CLI.new do
 				argument :number, :cast => Integer, :default => '123'
 			end.parse([])
-			ps.number.should be_a Integer
-			ps.number.should == 123
+      expect(ps.number).to be_a Integer
+      expect(ps.number).to eq 123
 		end
 
 		it "should cast value of multiple arguments argument" do
 			ps = CLI.new do
 				arguments :numbers, :cast => Integer
 			end.parse(['1', '2', '3'])
-			ps.numbers.should be_a Array
-			ps.numbers[0].should be_a Integer
-			ps.numbers[0].should == 1
-			ps.numbers[1].should be_a Integer
-			ps.numbers[1].should == 2
-			ps.numbers[2].should be_a Integer
-			ps.numbers[2].should == 3
+      expect(ps.numbers).to be_a Array
+      expect(ps.numbers[0]).to be_a Integer
+      expect(ps.numbers[0]).to eq 1
+      expect(ps.numbers[1]).to be_a Integer
+      expect(ps.numbers[1]).to eq 2
+      expect(ps.numbers[2]).to be_a Integer
+      expect(ps.numbers[2]).to eq 3
 		end
 
 		it "should cast single default value of multiple arguments argument" do
 			ps = CLI.new do
 				arguments :numbers, :cast => Integer, :default => '1'
 			end.parse([])
-			ps.numbers.should be_a Array
-			ps.numbers[0].should be_a Integer
-			ps.numbers[0].should == 1
+      expect(ps.numbers).to be_a Array
+      expect(ps.numbers[0]).to be_a Integer
+      expect(ps.numbers[0]).to eq 1
 		end
 
 		it "should cast default value array of multiple arguments argument" do
 			ps = CLI.new do
 				arguments :numbers, :cast => Integer, :default => ['1', '2', '3']
 			end.parse([])
-			ps.numbers.should be_a Array
-			ps.numbers[0].should be_a Integer
-			ps.numbers[0].should == 1
-			ps.numbers[1].should be_a Integer
-			ps.numbers[1].should == 2
-			ps.numbers[2].should be_a Integer
-			ps.numbers[2].should == 3
+      expect(ps.numbers).to be_a Array
+      expect(ps.numbers[0]).to be_a Integer
+      expect(ps.numbers[0]).to eq 1
+      expect(ps.numbers[1]).to be_a Integer
+      expect(ps.numbers[1]).to eq 2
+      expect(ps.numbers[2]).to be_a Integer
+      expect(ps.numbers[2]).to eq 3
 		end
 
 		it "should handle multiple arguments" do
@@ -104,10 +104,10 @@ describe CLI do
 				argument :log, :cast => Pathname
 				argument :test
 			end.parse(['/tmp', 'hello'])
-			ps.log.should be_a Pathname
-			ps.log.to_s.should == '/tmp'
-			ps.test.should be_a String
-			ps.test.should == 'hello'
+      expect(ps.log).to be_a Pathname
+      expect(ps.log.to_s).to eq '/tmp'
+      expect(ps.test).to be_a String
+      expect(ps.test).to eq 'hello'
 		end
 
 		it "should handle multi arguments" do
@@ -115,63 +115,63 @@ describe CLI do
 				argument :log, :cast => Pathname
 				arguments :words
 			end.parse(['/tmp', 'hello', 'world', 'test'])
-			ps.log.should be_a Pathname
-			ps.log.to_s.should == '/tmp'
+      expect(ps.log).to be_a Pathname
+      expect(ps.log.to_s).to eq '/tmp'
 
-			ps.words.should be_a Array
-			ps.words[0].should == 'hello'
-			ps.words[1].should == 'world'
-			ps.words[2].should == 'test'
+      expect(ps.words).to be_a Array
+      expect(ps.words[0]).to eq 'hello'
+      expect(ps.words[1]).to eq 'world'
+      expect(ps.words[2]).to eq 'test'
 		end
 
 		it "should raise error if not symbol and optional hash is passed" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					argument 'number'
 				end
-			}.should raise_error CLI::ParserError::NameArgumetNotSymbolError, "argument name has to be of type Symbol, got String"
+			}.to raise_error CLI::ParserError::NameArgumetNotSymbolError, "argument name has to be of type Symbol, got String"
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					argument :number, :test
 				end
-			}.should raise_error CLI::ParserError::OptionsArgumentNotHashError, "argument options has to be of type Hash, got Symbol"
+			}.to raise_error CLI::ParserError::OptionsArgumentNotHashError, "argument options has to be of type Hash, got Symbol"
 		end
 
 		it "should raise error if artument name is specified twice" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					argument :number
 					argument :number
 				end
-			}.should raise_error CLI::ParserError::ArgumentNameSpecifiedTwice, "argument 'number' specified twice"
+			}.to raise_error CLI::ParserError::ArgumentNameSpecifiedTwice, "argument 'number' specified twice"
 		end
 
 		it "should be required by default and raise error if not given" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					argument :log
 				end.parse([])
-			}.should raise_error CLI::ParsingError::MandatoryArgumentNotSpecifiedError, "mandatory argument 'log' not given"
+			}.to raise_error CLI::ParsingError::MandatoryArgumentNotSpecifiedError, "mandatory argument 'log' not given"
 		end
 
 		it "should raise error if casting fail" do
 			require 'ip'
-			lambda {
+			expect {
 				ps = CLI.new do
 					argument :log, :cast => IP
 				end.parse(['abc'])
-			}.should raise_error CLI::ParsingError::CastError, "failed to cast: 'log' to type: IP: invalid address"
+			}.to raise_error CLI::ParsingError::CastError, "failed to cast: 'log' to type: IP: invalid address"
 		end
 
 		it "should raise error if multiple artuments argument defined twice" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					arguments :test1
 					argument :test2
 					arguments :test3
 				end
-			}.should raise_error CLI::ParserError::MultipleArgumentsSpecifierError, "only one 'arguments' specifier can be used, got: test1, test3"
+			}.to raise_error CLI::ParserError::MultipleArgumentsSpecifierError, "only one 'arguments' specifier can be used, got: test1, test3"
 		end
 
 		describe "with defaults" do
@@ -183,11 +183,11 @@ describe CLI do
 					argument :test4, :default => 'd'
 					argument :test5, :default => 'e'
 				end.parse(['a', 'b'])
-				ps.test1.should == 'a'
-				ps.test2.should == 'b'
-				ps.test3.should == 'c'
-				ps.test4.should == 'd'
-				ps.test5.should == 'e'
+        expect(ps.test1).to eq 'a'
+        expect(ps.test2).to eq 'b'
+        expect(ps.test3).to eq 'c'
+        expect(ps.test4).to eq 'd'
+        expect(ps.test5).to eq 'e'
 
 				ps = CLI.new do
 					argument :log, :cast => Pathname
@@ -195,10 +195,10 @@ describe CLI do
 					argument :test
 					argument :code, :cast => Integer, :default => '123'
 				end.parse(['/tmp', 'hello', 'world'])
-				ps.log.to_s.should == '/tmp'
-				ps.magick.should == 'hello'
-				ps.test.should == 'world'
-				ps.code.should == 123
+        expect(ps.log.to_s).to eq '/tmp'
+        expect(ps.magick).to eq 'hello'
+        expect(ps.test).to eq 'world'
+        expect(ps.code).to eq 123
 			end
 
 			it "should fill multiple argumets argument with remaining arguments after filling mandatory and default arguments" do
@@ -211,12 +211,12 @@ describe CLI do
 					argument :code, :cast => Integer, :default => '123'
 				end.parse(['/tmp', 'number', 'test', 'hello', 'world', 'abc', 'test2', '42'])
 
-				ps.log.to_s.should == '/tmp'
-				ps.magick.should == 'number'
-				ps.test.should == 'test'
-				ps.words.should == ['hello', 'world', 'abc']
-				ps.test2.should == 'test2'
-				ps.code.should == 42
+        expect(ps.log.to_s).to eq '/tmp'
+        expect(ps.magick).to eq 'number'
+        expect(ps.test).to eq 'test'
+        expect(ps.words).to eq ['hello', 'world', 'abc']
+        expect(ps.test2).to eq 'test2'
+        expect(ps.code).to eq 42
 			end
 
 			it "should use default single value for multiple arguments argument when not enought arguments given" do
@@ -229,12 +229,12 @@ describe CLI do
 					argument :code, :cast => Integer, :default => '123'
 				end.parse(['/tmp', 'test', 'test2'])
 
-				ps.log.to_s.should == '/tmp'
-				ps.magick.should == 'word'
-				ps.test.should == 'test'
-				ps.words.should == ['hello']
-				ps.test2.should == 'test2'
-				ps.code.should == 123
+        expect(ps.log.to_s).to eq '/tmp'
+        expect(ps.magick).to eq 'word'
+        expect(ps.test).to eq 'test'
+        expect(ps.words).to eq ['hello']
+        expect(ps.test2).to eq 'test2'
+        expect(ps.code).to eq 123
 			end
 
 			it "should use default array of values for multiple arguments argument when not enought arguments given" do
@@ -247,12 +247,12 @@ describe CLI do
 					argument :code, :cast => Integer, :default => '123'
 				end.parse(['/tmp', 'test', 'test2'])
 
-				ps.log.to_s.should == '/tmp'
-				ps.magick.should == 'word'
-				ps.test.should == 'test'
-				ps.words.should == ['hello', 'world', 'abc']
-				ps.test2.should == 'test2'
-				ps.code.should == 123
+        expect(ps.log.to_s).to eq '/tmp'
+        expect(ps.magick).to eq 'word'
+        expect(ps.test).to eq 'test'
+        expect(ps.words).to eq ['hello', 'world', 'abc']
+        expect(ps.test2).to eq 'test2'
+        expect(ps.code).to eq 123
 			end
 
 			it "should fill at least one value of required multiple arguments argument" do
@@ -263,11 +263,11 @@ describe CLI do
 					argument :test4, :default => 'd'
 					argument :test5, :default => 'e'
 				end.parse(['a', 'c'])
-				ps.test1.should == 'a'
-				ps.test2.should == 'b'
-				ps.test3.should == ['c']
-				ps.test4.should == 'd'
-				ps.test5.should == 'e'
+        expect(ps.test1).to eq 'a'
+        expect(ps.test2).to eq 'b'
+        expect(ps.test3).to eq ['c']
+        expect(ps.test4).to eq 'd'
+        expect(ps.test5).to eq 'e'
 			end
 		end
 
@@ -280,19 +280,19 @@ describe CLI do
 					argument :test4, :required => false
 					argument :test5, :required => false
 				end.parse(['a', 'b'])
-				ps.test1.should == 'a'
-				ps.test2.should == 'b'
-				ps.test3.should be_nil
-				ps.test4.should be_nil
-				ps.test5.should be_nil
+        expect(ps.test1).to eq 'a'
+        expect(ps.test2).to eq 'b'
+        expect(ps.test3).to be_nil
+        expect(ps.test4).to be_nil
+        expect(ps.test5).to be_nil
 
 				ps = CLI.new do
 					argument :log, :cast => Pathname
 					argument :test, :required => false
 				end.parse(['/tmp'])
-				ps.log.should be_a Pathname
-				ps.log.to_s.should == '/tmp'
-				ps.test.should be_nil
+        expect(ps.log).to be_a Pathname
+        expect(ps.log.to_s).to eq '/tmp'
+        expect(ps.test).to be_nil
 			end
 
 			it "should use empty array for multiple arguments argument when not enought arguments given and it is not required" do
@@ -301,9 +301,9 @@ describe CLI do
 					argument :test2, :required => false
 					arguments :test3, :required => false
 				end.parse(['a', 'b'])
-				ps.test1.should == 'a'
-				ps.test2.should == 'b'
-				ps.test3.should == []
+        expect(ps.test1).to eq 'a'
+        expect(ps.test2).to eq 'b'
+        expect(ps.test3).to eq []
 
 				ps = CLI.new do
 					argument :log, :cast => Pathname
@@ -314,14 +314,13 @@ describe CLI do
 					argument :code, :cast => Integer, :default => '123'
 				end.parse(['/tmp', 'test', 'test2'])
 
-				ps.log.to_s.should == '/tmp'
-				ps.magick.should == 'word'
-				ps.test.should == 'test'
-				ps.words.should == []
-				ps.test2.should == 'test2'
-				ps.code.should == 123
+        expect(ps.log.to_s).to eq '/tmp'
+        expect(ps.magick).to eq 'word'
+        expect(ps.test).to eq 'test'
+        expect(ps.words).to eq []
+        expect(ps.test2).to eq 'test2'
+        expect(ps.code).to eq 123
 			end
 		end
 	end
 end
-

data/spec/cli_spec.rb

@@ -16,20 +16,20 @@ describe CLI do
 			argument :code, :cast => Integer, :default => '123'
 		end.parse(['-l', 'singapore', '--power-up', 'yes', '-s', '24', '--debug', '--size', 'XXXL', '/tmp', 'hello'])
 
-		ps.group.should == 'red'
-		ps.power_up.should == 'yes'
-		ps.speed.should == 24
-		ps.size.should == 'XXXL'
+    expect(ps.group).to eq 'red'
+    expect(ps.power_up).to eq 'yes'
+    expect(ps.speed).to eq 24
+    expect(ps.size).to eq 'XXXL'
 
-		ps.log.to_s.should == '/tmp'
-		ps.magick.should == 'word'
-		ps.test.should == 'hello'
-		ps.code.should == 123
-		ps.debug.should be_true
+    expect(ps.log.to_s).to eq '/tmp'
+    expect(ps.magick).to eq 'word'
+    expect(ps.test).to eq 'hello'
+    expect(ps.code).to eq 123
+    expect(ps.debug).to be true
 	end
 
 	it "provides name method that provides current program name" do
-		CLI.name.should == 'rspec'
+    expect(CLI.name).to eq 'rspec'
 	end
 
 	describe "parse!" do
@@ -40,9 +40,9 @@ describe CLI do
 				argument :code
 			end.parse!(['-l', 'singapore', '--debug', 'hello'])
 
-			ps.location.should == 'singapore'
-			ps.debug.should be_true
-			ps.code.should == 'hello'
+      expect(ps.location).to eq 'singapore'
+      expect(ps.debug).to be true
+      expect(ps.code).to eq 'hello'
 		end
 
 		it "should return value structure where all values are set" do
@@ -51,15 +51,15 @@ describe CLI do
 				switch :debug
 			end.parse!([]).marshal_dump
 
-			h.member?(:location).should be_true
-			h[:location].should be_nil
+      expect(h.member?(:location)).to be true
+      expect(h[:location]).to be_nil
 
-			h.member?(:debug).should be_true
-			h[:debug].should be_nil
+      expect(h.member?(:debug)).to be true
+      expect(h[:debug]).to be_nil
 		end
 
 		it "should take a block that can be used to verify passed values" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :location, :short => :l
 					switch :debug
@@ -68,10 +68,10 @@ describe CLI do
 				end.parse!(['-l', 'singapore', '--debug', 'hello']) do |values|
 					fail '--debug can not be used with --verbose' if values.debug and values.verbose
 				end
-			}.should_not raise_error
+			}.not_to raise_error
 
 			out = stderr_read do
-				lambda {
+				expect {
 					ps = CLI.new do
 						option :location, :short => :l
 						switch :debug
@@ -80,23 +80,22 @@ describe CLI do
 					end.parse!(['-l', 'singapore', '--debug', '--verbose', 'hello']) do |values|
 						fail '--debug can not be used with --verbose' if values.debug and values.verbose
 					end
-					}.should raise_error SystemExit
+					}.to raise_error SystemExit
 				end
-				out.should include('Error: --debug can not be used with --verbose')
-				out.should include('Usage:')
+				expect(out).to include('Error: --debug can not be used with --verbose')
+				expect(out).to include('Usage:')
 		end
 
 		it "should exit displaying usage and error message on standard error on usage error" do
 				out = stderr_read do
-					lambda {
+					expect {
 						ps = CLI.new do
 							option :weight, :required => true
 						end.parse!([])
-					}.should raise_error SystemExit
+					}.to raise_error SystemExit
 				end
-				out.should include('Error: mandatory options not specified: --weight')
-				out.should include('Usage:')
+        expect(out).to include('Error: mandatory options not specified: --weight')
+        expect(out).to include('Usage:')
 		end
 	end
 end
-

data/spec/conflict_reporting_spec.rb

@@ -4,66 +4,65 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe CLI do
 	describe "name conflict reporting" do
 		it "raise error when long names configlict" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch :location
 					switch :location
 				end
-			}.should raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'switch --location specified twice'
+			}.to raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'switch --location specified twice'
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :location
 					option :location
 				end
-			}.should raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'option --location specified twice'
+			}.to raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'option --location specified twice'
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch :location
 					option :location
 				end
-			}.should raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'switch and option --location specified twice'
+			}.to raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'switch and option --location specified twice'
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :location
 					switch :location
 				end
-			}.should raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'option and switch --location specified twice'
+			}.to raise_error CLI::ParserError::LongNameSpecifiedTwiceError, 'option and switch --location specified twice'
 		end
 	end
 
 	describe "short name conflict reporting" do
 		it "raise error when short names configlict" do
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch :location, :short => :l
 					switch :location2, :short => :l
 				end
-			}.should raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short switch -l specified twice'
+			}.to raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short switch -l specified twice'
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :location, :short => :l
 					option :location2, :short => :l
 				end
-			}.should raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short option -l specified twice'
+			}.to raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short option -l specified twice'
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					switch :location, :short => :l
 					option :location2, :short => :l
 				end
-			}.should raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short switch and option -l specified twice'
+			}.to raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short switch and option -l specified twice'
 
-			lambda {
+			expect {
 				ps = CLI.new do
 					option :location2, :short => :l
 					switch :location, :short => :l
 				end
-			}.should raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short option and switch -l specified twice'
+			}.to raise_error CLI::ParserError::ShortNameSpecifiedTwiceError, 'short option and switch -l specified twice'
 		end
 	end
 end
-