reek 4.7.1 → 5.0.0

data/spec/reek/smell_detectors/utility_function_spec.rb

@@ -98,7 +98,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
     expect(src).to reek_of(:UtilityFunction, context: 'simple')
   end
 
-  context 'Singleton methods' do
+  context 'when examining singleton methods' do
     ['class', 'module'].each do |scope|
       it "does not report for #{scope} with `class << self` notation" do
         src = "#{scope} Alfa; class << self; def bravo(charlie) charlie.to_s; end; end; end"
@@ -111,7 +111,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
       end
     end
 
-    context 'by using `module_function`' do
+    context 'when defined by using `module_function`' do
       it 'does not report UtilityFunction also when using multiple arguments' do
         src = <<-EOS
           class Alfa
@@ -194,7 +194,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
       { Reek::SmellDetectors::UtilityFunction::PUBLIC_METHODS_ONLY_KEY => true }
     end
 
-    context 'public methods' do
+    context 'when examining public methods' do
       it 'still reports UtilityFunction' do
         src = <<-EOS
           class Alfa
@@ -208,7 +208,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
       end
     end
 
-    context 'private methods' do
+    context 'when examining private methods' do
       it 'does not report UtilityFunction' do
         src = <<-EOS
           class Alfa
@@ -221,9 +221,21 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
 
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
+
+      it 'does not report UtilityFunction when private is used as a def modifier' do
+        src = <<-EOS
+          class Alfa
+            private def bravo(charlie)
+              charlie.delta.echo
+            end
+          end
+        EOS
+
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
+      end
     end
 
-    context 'protected methods' do
+    context 'when examining protected methods' do
       it 'does not report UtilityFunction' do
         src = <<-EOS
           class Alfa
@@ -236,6 +248,46 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
 
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
+
+      it 'does not report UtilityFunction when protected is used as a def modifier' do
+        src = <<-EOS
+          class Alfa
+            protected def bravo(charlie)
+              charlie.delta.echo
+            end
+          end
+        EOS
+
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
+      end
+    end
+  end
+
+  describe 'disabling with a comment' do
+    it 'disables the method following the comment' do
+      src = <<-EOS
+        class Alfa
+          # :reek:UtilityFunction
+          def bravo(charlie)
+            charlie.delta.echo
+          end
+        end
+      EOS
+
+      expect(src).not_to reek_of(:UtilityFunction)
+    end
+
+    it 'disables a method when it has a visibility modifier' do
+      src = <<-EOS
+        class Alfa
+          # :reek:UtilityFunction
+          private def bravo(charlie)
+            charlie.delta.echo
+          end
+        end
+      EOS
+
+      expect(src).not_to reek_of(:UtilityFunction)
     end
   end
 end

data/spec/reek/smell_warning_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Reek::SmellWarning do
   let(:utility_function_detector) { build(:smell_detector, smell_type: 'UtilityFunction') }
   let(:uncommunicative_name_detector) { build(:smell_detector, smell_type: 'UncommunicativeVariableName') }
 
-  context 'sort order' do
+  describe 'sort order' do
     shared_examples_for 'first sorts ahead of second' do
       it 'hash differently' do
         expect(first.hash).not_to eq(second.hash)
@@ -26,21 +26,21 @@ RSpec.describe Reek::SmellWarning do
       end
     end
 
-    context 'smells differing only by detector' do
+    context 'when smells differ only by detector' do
       let(:first) { build(:smell_warning, smell_detector: duplication_detector) }
       let(:second) { build(:smell_warning, smell_detector: feature_envy_detector) }
 
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing only by lines' do
+    context 'when smells differ only by lines' do
       let(:first) { build(:smell_warning, smell_detector: feature_envy_detector, lines: [2]) }
       let(:second) { build(:smell_warning, smell_detector: feature_envy_detector, lines: [3]) }
 
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing only by context' do
+    context 'when smells differ only by context' do
       let(:first) { build(:smell_warning, smell_detector: duplication_detector, context: 'first') }
       let(:second) do
         build(:smell_warning, smell_detector: duplication_detector, context: 'second')
@@ -49,7 +49,7 @@ RSpec.describe Reek::SmellWarning do
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing only by message' do
+    context 'when smells differ only by message' do
       let(:first) do
         build(:smell_warning, smell_detector: duplication_detector,
                               context: 'ctx', message: 'first message')
@@ -62,7 +62,7 @@ RSpec.describe Reek::SmellWarning do
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smell name takes precedence over message' do
+    context 'when smells differ by name and message' do
       let(:first) do
         build(:smell_warning, smell_detector: feature_envy_detector, message: 'second message')
       end
@@ -73,7 +73,7 @@ RSpec.describe Reek::SmellWarning do
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing everywhere' do
+    context 'when smells differ everywhere' do
       let(:first) do
         build(:smell_warning, smell_detector: duplication_detector,
                               context: 'Dirty#a',
@@ -97,7 +97,7 @@ RSpec.describe Reek::SmellWarning do
     end
   end
 
-  context '#yaml_hash' do
+  describe '#yaml_hash' do
     let(:context_name) { 'Module::Class#method/block' }
     let(:lines) { [24, 513] }
     let(:message) { 'test message' }
@@ -135,6 +135,10 @@ RSpec.describe Reek::SmellWarning do
       expect(yaml['source']).to eq source
     end
 
+    it 'includes the documentation link' do
+      expect(yaml['documentation_link']).to eq Reek::DocumentationLink.build('FeatureEnvy')
+    end
+
     it 'includes the parameters' do
       parameters.each do |key, value|
         expect(yaml[key]).to eq value

data/spec/reek/source/source_code_spec.rb

@@ -6,59 +6,60 @@ RSpec.describe Reek::Source::SourceCode do
   describe '#syntax_tree' do
     it 'associates comments with the AST' do
       source = "# this is\n# a comment\ndef foo; end"
-      source_code = described_class.new(code: source, origin: '(string)')
+      source_code = described_class.new(source: source, origin: '(string)')
       result = source_code.syntax_tree
       expect(result.leading_comment).to eq "# this is\n# a comment"
     end
 
     it 'cleanly processes empty source' do
-      source_code = described_class.new(code: '', origin: '(string)')
+      source_code = described_class.new(source: '', origin: '(string)')
       result = source_code.syntax_tree
-      expect(result).to be_nil
+      expect(result.type).to eq :empty
     end
 
     it 'cleanly processes empty source with comments' do
       source = "# this is\n# a comment\n"
-      source_code = described_class.new(code: source, origin: '(string)')
+      source_code = described_class.new(source: source, origin: '(string)')
       result = source_code.syntax_tree
-      expect(result).to be_nil
+      expect(result.type).to eq :empty
     end
 
     it 'does not crash with sequences incompatible with UTF-8' do
       source = '"\xFF"'
-      source_code = described_class.new(code: source, origin: '(string)')
+      source_code = described_class.new(source: source, origin: '(string)')
       result = source_code.syntax_tree
       expect(result.children.first).to eq "\xFF"
     end
-  end
 
-  context 'when the parser fails' do
-    let(:source_name) { 'Test source' }
-    let(:src) { described_class.new(code: code, origin: source_name, **parser) }
+    it 'returns a :lambda node for lambda expressions' do
+      source = '->() { }'
+      source_code = described_class.new(source: source, origin: '(string)')
+      result = source_code.syntax_tree
+      expect(result.children.first.type).to eq :lambda
+    end
 
-    context 'with a Parser::SyntaxError' do
+    context 'when the parser fails with a Parser::SyntaxError' do
+      let(:src) { described_class.new(source: code) }
       let(:code) { '== Invalid Syntax ==' }
-      let(:parser) { {} }
 
-      it 'adds a diagnostic' do
-        expect(src.diagnostics.size).to eq 2
+      it 'raises the error' do
+        expect { src.syntax_tree }.to raise_error Parser::SyntaxError
       end
     end
 
-    context 'with a generic error' do
+    context 'when the parser fails with a generic error' do
       let(:code) { '' }
+      let(:parser) { instance_double('Parser::Ruby25') }
+      let(:src) { described_class.new(source: code, parser: parser) }
       let(:error_class) { RuntimeError }
       let(:error_message) { 'An error' }
-      let(:parser) do
-        parser = instance_double('Parser::Ruby24')
+
+      before do
         allow(parser).to receive(:parse_with_comments).and_raise(error_class, error_message)
-        {
-          parser: parser
-        }
       end
 
       it 'raises the error' do
-        expect { src }.to raise_error error_class, error_message
+        expect { src.syntax_tree }.to raise_error error_class, error_message
       end
     end
   end

data/spec/reek/source/source_locator_spec.rb

@@ -5,15 +5,15 @@ require_lib 'reek/source/source_locator'
 
 RSpec.describe Reek::Source::SourceLocator do
   describe '#sources' do
-    context 'applied to hidden directories' do
-      let(:path) { SAMPLES_PATH.join('source_with_hidden_directories') }
+    context 'when applied to hidden directories' do
+      let(:path) { SAMPLES_DIR.join('source_with_hidden_directories') }
 
       let(:expected_paths) do
-        [path.join('uncommunicative_parameter_name.rb')]
+        [path.join('not_hidden.rb')]
       end
 
       let(:paths_that_are_expected_to_be_ignored) do
-        [path.join('.hidden/uncommunicative_method_name.rb')]
+        [path.join('.hidden/hidden.rb')]
       end
 
       it 'does not scan hidden directories' do
@@ -30,21 +30,21 @@ RSpec.describe Reek::Source::SourceLocator do
     end
 
     # rubocop:disable RSpec/NestedGroups
-    context 'exclude paths' do
+    context 'with excluded paths' do
       let(:configuration) do
-        test_configuration_for(CONFIG_PATH.join('with_excluded_paths.reek'))
+        test_configuration_for(CONFIGURATION_DIR.join('with_excluded_paths.reek'))
       end
 
       let(:options) { instance_double('Reek::CLI::Options', force_exclusion?: false) }
 
       context 'when the path is absolute' do
         let(:path) do
-          SAMPLES_PATH.join('source_with_exclude_paths',
-                            'ignore_me',
-                            'uncommunicative_method_name.rb').expand_path
+          SAMPLES_DIR.join('source_with_exclude_paths',
+                           'ignore_me',
+                           'uncommunicative_method_name.rb').expand_path
         end
 
-        context 'and options.force_exclusion? is true' do
+        context 'when options.force_exclusion? is true' do
           before do
             allow(options).to receive(:force_exclusion?).and_return(true)
           end
@@ -55,7 +55,7 @@ RSpec.describe Reek::Source::SourceLocator do
           end
         end
 
-        context 'and options.force_exclusion? is false' do
+        context 'when options.force_exclusion? is false' do
           before do
             allow(options).to receive(:force_exclusion?).and_return(false)
           end
@@ -68,7 +68,7 @@ RSpec.describe Reek::Source::SourceLocator do
       end
 
       context 'when the path is a file name in an excluded directory' do
-        let(:path) { SAMPLES_PATH.join('source_with_exclude_paths', 'ignore_me', 'uncommunicative_method_name.rb') }
+        let(:path) { SAMPLES_DIR.join('source_with_exclude_paths', 'ignore_me', 'uncommunicative_method_name.rb') }
 
         context 'when options.force_exclusion? is true' do
           before do
@@ -94,7 +94,7 @@ RSpec.describe Reek::Source::SourceLocator do
       end
 
       context 'when path is a directory' do
-        let(:path) { SAMPLES_PATH.join('source_with_exclude_paths') }
+        let(:path) { SAMPLES_DIR.join('source_with_exclude_paths') }
 
         let(:expected_paths) do
           [path.join('nested/uncommunicative_parameter_name.rb')]
@@ -120,10 +120,10 @@ RSpec.describe Reek::Source::SourceLocator do
     end
     # rubocop:enable RSpec/NestedGroups
 
-    context 'non-Ruby paths' do
-      let(:path) { SAMPLES_PATH.join('source_with_non_ruby_files') }
+    context 'with non-Ruby paths' do
+      let(:path) { SAMPLES_DIR.join('source_with_non_ruby_files') }
       let(:expected_sources) do
-        [path.join('uncommunicative_parameter_name.rb')]
+        [path.join('ruby.rb')]
       end
       let(:paths_that_are_expected_to_be_ignored) do
         [
@@ -145,7 +145,7 @@ RSpec.describe Reek::Source::SourceLocator do
       end
     end
 
-    context 'passing "." or "./" as argument' do
+    context 'when passing "." or "./" as argument' do
       let(:expected_sources) do
         [Pathname.new('spec/spec_helper.rb'), Pathname.new('lib/reek.rb')]
       end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -11,50 +11,46 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       expect(ruby).to reek_of(:DuplicateMethodCall)
     end
 
-    it 'reports duplicate calls by smell detector class' do
-      expect(ruby).to reek_of(Reek::SmellDetectors::DuplicateMethodCall)
-    end
-
     it 'does not report any feature envy' do
       expect(ruby).not_to reek_of(:FeatureEnvy)
     end
   end
 
   describe 'different sources of input' do
-    context 'checking code in a string' do
+    context 'when checking code in a string' do
       let(:clean_code) { 'def good() true; end' }
       let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'matches a smelly String' do
-        expect(matcher.matches?(smelly_code)).to be_truthy
+        expect(matcher).to be_matches(smelly_code)
       end
 
       it 'doesnt match a fragrant String' do
-        expect(matcher.matches?(clean_code)).to be_falsey
+        expect(matcher).not_to be_matches(clean_code)
       end
 
       it 're-calculates matches every time' do
         matcher.matches? smelly_code
-        expect(matcher.matches?(clean_code)).to be_falsey
+        expect(matcher).not_to be_matches(clean_code)
       end
     end
 
-    context 'checking code in a File' do
+    context 'when checking code in a File' do
       let(:matcher) { described_class.new(:UncommunicativeMethodName, name: 'x') }
 
       it 'matches a smelly file' do
-        expect(matcher.matches?(SMELLY_FILE)).to be_truthy
+        expect(matcher).to be_matches(SMELLY_FILE)
       end
 
       it 'doesnt match a fragrant file' do
-        expect(matcher.matches?(CLEAN_FILE)).to be_falsey
+        expect(matcher).not_to be_matches(CLEAN_FILE)
       end
     end
   end
 
   describe 'smell types and smell details' do
-    context 'passing in smell_details with unknown parameter name' do
+    context 'when passing in smell_details with unknown parameter name' do
       let(:matcher) { described_class.new(:UncommunicativeVariableName, foo: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
@@ -63,23 +59,23 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       end
     end
 
-    context 'both are matching' do
+    context 'when both are matching' do
       let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'is truthy' do
-        expect(matcher.matches?(smelly_code)).to be_truthy
+        expect(matcher).to be_matches(smelly_code)
       end
     end
 
-    context 'no smell_type is matching' do
+    context 'when no smell_type is matching' do
       let(:smelly_code) { 'def dummy() y = 4; end' }
 
       let(:falsey_matcher) { described_class.new(:FeatureEnvy, name: 'y') }
       let(:truthy_matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
 
       it 'is falsey' do
-        expect(falsey_matcher.matches?(smelly_code)).to be_falsey
+        expect(falsey_matcher).not_to be_matches(smelly_code)
       end
 
       it 'sets the proper error message' do
@@ -97,12 +93,12 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       end
     end
 
-    context 'smell type is matching but smell details are not' do
+    context 'when smell type is matching but smell details are not' do
       let(:smelly_code) { 'def double_thing() @other.thing.foo + @other.thing.foo end' }
       let(:matcher) { described_class.new(:DuplicateMethodCall, name: 'foo', count: 15) }
 
       it 'is falsey' do
-        expect(matcher.matches?(smelly_code)).to be_falsey
+        expect(matcher).not_to be_matches(smelly_code)
       end
 
       it 'sets the proper error message' do
@@ -129,15 +125,15 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     end
   end
 
-  context 'for a smell that is disabled by default' do
-    before do
-      default_config = Reek::SmellDetectors::UnusedPrivateMethod.default_config
-      expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
-    end
-
+  context 'with a smell that is disabled by default' do
     it 'enables the smell detector to match automatically' do
+      default_config = Reek::SmellDetectors::UnusedPrivateMethod.default_config
       src = 'class C; private; def foo; end; end'
-      expect(src).to reek_of(:UnusedPrivateMethod)
+
+      aggregate_failures do
+        expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
+        expect(src).to reek_of(:UnusedPrivateMethod)
+      end
     end
   end
 
@@ -146,13 +142,13 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     let(:configured_matcher) { matcher.with_config('accept' => 'x') }
 
     it 'uses the passed-in configuration for matching' do
-      expect(configured_matcher.matches?('def foo; q = 2; end')).to be_truthy
-      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
+      expect(configured_matcher).to be_matches('def foo; q = 2; end')
+      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
     end
 
     it 'leaves the original matcher intact' do
-      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
-      expect(matcher.matches?('def foo; x = 2; end')).to be_truthy
+      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
+      expect(matcher).to be_matches('def foo; x = 2; end')
     end
   end
 end

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
     context 'when a match was expected' do
       let(:source) { 'the_path/to_a/source_file.rb' }
 
-      before { allow(examiner).to receive(:description).and_return(source) }
+      before { allow(examiner).to receive(:origin).and_return(source) }
 
       it 'reports the source' do
         expect(matcher.failure_message).to match(source)
@@ -91,7 +91,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
 
     it 'reports the source when no match was expected' do
       source = 'the_path/to_a/source_file.rb'
-      allow(examiner).to receive(:description).and_return(source)
+      allow(examiner).to receive(:origin).and_return(source)
       expect(matcher.failure_message_when_negated).to match(source)
     end
   end

data/spec/reek/spec/should_reek_spec.rb

@@ -8,11 +8,11 @@ RSpec.describe Reek::Spec::ShouldReek do
     let(:smelly_code) { 'def x() y = 4; end' }
 
     it 'matches a smelly String' do
-      expect(matcher.matches?(smelly_code)).to be_truthy
+      expect(matcher).to be_matches(smelly_code)
     end
 
     it 'doesnt match a fragrant String' do
-      expect(matcher.matches?(clean_code)).to be_falsey
+      expect(matcher).not_to be_matches(clean_code)
     end
 
     it 'reports the smells when should_not fails' do
@@ -22,15 +22,15 @@ RSpec.describe Reek::Spec::ShouldReek do
   end
 
   describe 'checking code in a File' do
-    context 'matcher without masking' do
+    context 'without masking' do
       let(:matcher) { described_class.new }
 
       it 'matches a smelly File' do
-        expect(matcher.matches?(SMELLY_FILE)).to be_truthy
+        expect(matcher).to be_matches(SMELLY_FILE)
       end
 
       it 'doesnt match a fragrant File' do
-        expect(matcher.matches?(CLEAN_FILE)).to be_falsey
+        expect(matcher).not_to be_matches(CLEAN_FILE)
       end
 
       it 'reports the smells when should_not fails' do
@@ -39,13 +39,13 @@ RSpec.describe Reek::Spec::ShouldReek do
       end
     end
 
-    context 'matcher without masking' do
-      let(:path) { CONFIG_PATH.join('full_mask.reek') }
+    context 'with masking' do
+      let(:path) { CONFIGURATION_DIR.join('full_mask.reek') }
       let(:configuration) { test_configuration_for(path) }
       let(:matcher) { described_class.new(configuration: configuration) }
 
       it 'masks smells using the relevant configuration' do
-        expect(matcher.matches?(SMELLY_FILE)).to be_falsey
+        expect(matcher).not_to be_matches(SMELLY_FILE)
       end
     end
   end

data/spec/reek/spec/smell_matcher_spec.rb

@@ -10,35 +10,35 @@ RSpec.describe Reek::Spec::SmellMatcher do
   end
   let(:matcher) { described_class.new(smell_warning) }
 
-  context '#matches?' do
+  describe '#matches?' do
     it 'matches on class symbol' do
-      expect(matcher.matches?(:UncommunicativeVariableName)).to be_truthy
+      expect(matcher).to be_matches(:UncommunicativeVariableName)
     end
 
     it 'matches on class symbol and params' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something')).to be_truthy
+      expect(matcher).to be_matches(:UncommunicativeVariableName,
+                                    test: 'something')
     end
 
     it 'matches on class symbol, params and attributes' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something',
-                              message: "has the variable name '@s'")).to be_truthy
+      expect(matcher).to be_matches(:UncommunicativeVariableName,
+                                    test: 'something',
+                                    message: "has the variable name '@s'")
     end
 
     it 'does not match on different class symbol' do
-      expect(matcher.matches?(:FeatureEnvy)).to be_falsy
+      expect(matcher).not_to be_matches(:FeatureEnvy)
     end
 
     it 'does not match on different params' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something else')).to be_falsy
+      expect(matcher).not_to be_matches(:UncommunicativeVariableName,
+                                        test: 'something else')
     end
 
     it 'does not match on different attributes' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something',
-                              message: 'nothing')).to be_falsy
+      expect(matcher).not_to be_matches(:UncommunicativeVariableName,
+                                        test: 'something',
+                                        message: 'nothing')
     end
 
     it 'raises error on uncomparable attribute' do
@@ -50,33 +50,33 @@ RSpec.describe Reek::Spec::SmellMatcher do
     end
   end
 
-  context '#matches_smell_type?' do
+  describe '#matches_smell_type?' do
     it 'matches on class symbol' do
-      expect(matcher.matches_smell_type?(:UncommunicativeVariableName)).to be_truthy
+      expect(matcher).to be_matches_smell_type(:UncommunicativeVariableName)
     end
 
     it 'does not match on different class symbol' do
-      expect(matcher.matches_smell_type?(:FeatureEnvy)).to be_falsy
+      expect(matcher).not_to be_matches_smell_type(:FeatureEnvy)
     end
   end
 
-  context '#matches_attributes?' do
+  describe '#matches_attributes?' do
     it 'matches on params' do
-      expect(matcher.matches_attributes?(test: 'something')).to be_truthy
+      expect(matcher).to be_matches_attributes(test: 'something')
     end
 
     it 'matches on class symbol, params and attributes' do
-      expect(matcher.matches_attributes?(test: 'something',
-                                         message: "has the variable name '@s'")).to be_truthy
+      expect(matcher).to be_matches_attributes(test: 'something',
+                                               message: "has the variable name '@s'")
     end
 
     it 'does not match on different params' do
-      expect(matcher.matches_attributes?(test: 'something else')).to be_falsy
+      expect(matcher).not_to be_matches_attributes(test: 'something else')
     end
 
     it 'does not match on different attributes' do
-      expect(matcher.matches_attributes?(test: 'something',
-                                         message: 'nothing')).to be_falsy
+      expect(matcher).not_to be_matches_attributes(test: 'something',
+                                                   message: 'nothing')
     end
 
     it 'raises error on uncomparable attribute' do