inch 0.5.0.rc5 → 0.5.0.rc6

data/test/unit/cli/trace_helper_test.rb

@@ -1,11 +1,11 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 class Tracer
   include ::Inch::CLI::TraceHelper
 end
 
 describe ::Inch::CLI::TraceHelper do
-  it "should be a UI instance" do
+  it 'should be a UI instance' do
     @instance = Tracer.new
     assert @instance.ui.is_a?(Inch::Utils::UI)
   end

data/test/unit/cli/yardopts_helper_test.rb

@@ -1,85 +1,85 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 describe ::Inch::CLI::YardoptsHelper do
   before do
     Dir.chdir fixture_path(:ruby, :yardopts)
-    assert File.file?(".yardopts")
+    assert File.file?('.yardopts')
     @command = ::Inch::CLI::Command::List
   end
 
-  it "should run without args" do
+  it 'should run without args' do
     out, err = capture_io do
       @command.run
     end
-    refute out.empty?, "there should be some output"
-    assert err.empty?, "there should be no errors"
-    assert_match /\bFoo\b/, out
-    assert_match /\bFoo::Bar\b/, out
-    assert_match /\bFoo::Bar#initialize\b/, out
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
+    assert_match(/\bFoo\b/, out)
+    assert_match(/\bFoo::Bar\b/, out)
+    assert_match(/\bFoo::Bar#initialize\b/, out)
   end
 
-  it "should run with --no-yardopts" do
+  it 'should run with --no-yardopts' do
     out, err = capture_io do
-      @instance = @command.run("app/**/*.rb", "--no-yardopts")
+      @instance = @command.run('app/**/*.rb', '--no-yardopts')
     end
-    assert out.empty?, "there should be no output"
-    assert err.empty?, "there should be no errors"
+    assert out.empty?, 'there should be no output'
+    assert err.empty?, 'there should be no errors'
   end
 
-  it "should run with a given path and .yardopts" do
+  it 'should run with a given path and .yardopts' do
     out, err = capture_io do
       # lib/something*.rb doesnot exist in the fixture, it is just given as
       # a command-line path to check if it appears in the parsed filelist
-      @instance = @command.run("lib/something*.rb")
+      @instance = @command.run('lib/something*.rb')
     end
-    refute out.empty?, "there should be no output"
-    assert err.empty?, "there should be no errors"
+    refute out.empty?, 'there should be no output'
+    assert err.empty?, 'there should be no errors'
   end
 
-  it "should parse options with --no-yardopts" do
+  it 'should parse options with --no-yardopts' do
     @options = ::Inch::CLI::Command::Options::List.new
-    @options.parse(["app/**/*.rb", "--no-yardopts"])
-    assert_equal ["app/**/*.rb"], @options.paths
+    @options.parse(['app/**/*.rb', '--no-yardopts'])
+    assert_equal ['app/**/*.rb'], @options.paths
   end
 
-  it "should parse options with a given path and .yardopts" do
+  it 'should parse options with a given path and .yardopts' do
     # lib/something*.rb doesnot exist in the fixture, it is just given as
     # a command-line path to check if it appears in the parsed filelist
     @options = ::Inch::CLI::Command::Options::List.new
-    @options.parse(["lib/something*.rb"])
-    assert_equal ["foo/**/*.rb", "lib/something*.rb"], @options.paths
+    @options.parse(['lib/something*.rb'])
+    assert_equal ['foo/**/*.rb', 'lib/something*.rb'], @options.paths
   end
 
-  it "should output info when run with --help" do
+  it 'should output info when run with --help' do
     out, err = capture_io do
-      assert_raises(SystemExit) { @command.run("--help") }
+      assert_raises(SystemExit) { @command.run('--help') }
     end
-    refute out.empty?, "there should be some output"
-    assert_match /\bUsage\b.+list/, out
+    refute out.empty?, 'there should be some output'
+    assert_match(/\bUsage\b.+list/, out)
     # assert_match /\b\-\-\[no\-\]yardopts\b/, out,
     #              "--[no-]yardopts should be mentioned"
-    assert err.empty?, "there should be no errors"
+    assert err.empty?, 'there should be no errors'
   end
 end
 
 describe ::Inch::CLI::YardoptsHelper do
   before do
     Dir.chdir fixture_path(:ruby, :simple)
-    refute File.file?(".yardopts")
-    refute File.file?(".document")
+    refute File.file?('.yardopts')
+    refute File.file?('.document')
     @command = ::Inch::CLI::Command::List
   end
 
-  it "should not interfere with paths in arguments" do
+  it 'should not interfere with paths in arguments' do
     @options = ::Inch::CLI::Command::Options::List.new
-    @options.parse(["lib/**/foo*.rb"])
-    assert_equal ["lib/**/foo*.rb"], @options.paths
+    @options.parse(['lib/**/foo*.rb'])
+    assert_equal ['lib/**/foo*.rb'], @options.paths
   end
 
-  it "should not intefer with --all at the end" do
+  it 'should not intefer with --all at the end' do
     @options = ::Inch::CLI::Command::Options::List.new
-    @options.parse(["lib/**/foo*.rb", "--all"])
-    assert_equal ["lib/**/foo*.rb"], @options.paths
+    @options.parse(['lib/**/foo*.rb', '--all'])
+    assert_equal ['lib/**/foo*.rb'], @options.paths
   end
 
 end

data/test/unit/code_object/converter_test.rb

@@ -1,9 +1,9 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 describe ::Inch::CodeObject::Converter do
   class MockObject
     def docstring
-      "Foo::Bar"
+      'Foo::Bar'
     end
 
     def parameters
@@ -20,7 +20,7 @@ describe ::Inch::CodeObject::Converter do
   end
 
   let(:object) { MockObject.new }
-  it "should parse all objects" do
+  it 'should parse all objects' do
     attributes = ::Inch::CodeObject::Converter.to_hash(object)
     assert_equal object.docstring, attributes[:docstring]
     assert_equal object.public?, attributes[:public?]

data/test/unit/code_object/provider_test.rb

@@ -1,7 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 describe ::Inch::CodeObject::Provider do
-  it "should parse all objects" do
+  it 'should parse all objects' do
     Dir.chdir File.dirname(__FILE__)
     @provider = ::Inch::CodeObject::Provider.parse(fixture_path(:ruby, :simple))
     refute @provider.objects.empty?

data/test/unit/code_object/proxy_test.rb

@@ -1,49 +1,49 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 describe ::Inch::CodeObject::Proxy do
   before do
-    @codebase = test_codebase(:code_examples)
+    @codebase = test_codebase(:ruby, :code_examples)
     @objects = @codebase.objects
   end
 
   def test_inspect_gives_original_name
-    m = @objects.find("Foo::Bar#method_with_code_example")
-    assert_match /Foo::Bar#method_with_code_example/, m.inspect
+    m = @objects.find('Foo::Bar#method_with_code_example')
+    assert_match(/Foo::Bar#method_with_code_example/, m.inspect)
   end
 
   def test_grade_is_not_nil
-    m = @objects.find("Foo::Bar#method_with_code_example")
+    m = @objects.find('Foo::Bar#method_with_code_example')
     assert m.grade
   end
 
   def test_method_with_code_example
-    m = @objects.find("Foo::Bar#method_with_code_example")
+    m = @objects.find('Foo::Bar#method_with_code_example')
     assert m.has_code_example?
   end
 
   def test_method_with_code_example2
-    m = @objects.find("Foo::Bar#method_with_code_example2")
+    m = @objects.find('Foo::Bar#method_with_code_example2')
     assert m.has_code_example?
   end
 
   def test_method_with_code_examples
-    m = @objects.find("Foo::Bar#method_with_one_example")
+    m = @objects.find('Foo::Bar#method_with_one_example')
     assert m.has_code_example?
     refute m.has_multiple_code_examples?
   end
 
   def test_method_with_code_examples
-    m = @objects.find("Foo::Bar#method_with_examples")
+    m = @objects.find('Foo::Bar#method_with_examples')
     assert m.has_multiple_code_examples?
   end
 
   def test_method_with_code_examples
-    m = @objects.find("Foo::Bar#method_with_tagged_example")
+    m = @objects.find('Foo::Bar#method_with_tagged_example')
     assert m.has_multiple_code_examples?
   end
 
   def test_method_with_code_examples
-    m = @objects.find("Foo::Bar#method_with_2tagged_examples")
+    m = @objects.find('Foo::Bar#method_with_2tagged_examples')
     assert m.has_multiple_code_examples?
   end
 end

data/test/unit/codebase/objects_test.rb

@@ -1,22 +1,22 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 describe ::Inch::Codebase::Objects do
   before do
-    @codebase = test_codebase(:simple)
+    @codebase = test_codebase(:ruby, :simple)
     @objects = @codebase.objects
   end
 
-  it "should parse all objects" do
+  it 'should parse all objects' do
     refute @objects.empty?
   end
 
-  it "should find some objects" do
-    refute_nil @objects.find("Foo")
-    refute_nil @objects.find("Foo::Bar")
-    refute_nil @objects.find("Foo::Bar#method_without_doc")
+  it 'should find some objects' do
+    refute_nil @objects.find('Foo')
+    refute_nil @objects.find('Foo::Bar')
+    refute_nil @objects.find('Foo::Bar#method_without_doc')
   end
 
-  it "should support iteration" do
+  it 'should support iteration' do
     sum = 0
     @objects.each do
       sum += 1

data/test/unit/codebase/proxy_test.rb

@@ -1,17 +1,17 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 describe ::Inch::Codebase::Proxy do
-  it "should parse all objects" do
+  it 'should parse all objects' do
     dir = fixture_path(:ruby, :simple)
-    config = Inch::Config::Codebase.new(:ruby, ["lib/**/*.rb"])
+    config = Inch::Config::Codebase.new(:ruby, ['lib/**/*.rb'])
     config.object_provider :YARD
     @codebase = Inch::Codebase::Proxy.parse dir, config
     refute_nil @codebase.objects
   end
 
-  it "should parse given paths" do
+  it 'should parse given paths' do
     dir = fixture_path(:ruby, :simple)
-    config = Inch::Config::Codebase.new(:ruby, ["app/**/*.rb"])
+    config = Inch::Config::Codebase.new(:ruby, ['app/**/*.rb'])
     config.object_provider :YARD
     @codebase = Inch::Codebase::Proxy.parse dir, config
     assert @codebase.objects.empty?

data/test/unit/config/codebase_test.rb

@@ -1,7 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 describe ::Inch::Config::Codebase do
-  it "should parse .inch.yml" do
+  it 'should parse .inch.yml' do
     dir = fixture_path(:ruby, :simple)
     config = Inch::Config::Codebase.new
     config.update_via_yaml(dir)
@@ -9,7 +9,7 @@ describe ::Inch::Config::Codebase do
     assert config.excluded_files.empty?
   end
 
-  it "should parse .inch.yml if present" do
+  it 'should parse .inch.yml if present' do
     dir = fixture_path(:ruby, :"inch-yml")
     config = Inch::Config::Codebase.new
     config.update_via_yaml(dir)

data/test/unit/config_test.rb

@@ -1,13 +1,13 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 describe ::Inch::Config do
-  it "should return config for :ruby" do
+  it 'should return config for :ruby' do
     config = Inch::Config.for(:ruby)
     refute config.codebase.included_files.empty?
     assert config.codebase.excluded_files.empty?
   end
 
-  it "should parse .inch.yml if present" do
+  it 'should parse .inch.yml if present' do
     dir = fixture_path(:ruby, :"inch-yml")
     config = Inch::Config.for(:ruby, dir)
     refute config.codebase.included_files.empty?
@@ -20,7 +20,7 @@ describe ::Inch::Config do
     assert config.codebase.excluded_files.empty?
   end
 
-  it "should return config.evaluation for :ruby" do
+  it 'should return config.evaluation for :ruby' do
     config = Inch::Config.for(:ruby)
     refute_nil config.evaluation.criteria_for(:MethodObject)
   end

data/test/unit/evaluation/role_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 class MockPrivateRole < ::Inch::Evaluation::Role
   applicable_if :private?
@@ -39,31 +39,31 @@ class MockPublicObject
 end
 
 describe ::Inch::Evaluation::Role do
-  describe ".applicable" do
+  describe '.applicable' do
     let(:private_object) { MockPrivateObject.new }
     let(:public_object) { MockPublicObject.new }
 
-    describe ".applicable_if" do
-      it "should work with a symbol" do
+    describe '.applicable_if' do
+      it 'should work with a symbol' do
         assert MockPrivateRole.applicable?(private_object)
         assert !MockPrivateRole.applicable?(public_object)
       end
 
-      it "should work with a block" do
+      it 'should work with a block' do
         assert MockPublicRole.applicable?(public_object)
         assert MockNotPrivateRole.applicable?(public_object)
         assert !MockPublicRole.applicable?(private_object)
       end
     end
 
-    describe ".applicable_unless" do
-      it "should work with a block" do
+    describe '.applicable_unless' do
+      it 'should work with a block' do
         assert MockNotPrivateRole.applicable?(public_object)
         assert !MockNotPrivateRole.applicable?(private_object)
       end
     end
 
-    it "should work by implementing a class method" do
+    it 'should work by implementing a class method' do
       assert MockIndifferentRole.applicable?(private_object)
       assert MockIndifferentRole.applicable?(public_object)
     end

data/test/unit/language/elixir/code_object/function_object_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../../test_helper')
+
+describe ::Inch::Language::Elixir::CodeObject::FunctionObject do
+  before do
+    @codebase = fresh_codebase(:elixir, :simple, 'all.json')
+    @objects = @codebase.objects
+  end
+
+  describe 'Scores' do
+    #
+    it 'should not' do
+      m = @objects.find('InchEx.generate_docs/3')
+      assert m.score > 50
+    end
+  end
+
+  it 'should recognize the relationship between modules and functions' do
+    mod = @objects.find('InchEx')
+    assert mod.has_children?
+    assert mod.children.size > 1
+    fun = @objects.find('InchEx.generate_docs/3')
+    assert_equal mod, fun.parent
+  end
+
+  it 'should recognize the depth of methods' do
+    m = @objects.find('InchEx')
+    assert_equal 1, m.depth
+    m = @objects.find('InchEx.Config')
+    assert_equal 2, m.depth
+    m = @objects.find('InchEx.Docs.Formatter')
+    assert_equal 3, m.depth
+    m = @objects.find('InchEx.Docs.Formatter.run/2')
+    assert_equal 4, m.depth
+  end
+end

data/test/unit/language/ruby/code_object/method_object_test.rb

@@ -1,41 +1,41 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../../../test_helper')
 
 describe ::Inch::Language::Ruby::CodeObject::MethodObject do
   before do
-    @codebase = test_codebase(:simple)
+    @codebase = test_codebase(:ruby, :simple)
     @objects = @codebase.objects
   end
 
-  describe "Scores" do
+  describe 'Scores' do
     #
-    it "should not count tags that are transitive" do
-      m = @objects.find("InchTest::Deprecated::ClassMethods")
+    it 'should not count tags that are transitive' do
+      m = @objects.find('InchTest::Deprecated::ClassMethods')
       assert_equal 0, m.score
       assert m.undocumented?
     end
 
-    it "counts a @raise tag" do
-      m = @objects.find("InchTest#raising_method_with_comment")
+    it 'counts a @raise tag' do
+      m = @objects.find('InchTest#raising_method_with_comment')
       assert m.score > 0
       refute m.undocumented?
     end
 
-    it "should not count a call to `raise`" do
-      m = @objects.find("InchTest#raising_method")
+    it 'should not count a call to `raise`' do
+      m = @objects.find('InchTest#raising_method')
       assert_equal 0, m.score
       assert m.undocumented?
     end
 
-    it "should not count a call to `yield`" do
-      m = @objects.find("InchTest#yielding_method")
+    it 'should not count a call to `yield`' do
+      m = @objects.find('InchTest#yielding_method')
       assert_equal 0, m.score
       assert m.undocumented?
     end
   end
 
-  describe "Taggings" do
+  describe 'Taggings' do
     #
-    it "should recognize forms of @private-tags" do
+    it 'should recognize forms of @private-tags' do
       %w( InchTest#method_with_private_tag
           InchTest#private_method_with_tomdoc).each do |fullname|
         m = @objects.find(fullname)
@@ -43,7 +43,7 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       end
     end
 
-    it "should recognize forms of internal-tags" do
+    it 'should recognize forms of internal-tags' do
       # @api private in YARD
       # Internal: in TomDoc
       %w( InchTest#private_api_with_yard
@@ -54,8 +54,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
     end
   end
 
-  it "should recognize undocumented methods without parameters" do
-    m = @objects.find("Foo::Bar#method_without_doc")
+  it 'should recognize undocumented methods without parameters' do
+    m = @objects.find('Foo::Bar#method_without_doc')
     refute m.has_doc?
     refute m.has_parameters?
     refute m.return_mentioned?
@@ -64,8 +64,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
     assert_equal 0, m.score
   end
 
-  it "should recognize missing parameter documentation" do
-    m = @objects.find("Foo::Bar#method_with_missing_param_doc")
+  it 'should recognize missing parameter documentation' do
+    m = @objects.find('Foo::Bar#method_with_missing_param_doc')
     assert m.has_doc?
     assert m.has_parameters?
     assert m.return_mentioned?
@@ -83,10 +83,10 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
     assert m.score
   end
 
-  describe "Documentation Styles" do
+  describe 'Documentation Styles' do
     #
-    it "should handle YARD when no additional docstring is given" do
-      m = @objects.find("Foo::Bar#method_without_docstring")
+    it 'should handle YARD when no additional docstring is given' do
+      m = @objects.find('Foo::Bar#method_without_docstring')
       refute m.has_doc?
       assert m.has_parameters?
       assert m.return_mentioned?
@@ -94,8 +94,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should handle YARD when only @return is given" do
-      m = @objects.find("Foo::Bar#method_without_params_or_docstring")
+    it 'should handle YARD when only @return is given' do
+      m = @objects.find('Foo::Bar#method_without_params_or_docstring')
       refute m.has_doc?
       refute m.has_parameters?
       assert m.return_mentioned?
@@ -104,16 +104,17 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should handle unusable return value when only @return [void] is given" do
-      m = @objects.find("Foo::Bar#method_without_usable_return_value")
+    it 'should handle unusable return value when only @return [void]' \
+       ' is given' do
+      m = @objects.find('Foo::Bar#method_without_usable_return_value')
       assert m.return_mentioned?
       assert m.return_described?
 
       assert m.score
     end
 
-    it "should handle RDoc" do
-      m = @objects.find("Foo::Bar#method_with_rdoc_doc")
+    it 'should handle RDoc' do
+      m = @objects.find('Foo::Bar#method_with_rdoc_doc')
       assert m.has_doc?
       assert m.has_parameters?
       p = m.parameter(:param1)
@@ -123,8 +124,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should handle other RDoc styles" do
-      m = @objects.find("Foo::Bar#method_with_other_rdoc_doc")
+    it 'should handle other RDoc styles' do
+      m = @objects.find('Foo::Bar#method_with_other_rdoc_doc')
       assert m.has_doc?
       assert m.has_parameters?
       p = m.parameter(:param1)
@@ -138,8 +139,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should handle yet other RDoc styles" do
-      m = @objects.find("Foo::Bar#method_with_yet_another_rdoc_doc")
+    it 'should handle yet other RDoc styles' do
+      m = @objects.find('Foo::Bar#method_with_yet_another_rdoc_doc')
       assert m.has_doc?
       assert m.has_parameters?
       p = m.parameter(:param1)
@@ -150,8 +151,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should handle unstructured doc styles" do
-      m = @objects.find("Foo::Bar#method_with_unstructured_doc")
+    it 'should handle unstructured doc styles' do
+      m = @objects.find('Foo::Bar#method_with_unstructured_doc')
       assert m.has_doc?
       assert m.has_parameters?
       p = m.parameter(:param1)
@@ -161,8 +162,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should handle unstructured doc styles with an undocumented param" do
-      m = @objects.find("Foo::Bar#method_with_unstructured_doc_missing_params")
+    it 'should handle unstructured doc styles with an undocumented param' do
+      m = @objects.find('Foo::Bar#method_with_unstructured_doc_missing_params')
       assert m.has_doc?
       assert m.has_parameters?
       p = m.parameter(:format)
@@ -172,9 +173,9 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should handle methods (without parameters) that have only a docstring" \
-       " (text comment)" do
-      m = @objects.find("Foo::Bar#method_without_params_or_return_type")
+    it 'should handle methods (without parameters) that have only a docstring' \
+       ' (text comment)' do
+      m = @objects.find('Foo::Bar#method_without_params_or_return_type')
       assert m.has_doc?
       refute m.has_parameters?
       refute m.return_mentioned?
@@ -183,164 +184,165 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
     end
   end
 
-  describe "Getter/Setter Handling" do
+  describe 'Getter/Setter Handling' do
 
-    it "should recognize a getter method" do
-      m = @objects.find("InchTest#getter")
-      assert m.getter?, "should be a getter"
+    it 'should recognize a getter method' do
+      m = @objects.find('InchTest#getter')
+      assert m.getter?, 'should be a getter'
       refute m.setter?
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a setter method" do
-      m = @objects.find("InchTest#attr_setter=")
+    it 'should recognize a setter method' do
+      m = @objects.find('InchTest#attr_setter=')
       refute m.getter?
-      assert m.setter?, "should be a setter"
+      assert m.setter?, 'should be a setter'
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a manually defined setter method" do
-      m = @objects.find("InchTest#manual_setter=")
+    it 'should recognize a manually defined setter method' do
+      m = @objects.find('InchTest#manual_setter=')
       refute m.getter?
-      assert m.setter?, "should be a setter"
+      assert m.setter?, 'should be a setter'
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a getter in a manually defined getter/setter pair" do
-      m = @objects.find("InchTest#manual_getset")
-      assert m.getter?, "should be a getter"
+    it 'should recognize a getter in a manually defined getter/setter pair' do
+      m = @objects.find('InchTest#manual_getset')
+      assert m.getter?, 'should be a getter'
       refute m.setter?
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a setter in a manually defined getter/setter pair" do
-      m = @objects.find("InchTest#manual_getset=")
+    it 'should recognize a setter in a manually defined getter/setter pair' do
+      m = @objects.find('InchTest#manual_getset=')
       refute m.getter?
-      assert m.setter?, "should be a setter"
+      assert m.setter?, 'should be a setter'
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a getter in a getter/setter pair defined via" \
-       " attr_accessor" do
-      m = @objects.find("InchTest#attr_getset")
-      assert m.getter?, "should be a getter"
+    it 'should recognize a getter in a getter/setter pair defined via' \
+       ' attr_accessor' do
+      m = @objects.find('InchTest#attr_getset')
+      assert m.getter?, 'should be a getter'
       refute m.setter?
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a setter in a getter/setter pair defined via" \
-       " attr_accessor" do
-      m = @objects.find("InchTest#attr_getset=")
+    it 'should recognize a setter in a getter/setter pair defined via' \
+       ' attr_accessor' do
+      m = @objects.find('InchTest#attr_getset=')
       refute m.getter?
-      assert m.setter?, "should be a setter"
+      assert m.setter?, 'should be a setter'
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a getter in a getter/setter pair defined via Struct" do
-      m = @objects.find("InchTest::StructGetSet#struct_getset")
-      assert m.getter?, "should be a getter"
+    it 'should recognize a getter in a getter/setter pair defined via Struct' do
+      m = @objects.find('InchTest::StructGetSet#struct_getset')
+      assert m.getter?, 'should be a getter'
       refute m.setter?
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize a setter in a getter/setter pair defined via Struct" do
-      m = @objects.find("InchTest::StructGetSet#struct_getset=")
+    it 'should recognize a setter in a getter/setter pair defined via Struct' do
+      m = @objects.find('InchTest::StructGetSet#struct_getset=')
       refute m.getter?
-      assert m.setter?, "should be a setter"
+      assert m.setter?, 'should be a setter'
       refute m.has_doc?
       assert_equal 0, m.score
     end
 
-    it "should recognize docs on a getter in a getter/setter pair defined via" \
-       " attr_accessor" do
-      m = @objects.find("Attributes#username")
+    it 'should recognize docs on a getter in a getter/setter pair defined via' \
+       ' attr_accessor' do
+      m = @objects.find('Attributes#username')
       refute_equal 0, m.score
       refute m.undocumented?
     end
 
-    it "should recognize docs on a setter in a getter/setter pair defined via" \
-       " attr_accessor" do
-      m = @objects.find("Attributes#username=")
+    it 'should recognize docs on a setter in a getter/setter pair defined via' \
+       ' attr_accessor' do
+      m = @objects.find('Attributes#username=')
       refute_equal 0, m.score
       refute m.undocumented?
     end
 
-    it "should recognize splat parameter notation" do
+    it 'should recognize splat parameter notation' do
       # it should assign the same score whether the parameter is
       # described with or without the splat (*) operator
-      m1 = @objects.find("Foo#method_with_splat_parameter")
-      m2 = @objects.find("Foo#method_with_splat_parameter2")
+      m1 = @objects.find('Foo#method_with_splat_parameter')
+      m2 = @objects.find('Foo#method_with_splat_parameter2')
       assert_equal 1, m1.parameters.size
       assert_equal 1, m2.parameters.size
       assert_equal m1.score, m2.score
     end
 
-    it "should recognize alias methods and aliased methods" do
-      m1 = @objects.find("InchTest#_aliased_method")
-      m2 = @objects.find("InchTest#_alias_method")
+    it 'should recognize alias methods and aliased methods' do
+      m1 = @objects.find('InchTest#_aliased_method')
+      m2 = @objects.find('InchTest#_alias_method')
       assert_equal m1.score, m2.score
     end
   end
 
-  describe "YARDs @!attribute directive on a class" do
+  describe 'YARDs @!attribute directive on a class' do
     #
-    it "should work as a reader" do
-      m = @objects.find("Attributes#email")
+    it 'should work as a reader' do
+      m = @objects.find('Attributes#email')
       refute_equal 0, m.score
       refute m.undocumented?
     end
 
-    it "should work as a writer" do
-      m = @objects.find("Attributes#email=")
+    it 'should work as a writer' do
+      m = @objects.find('Attributes#email=')
       refute_equal 0, m.score
       # refute m.undocumented?
       # NOTE: this is undocumented since there is no original_docstring
     end
   end
 
-  describe "YARDs @overload tag on methods" do
+  describe 'YARDs @overload tag on methods' do
     #
-    it "should work with basic overloading" do
+    it 'should work with basic overloading' do
       list = []
-      list << @objects.find("Overloading#rgb")
-      list << @objects.find("Overloading#rgba")
-      list << @objects.find("Overloading#change_color")
-      list << @objects.find("Overloading#mix")
-      list << @objects.find("Overloading#hooks")
-      list << @objects.find("Overloading#identifiers")
-      list << @objects.find("Overloading#params_only_in_overloads")
+      list << @objects.find('Overloading#rgb')
+      list << @objects.find('Overloading#rgba')
+      list << @objects.find('Overloading#change_color')
+      list << @objects.find('Overloading#mix')
+      list << @objects.find('Overloading#hooks')
+      list << @objects.find('Overloading#identifiers')
+      list << @objects.find('Overloading#params_only_in_overloads')
       list.each do |m|
         assert_equal 100, m.score, "#{m.fullname} did not get 100"
       end
     end
 
-    it "should work with a malformed @param tag in an overload tag" do
-      m = @objects.find("Overloading#missing_param_names")
+    it 'should work with a malformed @param tag in an overload tag' do
+      m = @objects.find('Overloading#missing_param_names')
       refute m.has_doc? # it may be mentioned in the docs, but it's malformed.
     end
 
-    it "should work with several overload tags on the same method" do
+    it 'should work with several overload tags on the same method' do
       skip
-      m = @objects.find("Overloading#many_overloads")
+      m = @objects.find('Overloading#many_overloads')
       assert_equal 1, count_roles(
         m, Inch::Language::Ruby::Evaluation::Role::Method::WithoutReturnDescription)
       assert_equal 1, count_roles(
         m, Inch::Language::Ruby::Evaluation::Role::Method::WithoutReturnType)
       assert_equal 1, count_roles(
-        m, Inch::Language::Ruby::Evaluation::Role::MethodParameter::WithoutMention, "block")
+        m, Inch::Language::Ruby::Evaluation::Role::MethodParameter::WithoutMention,
+        'block')
     end
 
-    it "should work if @param tags are only present in the @overload tags," \
-       " but not on the actual method" do
-      m = @objects.find("Overloading#params_only_in_overloads")
+    it 'should work if @param tags are only present in the @overload tags,' \
+       ' but not on the actual method' do
+      m = @objects.find('Overloading#params_only_in_overloads')
       unexpected_roles = [
         Inch::Language::Ruby::Evaluation::Role::Object::WithoutCodeExample,
         Inch::Language::Ruby::Evaluation::Role::MethodParameter::WithoutMention,
@@ -349,8 +351,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert_roles m, [], unexpected_roles
     end
 
-    it "should work with one param missing in the overload tag" do
-      m = @objects.find("Overloading#one_param_missing_in_overload")
+    it 'should work with one param missing in the overload tag' do
+      m = @objects.find('Overloading#one_param_missing_in_overload')
       unexpected_roles = [
         Inch::Language::Ruby::Evaluation::Role::Object::WithoutCodeExample
       ]
@@ -362,12 +364,12 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
     end
   end
 
-  describe "MISC" do
+  describe 'MISC' do
     #
-    it "should recognize named parameters in Ruby 2.1" do
+    it 'should recognize named parameters in Ruby 2.1' do
       skip # unless RUBY_VERSION =~ /^2/
 
-      m = @objects.find("Foo#method_with_named_parameter")
+      m = @objects.find('Foo#method_with_named_parameter')
       unexpected_roles = [
         Inch::Language::Ruby::Evaluation::Role::MethodParameter::WithoutMention,
         Inch::Language::Ruby::Evaluation::Role::MethodParameter::WithoutType
@@ -375,10 +377,10 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert_roles m, [], unexpected_roles
     end
 
-    it "should recognize indented parameter documentation" do
+    it 'should recognize indented parameter documentation' do
       skip # YARD cannot parse this
 
-      m = @objects.find("Foo#method_with_indented_param_tag")
+      m = @objects.find('Foo#method_with_indented_param_tag')
       unexpected_roles = [
         Inch::Language::Ruby::Evaluation::Role::MethodParameter::WithoutMention,
         Inch::Language::Ruby::Evaluation::Role::MethodParameter::WithoutType
@@ -386,8 +388,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert_roles m, [], unexpected_roles
     end
 
-    it "should recognize wrong parameter documentation" do
-      m = @objects.find("Foo::Bar#method_with_wrong_doc")
+    it 'should recognize wrong parameter documentation' do
+      m = @objects.find('Foo::Bar#method_with_wrong_doc')
       assert m.has_doc?
       assert m.has_parameters?
       assert m.return_mentioned?
@@ -410,8 +412,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score
     end
 
-    it "should recognize fully-documented methods with parameters" do
-      m = @objects.find("Foo::Bar#method_with_full_doc")
+    it 'should recognize fully-documented methods with parameters' do
+      m = @objects.find('Foo::Bar#method_with_full_doc')
       assert m.has_doc?
       assert m.has_parameters?
       assert m.return_mentioned?
@@ -427,8 +429,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert_equal 100, m.score
     end
 
-    it "should recognize question mark methods" do
-      m = @objects.find("InchTest#question_mark_method?")
+    it 'should recognize question mark methods' do
+      m = @objects.find('InchTest#question_mark_method?')
       refute m.has_doc?
       refute m.has_parameters?
 
@@ -436,8 +438,8 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert_equal 0, m.score
     end
 
-    it "should recognize question mark methods with description" do
-      m = @objects.find("InchTest#question_mark_method_with_description?")
+    it 'should recognize question mark methods with description' do
+      m = @objects.find('InchTest#question_mark_method_with_description?')
       refute m.has_doc?
       refute m.has_parameters?
 
@@ -445,26 +447,26 @@ describe ::Inch::Language::Ruby::CodeObject::MethodObject do
       assert m.score >= 50 # TODO: don't use magic numbers
     end
 
-    it "should recognize question mark methods with description and" \
-       " parameters" do
-      m = @objects.find("InchTest#method_with_description_and_parameters?")
+    it 'should recognize question mark methods with description and' \
+       ' parameters' do
+      m = @objects.find('InchTest#method_with_description_and_parameters?')
       refute m.has_doc?
       assert m.has_parameters?
 
       assert m.score > 0
     end
 
-    it "should recognize the depth of methods" do
-      m = @objects.find("#root_method")
+    it 'should recognize the depth of methods' do
+      m = @objects.find('#root_method')
       assert_equal 1, m.depth
-      m = @objects.find("InchTest#getter")
+      m = @objects.find('InchTest#getter')
       assert_equal 2, m.depth
-      m = @objects.find("Foo::Bar#method_without_doc")
+      m = @objects.find('Foo::Bar#method_without_doc')
       assert_equal 3, m.depth
     end
 
-    it "should recognize docs on class variables" do
-      m = @objects.find("Foo::@@class_variable")
+    it 'should recognize docs on class variables' do
+      m = @objects.find('Foo::@@class_variable')
       assert m.has_doc?
       refute m.undocumented?
       assert_equal 100, m.score