reek 1.3.8 → 1.4.0

data/spec/reek/source/code_comment_spec.rb

@@ -9,74 +9,74 @@ describe CodeComment do
       @comment = CodeComment.new('')
     end
     it 'is not descriptive' do
-      @comment.is_descriptive?.should be_false
+      expect(@comment).not_to be_descriptive
     end
     it 'has an empty config' do
-      @comment.config.should be_empty
+      expect(@comment.config).to be_empty
     end
   end
 
   context 'comment checks' do
     it 'rejects an empty comment' do
-      CodeComment.new('#').is_descriptive?.should be_false
+      expect(CodeComment.new('#')).not_to be_descriptive
     end
     it 'rejects a 1-word comment' do
-      CodeComment.new("# fred\n#  ").is_descriptive?.should be_false
+      expect(CodeComment.new("# fred\n#  ")).not_to be_descriptive
     end
     it 'accepts a 2-word comment' do
-      CodeComment.new('# fred here  ').is_descriptive?.should be_true
+      expect(CodeComment.new('# fred here  ')).to be_descriptive
     end
     it 'accepts a multi-word comment' do
-      CodeComment.new("# fred here \n# with \n   # biscuits ").is_descriptive?.should be_true
+      expect(CodeComment.new("# fred here \n# with \n   # biscuits ")).to be_descriptive
     end
   end
 
   context 'comment config' do
     it 'parses hashed options' do
-      config = CodeComment.new("# :reek:Duplication: { enabled: false }").config
-      config.should include('Duplication')
-      config['Duplication'].should include('enabled')
-      config['Duplication']['enabled'].should be_false
+      config = CodeComment.new('# :reek:Duplication: { enabled: false }').config
+      expect(config).to include('Duplication')
+      expect(config['Duplication']).to include('enabled')
+      expect(config['Duplication']['enabled']).to be_falsey
     end
     it 'parses hashed options with ruby names' do
-      config = CodeComment.new("# :reek:nested_iterators: { enabled: true }").config
-      config.should include('NestedIterators')
-      config['NestedIterators'].should include('enabled')
-      config['NestedIterators']['enabled'].should be_true
+      config = CodeComment.new('# :reek:nested_iterators: { enabled: true }').config
+      expect(config).to include('NestedIterators')
+      expect(config['NestedIterators']).to include('enabled')
+      expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple hashed options' do
       config = CodeComment.new("# :reek:Duplication: { enabled: false }\n:reek:nested_iterators: { enabled: true }").config
-      config.should include('Duplication','NestedIterators')
-      config['Duplication'].should include('enabled')
-      config['Duplication']['enabled'].should be_false
-      config['NestedIterators'].should include('enabled')
-      config['NestedIterators']['enabled'].should be_true
+      expect(config).to include('Duplication', 'NestedIterators')
+      expect(config['Duplication']).to include('enabled')
+      expect(config['Duplication']['enabled']).to be_falsey
+      expect(config['NestedIterators']).to include('enabled')
+      expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple hashed options on the same line' do
-      config = CodeComment.new("# :reek:Duplication: { enabled: false } and :reek:nested_iterators: { enabled: true }").config
-      config.should include('Duplication','NestedIterators')
-      config['Duplication'].should include('enabled')
-      config['Duplication']['enabled'].should be_false
-      config['NestedIterators'].should include('enabled')
-      config['NestedIterators']['enabled'].should be_true
+      config = CodeComment.new('# :reek:Duplication: { enabled: false } and :reek:nested_iterators: { enabled: true }').config
+      expect(config).to include('Duplication', 'NestedIterators')
+      expect(config['Duplication']).to include('enabled')
+      expect(config['Duplication']['enabled']).to be_falsey
+      expect(config['NestedIterators']).to include('enabled')
+      expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple unhashed options on the same line' do
-      config = CodeComment.new("# :reek:Duplication and :reek:nested_iterators").config
-      config.should include('Duplication','NestedIterators')
-      config['Duplication'].should include('enabled')
-      config['Duplication']['enabled'].should be_false
-      config['NestedIterators'].should include('enabled')
-      config['NestedIterators']['enabled'].should be_false
+      config = CodeComment.new('# :reek:Duplication and :reek:nested_iterators').config
+      expect(config).to include('Duplication', 'NestedIterators')
+      expect(config['Duplication']).to include('enabled')
+      expect(config['Duplication']['enabled']).to be_falsey
+      expect(config['NestedIterators']).to include('enabled')
+      expect(config['NestedIterators']['enabled']).to be_falsey
     end
     it 'disables the smell if no options are specifed' do
-      config = CodeComment.new("# :reek:Duplication").config
-      config.should include('Duplication')
-      config['Duplication'].should include('enabled')
-      config['Duplication']['enabled'].should be_false
+      config = CodeComment.new('# :reek:Duplication').config
+      expect(config).to include('Duplication')
+      expect(config['Duplication']).to include('enabled')
+      expect(config['Duplication']['enabled']).to be_falsey
     end
     it 'ignores smells after a space' do
-      config = CodeComment.new("# :reek: Duplication").config
-      config.should_not include('Duplication')
+      config = CodeComment.new('# :reek: Duplication').config
+      expect(config).not_to include('Duplication')
     end
   end
 end

data/spec/reek/source/object_source_spec.rb

@@ -5,16 +5,16 @@ include Reek
 describe Dir do
   it 'reports correct smells via the Dir matcher' do
     files = Dir['spec/samples/two_smelly_files/*.rb']
-    files.should reek
-    files.should reek_of(:UncommunicativeVariableName)
-    files.should_not reek_of(:LargeClass)
+    expect(files).to reek
+    expect(files).to reek_of(:UncommunicativeVariableName)
+    expect(files).not_to reek_of(:LargeClass)
   end
 
   it 'copes with daft file specs' do
-    Dir["spec/samples/two_smelly_files/*/.rb"].should_not reek
+    expect(Dir['spec/samples/two_smelly_files/*/.rb']).not_to reek
   end
 
   it 'copes with empty array' do
-    [].should_not reek
+    expect([]).not_to reek
   end
 end

data/spec/reek/source/reference_collector_spec.rb

@@ -10,28 +10,28 @@ describe ReferenceCollector do
       ReferenceCollector.new(src.to_reek_source.syntax_tree).num_refs_to_self
     end
     it 'with no refs to self' do
-      refs_to_self('def no_envy(arga) arga.barg end').should == 0
+      expect(refs_to_self('def no_envy(arga) arga.barg end')).to eq(0)
     end
     it 'counts a call to super' do
-      refs_to_self('def simple() super; end').should == 1
+      expect(refs_to_self('def simple() super; end')).to eq(1)
     end
     it 'counts a local call' do
-      refs_to_self('def simple() to_s; end').should == 1
+      expect(refs_to_self('def simple() to_s; end')).to eq(1)
     end
     it 'counts a use of self' do
-      refs_to_self('def simple() lv = self; end').should == 1
+      expect(refs_to_self('def simple() lv = self; end')).to eq(1)
     end
     it 'counts a call with self as receiver' do
-      refs_to_self('def simple() self.to_s; end').should == 1
+      expect(refs_to_self('def simple() self.to_s; end')).to eq(1)
     end
     it 'counts uses of an ivar' do
-      refs_to_self('def no_envy() @item.to_a; @item = 4; @item end').should == 3
+      expect(refs_to_self('def no_envy() @item.to_a; @item = 4; @item end')).to eq(3)
     end
     it 'counts an ivar passed to a method' do
-      refs_to_self('def no_envy(arga) arga.barg(@item); arga end').should == 1
+      expect(refs_to_self('def no_envy(arga) arga.barg(@item); arga end')).to eq(1)
     end
     it 'ignores global variables' do
-      refs_to_self('def no_envy(arga) $s2.to_a; $s2[arga] end').should == 0
+      expect(refs_to_self('def no_envy(arga) $s2.to_a; $s2[arga] end')).to eq(0)
     end
     it 'ignores global variables' do
       src = <<EOS
@@ -47,7 +47,7 @@ describe ReferenceCollector do
       @atype[t] = [pat, block]
     end
 EOS
-      refs_to_self(src).should == 2
+      expect(refs_to_self(src)).to eq(2)
     end
   end
 end

data/spec/reek/source/sexp_extensions_spec.rb

@@ -10,16 +10,16 @@ describe SexpExtensions::DefnNode do
       @node.extend(SexpExtensions::DefnNode)
     end
     it 'has no arg names' do
-      @node.arg_names.should == s()
+      expect(@node.arg_names).to eq(s())
     end
     it 'has no parameter names' do
-      @node.parameter_names.should == s()
+      expect(@node.parameter_names).to eq(s())
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
+      expect(@node.full_name('Fred')).to eq('Fred#hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
+      expect(@node.full_name('')).to eq('hello')
     end
   end
 
@@ -29,16 +29,16 @@ describe SexpExtensions::DefnNode do
       @node.extend(SexpExtensions::DefnNode)
     end
     it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
+      expect(@node.arg_names).to eq(s(:param))
     end
     it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
+      expect(@node.parameter_names).to eq(s(:param))
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
+      expect(@node.full_name('Fred')).to eq('Fred#hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
+      expect(@node.full_name('')).to eq('hello')
     end
   end
 
@@ -48,16 +48,16 @@ describe SexpExtensions::DefnNode do
       @node.extend(SexpExtensions::DefnNode)
     end
     it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
+      expect(@node.arg_names).to eq(s(:param))
     end
     it 'has 2 parameter names' do
-      @node.parameter_names.should == s(:param, :"&blk")
+      expect(@node.parameter_names).to eq(s(:param, :"&blk"))
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
+      expect(@node.full_name('Fred')).to eq('Fred#hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
+      expect(@node.full_name('')).to eq('hello')
     end
   end
 
@@ -67,16 +67,16 @@ describe SexpExtensions::DefnNode do
       @node.extend(SexpExtensions::DefnNode)
     end
     it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
+      expect(@node.arg_names).to eq(s(:param))
     end
     it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
+      expect(@node.parameter_names).to eq(s(:param))
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
+      expect(@node.full_name('Fred')).to eq('Fred#hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
+      expect(@node.full_name('')).to eq('hello')
     end
   end
 
@@ -87,12 +87,12 @@ describe SexpExtensions::DefnNode do
     end
 
     it 'has 2 body statements' do
-      @node.body.should == s(s(:first), s(:second))
+      expect(@node.body).to eq(s(s(:first), s(:second)))
     end
 
     it 'has a body extended with SexpNode' do
       b = @node.body
-      (class << b; self; end).included_modules.first.should == SexpNode
+      expect((class << b; self; end).included_modules.first).to eq(SexpNode)
     end
   end
 end
@@ -104,16 +104,16 @@ describe SexpExtensions::DefsNode do
       @node.extend(SexpExtensions::DefsNode)
     end
     it 'has no arg names' do
-      @node.arg_names.should == s()
+      expect(@node.arg_names).to eq(s())
     end
     it 'has no parameter names' do
-      @node.parameter_names.should == s()
+      expect(@node.parameter_names).to eq(s())
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
+      expect(@node.full_name('Fred')).to eq('Fred#obj.hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
+      expect(@node.full_name('')).to eq('obj.hello')
     end
   end
 
@@ -123,16 +123,16 @@ describe SexpExtensions::DefsNode do
       @node.extend(SexpExtensions::DefsNode)
     end
     it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
+      expect(@node.arg_names).to eq(s(:param))
     end
     it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
+      expect(@node.parameter_names).to eq(s(:param))
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
+      expect(@node.full_name('Fred')).to eq('Fred#obj.hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
+      expect(@node.full_name('')).to eq('obj.hello')
     end
   end
 
@@ -142,16 +142,16 @@ describe SexpExtensions::DefsNode do
       @node.extend(SexpExtensions::DefsNode)
     end
     it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
+      expect(@node.arg_names).to eq(s(:param))
     end
     it 'has 2 parameter names' do
-      @node.parameter_names.should == s(:param, :"&blk")
+      expect(@node.parameter_names).to eq(s(:param, :"&blk"))
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
+      expect(@node.full_name('Fred')).to eq('Fred#obj.hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
+      expect(@node.full_name('')).to eq('obj.hello')
     end
   end
 
@@ -161,16 +161,16 @@ describe SexpExtensions::DefsNode do
       @node.extend(SexpExtensions::DefsNode)
     end
     it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
+      expect(@node.arg_names).to eq(s(:param))
     end
     it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
+      expect(@node.parameter_names).to eq(s(:param))
     end
     it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
+      expect(@node.full_name('Fred')).to eq('Fred#obj.hello')
     end
     it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
+      expect(@node.full_name('')).to eq('obj.hello')
     end
   end
 
@@ -181,12 +181,12 @@ describe SexpExtensions::DefsNode do
     end
 
     it 'has 2 body statements' do
-      @node.body.should == s(s(:first), s(:second))
+      expect(@node.body).to eq(s(s(:first), s(:second)))
     end
 
     it 'has a body extended with SexpNode' do
       b = @node.body
-      (class << b; self; end).included_modules.first.should == SexpNode
+      expect((class << b; self; end).included_modules.first).to eq(SexpNode)
     end
   end
 end
@@ -198,7 +198,7 @@ describe SexpExtensions::CallNode do
       @node.extend(SexpExtensions::CallNode)
     end
     it 'has no parameter names' do
-      @node.parameter_names.should == nil
+      expect(@node.parameter_names).to eq(nil)
     end
   end
 
@@ -208,7 +208,7 @@ describe SexpExtensions::CallNode do
       @node.extend(SexpExtensions::CallNode)
     end
     it 'has 1 argument name' do
-      @node.arg_names.should == [:param]
+      expect(@node.arg_names).to eq([:param])
     end
   end
 
@@ -218,7 +218,7 @@ describe SexpExtensions::CallNode do
       @node.extend(SexpExtensions::CallNode)
     end
     it 'has 2 argument names' do
-      @node.arg_names.should == [:x, :y]
+      expect(@node.arg_names).to eq([:x, :y])
     end
   end
 end
@@ -230,7 +230,7 @@ describe SexpExtensions::IterNode do
       @node.extend(SexpExtensions::IterNode)
     end
     it 'has no parameter names' do
-      @node.parameter_names.should == []
+      expect(@node.parameter_names).to eq([])
     end
   end
 
@@ -240,7 +240,7 @@ describe SexpExtensions::IterNode do
       @node.extend(SexpExtensions::IterNode)
     end
     it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
+      expect(@node.parameter_names).to eq(s(:param))
     end
   end
 
@@ -250,7 +250,7 @@ describe SexpExtensions::IterNode do
       @node.extend(SexpExtensions::IterNode)
     end
     it 'has 2 parameter names' do
-      @node.parameter_names.should == [:x, :y]
+      expect(@node.parameter_names).to eq([:x, :y])
     end
   end
 end
@@ -261,14 +261,24 @@ describe SexpExtensions::ModuleNode do
       mod = ast(:module, :Fred, nil)
       mod
     end
-    its(:name) { should == :Fred }
-    its(:simple_name) { should == :Fred }
-    its(:text_name) { should == 'Fred' }
+
+    it 'has the correct #name' do
+      expect(subject.name).to eq(:Fred)
+    end
+
+    it 'has the correct #simple_name' do
+      expect(subject.simple_name).to eq(:Fred)
+    end
+
+    it 'has the correct #text_name' do
+      expect(subject.text_name).to eq('Fred')
+    end
+
     it 'has a simple full_name' do
-      subject.full_name('').should == 'Fred'
+      expect(subject.full_name('')).to eq('Fred')
     end
     it 'has a fq full_name' do
-      subject.full_name('Blimey::O::Reilly').should == 'Blimey::O::Reilly::Fred'
+      expect(subject.full_name('Blimey::O::Reilly')).to eq('Blimey::O::Reilly::Fred')
     end
   end
 
@@ -277,14 +287,25 @@ describe SexpExtensions::ModuleNode do
       mod = ast(:module, s(:colon2, s(:const, :Foo), :Bar), nil)
       mod
     end
-    its(:name) { should == s(:colon2, s(:const, :Foo), :Bar) }
-    its(:simple_name) { should == :Bar }
-    its(:text_name) { should == 'Foo::Bar' }
+
+    it 'has the correct #name' do
+      expect(subject.name).to eq(s(:colon2, s(:const, :Foo), :Bar))
+    end
+
+    it 'has the correct #simple_name' do
+      expect(subject.simple_name).to eq(:Bar)
+    end
+
+    it 'has the correct #text_name' do
+      expect(subject.text_name).to eq('Foo::Bar')
+    end
+
     it 'has a simple full_name' do
-      subject.full_name('').should == 'Foo::Bar'
+      expect(subject.full_name('')).to eq('Foo::Bar')
     end
+
     it 'has a fq full_name' do
-      subject.full_name('Blimey::O::Reilly').should == 'Blimey::O::Reilly::Foo::Bar'
+      expect(subject.full_name('Blimey::O::Reilly')).to eq('Blimey::O::Reilly::Foo::Bar')
     end
   end
 end