yard 0.8.7.6 → 0.9.0

data/spec/handlers/dsl_handler_spec.rb

@@ -4,189 +4,188 @@ require 'ostruct'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}DSLHandler" do
   before(:all) { parse_file :dsl_handler_001, __FILE__ }
 
-  it "should create a readable attribute when @!attribute r is found" do
+  it "creates a readable attribute when @!attribute r is found" do
     obj = Registry.at('Foo#attr1')
-    obj.should_not be_nil
-    obj.should be_reader
-    obj.tag(:return).types.should == ['Numeric']
-    Registry.at('Foo#attr1=').should be_nil
+    expect(obj).not_to be nil
+    expect(obj).to be_reader
+    expect(obj.tag(:return).types).to eq ['Numeric']
+    expect(Registry.at('Foo#attr1=')).to be nil
   end
 
-  it "should create a writable attribute when @!attribute w is found" do
+  it "creates a writable attribute when @!attribute w is found" do
     obj = Registry.at('Foo#attr2=')
-    obj.should_not be_nil
-    obj.should be_writer
-    Registry.at('Foo#attr2').should be_nil
+    expect(obj).not_to be nil
+    expect(obj).to be_writer
+    expect(Registry.at('Foo#attr2')).to be nil
   end
 
-  it "should default to readwrite @!attribute" do
+  it "defaults to readwrite @!attribute" do
     obj = Registry.at('Foo#attr3')
-    obj.should_not be_nil
-    obj.should be_reader
+    expect(obj).not_to be nil
+    expect(obj).to be_reader
     obj = Registry.at('Foo#attr3=')
-    obj.should_not be_nil
-    obj.should be_writer
+    expect(obj).not_to be nil
+    expect(obj).to be_writer
   end
 
-  it "should allow @!attribute to define alternate method name" do
-    Registry.at('Foo#attr4').should be_nil
-    Registry.at('Foo#custom').should_not be_nil
+  it "allows @!attribute to define alternate method name" do
+    expect(Registry.at('Foo#attr4')).to be nil
+    expect(Registry.at('Foo#custom')).not_to be nil
   end
 
-  it "should default to creating an instance method for any DSL method with special tags" do
+  it "defaults to creating an instance method for any DSL method with special tags" do
     obj = Registry.at('Foo#implicit0')
-    obj.should_not be_nil
-    obj.docstring.should == "IMPLICIT METHOD!"
-    obj.tag(:return).types.should == ['String']
+    expect(obj).not_to be nil
+    expect(obj.docstring).to eq "IMPLICIT METHOD!"
+    expect(obj.tag(:return).types).to eq ['String']
   end
 
-  it "should recognize implicit docstring when it has scope tag" do
+  it "recognizes implicit docstring when it has scope tag" do
     obj = Registry.at("Foo.implicit1")
-    obj.should_not be_nil
-    obj.scope.should == :class
+    expect(obj).not_to be nil
+    expect(obj.scope).to eq :class
   end
 
-  it "should recognize implicit docstring when it has visibility tag" do
+  it "recognizes implicit docstring when it has visibility tag" do
     obj = Registry.at("Foo#implicit2")
-    obj.should_not be_nil
-    obj.visibility.should == :protected
+    expect(obj).not_to be nil
+    expect(obj.visibility).to eq :protected
   end
 
-  it "should not recognize implicit docstring with any other normal tag" do
+  it "does not recognize implicit docstring with any other normal tag" do
     obj = Registry.at('Foo#implicit_invalid3')
-    obj.should be_nil
+    expect(obj).to be nil
   end
 
-  it "should set the method name when using @!method" do
+  it "sets the method name when using @!method" do
     obj = Registry.at('Foo.xyz')
-    obj.should_not be_nil
-    obj.signature.should == 'def xyz(a, b, c)'
-    obj.parameters.should == [['a', nil], ['b', nil], ['c', nil]]
-    obj.source.should == 'foo_bar'
-    obj.docstring.should == 'The foo method'
+    expect(obj).not_to be nil
+    expect(obj.signature).to eq 'def xyz(a, b, c)'
+    expect(obj.parameters).to eq [['a', nil], ['b', nil], ['c', nil]]
+    expect(obj.source).to eq 'foo_bar'
+    expect(obj.docstring).to eq 'The foo method'
   end
 
-  it "should allow setting of @!scope" do
-    Registry.at('Foo.xyz').scope.should == :class
+  it "allows setting of @!scope" do
+    expect(Registry.at('Foo.xyz').scope).to eq :class
   end
 
-  it "should create module function if @!scope is module" do
+  it "creates module function if @!scope is module" do
     mod_c = Registry.at('Foo.modfunc1')
     mod_i = Registry.at('Foo#modfunc1')
-    mod_c.scope.should == :class
-    mod_i.visibility.should == :private
+    expect(mod_c.scope).to eq :class
+    expect(mod_i.visibility).to eq :private
   end
 
-  it "should allow setting of @!visibility" do
-    Registry.at('Foo.xyz').visibility.should == :protected
+  it "allows setting of @!visibility" do
+    expect(Registry.at('Foo.xyz').visibility).to eq :protected
   end
 
-  it "should ignore DSL methods without tags" do
-    Registry.at('Foo#implicit_invalid').should be_nil
+  it "ignores DSL methods without tags" do
+    expect(Registry.at('Foo#implicit_invalid')).to be nil
   end
 
-  it "should accept a DSL method without tags if it has hash_flag (##)" do
-    Registry.at('Foo#implicit_valid').should_not be_nil
-    Registry.at('Foo#implicit_invalid2').should be_nil
+  it "accepts a DSL method without tags if it has hash_flag (##)" do
+    expect(Registry.at('Foo#implicit_valid')).not_to be nil
+    expect(Registry.at('Foo#implicit_invalid2')).to be nil
   end
 
-  it "should allow creation of macros" do
+  it "allows creation of macros" do
     macro = CodeObjects::MacroObject.find('property')
-    macro.should_not be_nil
-    macro.should_not be_attached
-    macro.method_object.should be_nil
+    expect(macro).not_to be nil
+    expect(macro).not_to be_attached
+    expect(macro.method_object).to be nil
   end
 
-  it "should handle macros with no parameters to expand" do
-    Registry.at('Foo#none').should_not be_nil
-    Registry.at('Baz#none').signature.should == 'def none(foo, bar)'
+  it "handles macros with no parameters to expand" do
+    expect(Registry.at('Foo#none')).not_to be nil
+    expect(Registry.at('Baz#none').signature).to eq 'def none(foo, bar)'
   end
 
-  it "should expand $N on method definitions" do
-    Registry.at('Foo#regular_meth').docstring.should == 'a b c'
+  it "expands $N on method definitions" do
+    expect(Registry.at('Foo#regular_meth').docstring).to eq 'a b c'
   end
 
-  it "should apply new macro docstrings on new objects" do
+  it "applies new macro docstrings on new objects" do
     obj = Registry.at('Foo#name')
-    obj.should_not be_nil
-    obj.source.should == 'property :name, String, :a, :b, :c'
-    obj.signature.should == 'def name(a, b, c)'
-    obj.docstring.should == 'A property that is awesome.'
-    obj.tag(:param).name.should == 'a'
-    obj.tag(:param).text.should == 'first parameter'
-    obj.tag(:return).types.should == ['String']
-    obj.tag(:return).text.should == 'the property name'
+    expect(obj).not_to be nil
+    expect(obj.source).to eq 'property :name, String, :a, :b, :c'
+    expect(obj.signature).to eq 'def name(a, b, c)'
+    expect(obj.docstring).to eq 'A property that is awesome.'
+    expect(obj.tag(:param).name).to eq 'a'
+    expect(obj.tag(:param).text).to eq 'first parameter'
+    expect(obj.tag(:return).types).to eq ['String']
+    expect(obj.tag(:return).text).to eq 'the property name'
   end
 
-  it "should allow reuse of named macros" do
+  it "allows reuse of named macros" do
     obj = Registry.at('Foo#age')
-    obj.should_not be_nil
-    obj.source.should == 'property :age, Fixnum, :value'
-    obj.signature.should == 'def age(value)'
-    obj.docstring.should == 'A property that is awesome.'
-    obj.tag(:param).name.should == 'value'
-    obj.tag(:param).text.should == 'first parameter'
-    obj.tag(:return).types.should == ['Fixnum']
-    obj.tag(:return).text.should == 'the property age'
+    expect(obj).not_to be nil
+    expect(obj.source).to eq 'property :age, Fixnum, :value'
+    expect(obj.signature).to eq 'def age(value)'
+    expect(obj.docstring).to eq 'A property that is awesome.'
+    expect(obj.tag(:param).name).to eq 'value'
+    expect(obj.tag(:param).text).to eq 'first parameter'
+    expect(obj.tag(:return).types).to eq ['Fixnum']
+    expect(obj.tag(:return).text).to eq 'the property age'
   end
 
-  it "should know about method information on DSL with macro expansion" do
-    Registry.at('Foo#right_name').should_not be_nil
-    Registry.at('Foo#right_name').source.should ==
-      'implicit_with_different_method_name :wrong, :right'
-    Registry.at('Foo#wrong_name').should be_nil
+  it "knows about method information on DSL with macro expansion" do
+    expect(Registry.at('Foo#right_name')).not_to be nil
+    expect(Registry.at('Foo#right_name').source).to eq 'implicit_with_different_method_name :wrong, :right'
+    expect(Registry.at('Foo#wrong_name')).to be nil
   end
 
-  it "should use attached macros" do
+  it "uses attached macros" do
     macro = CodeObjects::MacroObject.find('parser')
-    macro.macro_data.should == "@!method $1(opts = {})\n@return NOTHING!"
-    macro.should_not be_nil
-    macro.should be_attached
-    macro.method_object.should == P('Foo.parser')
+    expect(macro.macro_data).to eq "@!method $1(opts = {})\n@return NOTHING!"
+    expect(macro).not_to be nil
+    expect(macro).to be_attached
+    expect(macro.method_object).to eq P('Foo.parser')
     obj = Registry.at('Foo#c_parser')
-    obj.should_not be_nil
-    obj.docstring.should == ""
-    obj.signature.should == "def c_parser(opts = {})"
-    obj.docstring.tag(:return).text.should == "NOTHING!"
+    expect(obj).not_to be nil
+    expect(obj.docstring).to eq ""
+    expect(obj.signature).to eq "def c_parser(opts = {})"
+    expect(obj.docstring.tag(:return).text).to eq "NOTHING!"
   end
 
-  it "should append docstring on DSL method to attached macro" do
+  it "appends docstring on DSL method to attached macro" do
     obj = Registry.at('Foo#d_parser')
-    obj.should_not be_nil
-    obj.docstring.should == "Another docstring"
-    obj.signature.should == "def d_parser(opts = {})"
-    obj.docstring.tag(:return).text.should == "NOTHING!"
+    expect(obj).not_to be nil
+    expect(obj.docstring).to eq "Another docstring"
+    expect(obj.signature).to eq "def d_parser(opts = {})"
+    expect(obj.docstring.tag(:return).text).to eq "NOTHING!"
   end
 
-  it "should only use attached macros on methods defined in inherited hierarchy" do
-    Registry.at('Bar#x_parser').should be_nil
-    Registry.at('Baz#y_parser').should_not be_nil
+  it "only uses attached macros on methods defined in inherited hierarchy" do
+    expect(Registry.at('Bar#x_parser')).to be nil
+    expect(Registry.at('Baz#y_parser')).not_to be nil
   end
 
-  it "should look through mixins for attached macros" do
+  it "looks through mixins for attached macros" do
     meth = Registry.at('Baz#mixin_method')
-    meth.should_not be_nil
-    meth.docstring.should == 'DSL method mixin_method'
+    expect(meth).not_to be nil
+    expect(meth.docstring).to eq 'DSL method mixin_method'
   end
 
-  it "should handle top-level DSL methods" do
+  it "handles top-level DSL methods" do
     obj = Registry.at('#my_other_method')
-    obj.should_not be_nil
-    obj.docstring.should == "Docstring for method"
+    expect(obj).not_to be nil
+    expect(obj.docstring).to eq "Docstring for method"
   end
 
-  it "should handle Constant.foo syntax" do
+  it "handles Constant.foo syntax" do
     obj = Registry.at('#beep')
-    obj.should_not be_nil
-    obj.signature.should == 'def beep(a, b, c)'
+    expect(obj).not_to be nil
+    expect(obj.signature).to eq 'def beep(a, b, c)'
   end
 
-  it "should expand attached macros in first DSL method" do
-    Registry.at('DSLMethods#foo').docstring.should == "Returns String for foo"
-    Registry.at('DSLMethods#bar').docstring.should == "Returns Integer for bar"
+  it "expands attached macros in first DSL method" do
+    expect(Registry.at('DSLMethods#foo').docstring).to eq "Returns String for foo"
+    expect(Registry.at('DSLMethods#bar').docstring).to eq "Returns Integer for bar"
   end
 
-  it "should not detect implicit macros with invalid method names" do
+  it "does not detect implicit macros with invalid method names" do
     undoc_error <<-eof
       ##
       # IMPLICIT METHOD THAT SHOULD

data/spec/handlers/examples/constant_handler_001.rb.txt

@@ -22,4 +22,7 @@ MyEmptyStruct = Struct.new
 #
 # @attr [String] bar An attr
 # @attr [Number] baz Another attr
-DocstringStruct = Struct.new(:bar, :baz)
+# @!attribute new_syntax
+#   Attribute defined with the new syntax
+#   @return [Symbol] something usefull
+DocstringStruct = Struct.new(:bar, :baz, :new_syntax)

data/spec/handlers/examples/visibility_handler_001.rb.txt

@@ -25,8 +25,12 @@ class Testing
   def Foo; end
   private :Foo
 
+  private def decpriv; end
+
   private
 
   class Bar; end
   module Baz; end
+
+  private :not_exist!
 end

data/spec/handlers/exception_handler_spec.rb

@@ -3,46 +3,46 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandler" do
   before(:all) { parse_file :exception_handler_001, __FILE__ }
 
-  it "should not document an exception outside of a method" do
-    P('Testing').has_tag?(:raise).should == false
+  it "does not document an exception outside of a method" do
+    expect(P('Testing').has_tag?(:raise)).to be false
   end
 
-  it "should document a valid raise" do
-    P('Testing#mymethod').tag(:raise).types.should == ['ArgumentError']
+  it "documents a valid raise" do
+    expect(P('Testing#mymethod').tag(:raise).types).to eq ['ArgumentError']
   end
 
-  it "should only document non-dynamic raises" do
-    P('Testing#mymethod2').tag(:raise).should be_nil
-    P('Testing#mymethod6').tag(:raise).should be_nil
-    P('Testing#mymethod7').tag(:raise).should be_nil
+  it "only documents non-dynamic raises" do
+    expect(P('Testing#mymethod2').tag(:raise)).to be nil
+    expect(P('Testing#mymethod6').tag(:raise)).to be nil
+    expect(P('Testing#mymethod7').tag(:raise)).to be nil
   end
 
-  it "should treat ConstantName.new as a valid exception class" do
-    P('Testing#mymethod8').tag(:raise).types.should == ['ExceptionClass']
+  it "treats ConstantName.new as a valid exception class" do
+    expect(P('Testing#mymethod8').tag(:raise).types).to eq ['ExceptionClass']
   end
 
-  it "should not document a method with an existing @raise tag" do
-    P('Testing#mymethod3').tag(:raise).types.should == ['A']
+  it "does not document a method with an existing @raise tag" do
+    expect(P('Testing#mymethod3').tag(:raise).types).to eq ['A']
   end
 
-  it "should only document the first raise message of a method (limitation of exception handler)" do
-    P('Testing#mymethod4').tag(:raise).types.should == ['A']
+  it "only documents the first raise message of a method (limitation of exception handler)" do
+    expect(P('Testing#mymethod4').tag(:raise).types).to eq ['A']
   end
 
-  it "should handle complex class names" do
-    P('Testing#mymethod5').tag(:raise).types.should == ['YARD::Parser::UndocumentableError']
+  it "handles complex class names" do
+    expect(P('Testing#mymethod5').tag(:raise).types).to eq ['YARD::Parser::UndocumentableError']
   end
 
-  it "should ignore any raise calls on a receiver" do
-    P('Testing#mymethod9').tag(:raise).should be_nil
+  it "ignores any raise calls on a receiver" do
+    expect(P('Testing#mymethod9').tag(:raise)).to be nil
   end
 
-  it "should handle raise expressions that are method calls" do
-    P('Testing#mymethod10').tag(:raise).should be_nil
-    P('Testing#mymethod11').tag(:raise).should be_nil
+  it "handles raise expressions that are method calls" do
+    expect(P('Testing#mymethod10').tag(:raise)).to be nil
+    expect(P('Testing#mymethod11').tag(:raise)).to be nil
   end
 
-  it "should ignore empty raise call" do
-    P('Testing#mymethod12').tag(:raise).should be_nil
+  it "ignores empty raise call" do
+    expect(P('Testing#mymethod12').tag(:raise)).to be nil
   end
 end

data/spec/handlers/extend_handler_spec.rb

@@ -3,21 +3,21 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExtendHandler" do
   before(:all) { parse_file :extend_handler_001, __FILE__ }
 
-  it "should include modules at class scope" do
-    Registry.at(:B).class_mixins.should == [P(:A)]
-    Registry.at(:B).instance_mixins.should be_empty
+  it "includes modules at class scope" do
+    expect(Registry.at(:B).class_mixins).to eq [P(:A)]
+    expect(Registry.at(:B).instance_mixins).to be_empty
   end
 
-  it "should handle a module extending itself" do
-    Registry.at(:C).class_mixins.should == [P(:C)]
-    Registry.at(:C).instance_mixins.should be_empty
+  it "handles a module extending itself" do
+    expect(Registry.at(:C).class_mixins).to eq [P(:C)]
+    expect(Registry.at(:C).instance_mixins).to be_empty
   end
 
-  it "should extend module with correct namespace" do
-    Registry.at('Q::R::S').class_mixins.first.path.should == 'A'
+  it "extends module with correct namespace" do
+    expect(Registry.at('Q::R::S').class_mixins.first.path).to eq 'A'
   end
 
-  it "should not allow extending self if object is a class" do
+  it "does not allow extending self if object is a class" do
     undoc_error "class Foo; extend self; end"
   end
 end

data/spec/handlers/legacy_base_spec.rb

@@ -10,58 +10,58 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#tokval" do
     @handler.send(:tokval, TokenList.new(code).first, *types)
   end
 
-  it "should return the String's value without quotes" do
-    tokval('"hello"').should == "hello"
+  it "returns the String's value without quotes" do
+    expect(tokval('"hello"')).to eq "hello"
   end
 
-  it "should not allow interpolated strings with TkSTRING" do
-    tokval('"#{c}"', RubyToken::TkSTRING).should be_nil
+  it "does not allow interpolated strings with TkSTRING" do
+    expect(tokval('"#{c}"', RubyToken::TkSTRING)).to be nil
   end
 
-  it "should return a Symbol's value as a String (as if it was done via :name.to_sym)" do
-    tokval(':sym').should == :sym
+  it "returns a Symbol's value as a String (as if it was done via :name.to_sym)" do
+    expect(tokval(':sym')).to eq :sym
   end
 
-  it "should return nil for any non accepted type" do
-    tokval('identifier').should be_nil
-    tokval(':sym', RubyToken::TkId).should be_nil
+  it "returns nil for any non accepted type" do
+    expect(tokval('identifier')).to be nil
+    expect(tokval(':sym', RubyToken::TkId)).to be nil
   end
 
-  it "should accept TkVal tokens by default" do
-    tokval('2.5').should == 2.5
-    tokval(':sym').should == :sym
+  it "accepts TkVal tokens by default" do
+    expect(tokval('2.5')).to eq 2.5
+    expect(tokval(':sym')).to eq :sym
   end
 
-  it "should accept any ID type if TkId is set" do
-    tokval('variable', RubyToken::TkId).should == "variable"
-    tokval('CONSTANT', RubyToken::TkId).should == "CONSTANT"
+  it "accepts any ID type if TkId is set" do
+    expect(tokval('variable', RubyToken::TkId)).to eq "variable"
+    expect(tokval('CONSTANT', RubyToken::TkId)).to eq "CONSTANT"
   end
 
-  it "should allow extra token types to be accepted" do
-    tokval('2.5', RubyToken::TkFLOAT).should == 2.5
-    tokval('2', RubyToken::TkFLOAT).should be_nil
-    tokval(':symbol', RubyToken::TkFLOAT).should be_nil
+  it "allows extra token types to be accepted" do
+    expect(tokval('2.5', RubyToken::TkFLOAT)).to eq 2.5
+    expect(tokval('2', RubyToken::TkFLOAT)).to be nil
+    expect(tokval(':symbol', RubyToken::TkFLOAT)).to be nil
   end
 
-  it "should allow :string for any string type" do
-    tokval('"hello"', :string).should == "hello"
-    tokval('"#{c}"', :string).should == '#{c}'
+  it "allows :string for any string type" do
+    expect(tokval('"hello"', :string)).to eq "hello"
+    expect(tokval('"#{c}"', :string)).to eq '#{c}'
   end
 
-  it "should not include interpolated strings when using :attr" do
-    tokval('"#{c}"', :attr).should be_nil
+  it "does not include interpolated strings when using :attr" do
+    expect(tokval('"#{c}"', :attr)).to be nil
   end
 
-  it "should allow any number type with :number" do
-    tokval('2.5', :number).should == 2.5
-    tokval('2', :number).should == 2
+  it "allows any number type with :number" do
+    expect(tokval('2.5', :number)).to eq 2.5
+    expect(tokval('2', :number)).to eq 2
   end
 
-  it "should should allow method names with :identifier" do
-    tokval('methodname?', :identifier).should == "methodname?"
+  it "allows method names with :identifier" do
+    expect(tokval('methodname?', :identifier)).to eq "methodname?"
   end
 
-  #it "should obey documentation expectations" do docspec end
+  #it "obeys documentation expectations" do docspec end
 end
 
 describe YARD::Handlers::Base, "#tokval_list" do
@@ -71,58 +71,58 @@ describe YARD::Handlers::Base, "#tokval_list" do
     @handler.send(:tokval_list, TokenList.new(code), *types)
   end
 
-  it "should return the list of tokvalues" do
-    tokval_list(":a, :b, \"\#{c}\", 'd'", :attr).should == [:a, :b, 'd']
-    tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d",
-      RubyToken::Token).should  == [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
+  it "returns the list of tokvalues" do
+    expect(tokval_list(":a, :b, \"\#{c}\", 'd'", :attr)).to eq [:a, :b, 'd']
+    expect(tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d",
+      RubyToken::Token)).to eq [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
   end
 
-  it "should try to skip any invalid tokens" do
-    tokval_list(":a, :b, \"\#{c}\", :d", :attr).should  == [:a, :b, :d]
-    tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr).should  == [:a, :b, :d]
-    tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2",
-      RubyToken::TkId).should  == ['CONST1', 'identifier', 'CONST2']
+  it "tries to skip any invalid tokens" do
+    expect(tokval_list(":a, :b, \"\#{c}\", :d", :attr)).to eq [:a, :b, :d]
+    expect(tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr)).to eq [:a, :b, :d]
+    expect(tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2",
+      RubyToken::TkId)).to eq ['CONST1', 'identifier', 'CONST2']
   end
 
-  it "should ignore a token if another invalid token is read before a comma" do
-    tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL).should == [:a, :c]
+  it "ignores a token if another invalid token is read before a comma" do
+    expect(tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL)).to eq [:a, :c]
   end
 
-  it "should stop on most keywords" do
-    tokval_list(':a rescue :x == 5', RubyToken::Token).should == [:a]
+  it "stops on most keywords" do
+    expect(tokval_list(':a rescue :x == 5', RubyToken::Token)).to eq [:a]
   end
 
-  it "should handle ignore parentheses that begin the token list" do
-    tokval_list('(:a, :b, :c)', :attr).should == [:a, :b, :c]
+  it "handles ignore parentheses that begin the token list" do
+    expect(tokval_list('(:a, :b, :c)', :attr)).to eq [:a, :b, :c]
   end
 
-  it "should end when a closing parenthesis was found" do
-    tokval_list(':a, :b, :c), :d', :attr).should == [:a, :b, :c]
+  it "ends when a closing parenthesis was found" do
+    expect(tokval_list(':a, :b, :c), :d', :attr)).to eq [:a, :b, :c]
   end
 
-  it "should ignore parentheses around items in a list" do
-    tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr).should == [:a, :b, :c, :e, :g]
-    tokval_list(':a, (((:f)))', :attr).should == [:a, :f]
-    tokval_list(':a, ([:f]), :c)', RubyToken::Token).should == [:a, '[:f]', :c]
+  it "ignores parentheses around items in a list" do
+    expect(tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr)).to eq [:a, :b, :c, :e, :g]
+    expect(tokval_list(':a, (((:f)))', :attr)).to eq [:a, :f]
+    expect(tokval_list(':a, ([:f]), :c)', RubyToken::Token)).to eq [:a, '[:f]', :c]
   end
 
-  it "should not stop on a true/false/self keyword (cannot handle nil)" do
-    tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ',
-      RubyToken::Token).should == [:a, true, :b, 'self', false, :c, 'File', 'super']
+  it "does not stop on a true/false/self keyword (cannot handle nil)" do
+    expect(tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ',
+      RubyToken::Token)).to eq [:a, true, :b, 'self', false, :c, 'File', 'super']
   end
 
-  it "should ignore invalid commas" do
-    tokval_list(":a, :b, , :d").should == [:a, :b, :d]
+  it "ignores invalid commas" do
+    expect(tokval_list(":a, :b, , :d")).to eq [:a, :b, :d]
   end
 
-  it "should return an empty list if no matches were found" do
-    tokval_list('attr_accessor :x').should == []
+  it "returns an empty list if no matches were found" do
+    expect(tokval_list('attr_accessor :x')).to eq []
   end
 
-  it "should treat {} as a valid value" do
+  it "treats {} as a valid value" do
     # FIXME: tokval_list destroys extra spaces surrounding the '=' in
     #        this situation. This is technically a design flaw of the
     #        tokval parser, but this is now the expected behaviour.
-    tokval_list("opts = {}", :all).should == ["opts={}"]
+    expect(tokval_list("opts = {}", :all)).to eq ["opts={}"]
   end
 end