yard 0.9.5 → 0.9.6

data/spec/handlers/alias_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AliasHandler" do
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AliasHandler" do
   before(:all) { parse_file :alias_handler_001, __FILE__ }
 
   it "throws alias into namespace object list" do

data/spec/handlers/attribute_handler_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandler" do
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandler" do
   before(:all) { parse_file :attribute_handler_001, __FILE__ }
 
   def read_write(namespace, name, read, write, scope = :instance)
-    rname, wname = namespace.to_s+"#"+name.to_s, namespace.to_s+"#"+name.to_s+"="
+    rname = namespace.to_s + "#" + name.to_s
+    wname = namespace.to_s + "#" + name.to_s + "="
     if read
       expect(Registry.at(rname)).to be_instance_of(CodeObjects::MethodObject)
     else
@@ -18,8 +20,8 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandl
     end
 
     attrs = Registry.at(namespace).attributes[scope][name]
-    expect(attrs[:read]).to eq (read ? Registry.at(rname) : nil)
-    expect(attrs[:write]).to eq (write ? Registry.at(wname) : nil)
+    expect(attrs[:read]).to eq(read ? Registry.at(rname) : nil)
+    expect(attrs[:write]).to eq(write ? Registry.at(wname) : nil)
   end
 
   it "parses attributes inside modules too" do
@@ -91,4 +93,4 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandl
   it "maintains visibility for attr_reader" do
     expect(Registry.at('D#parser').visibility).to eq :protected
   end
-end
+end

data/spec/handlers/base_spec.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 require 'ostruct'
 
 include Parser
 
-describe YARD::Handlers::Base do
+RSpec.describe YARD::Handlers::Base do
   describe "#handles and inheritance" do
     before do
       allow(Handlers::Base).to receive(:inherited)
@@ -160,9 +161,9 @@ describe YARD::Handlers::Base do
     def create_handler(stmts, parser_type)
       $handler_counter ||= 0
       sklass = parser_type == :ruby ? "Base" : "Legacy::Base"
-      instance_eval(<<-eof)
+      instance_eval(<<-eof, __FILE__, __LINE__ + 1)
         class ::InFileHandler#{$handler_counter += 1} < Handlers::Ruby::#{sklass}
-          handles /^class/
+          handles(/^class/)
           #{stmts}
           def process; MethodObject.new(:root, :FOO) end
         end
@@ -175,7 +176,7 @@ describe YARD::Handlers::Base do
       create_handler(stmts, parser_type)
       parse(file, parser_type)
       expect(Registry.at('#FOO')).send(creates ? :not_to : :to, be_nil)
-      Handlers::Base.subclasses.delete_if {|k,v| k.to_s =~ /^InFileHandler/ }
+      Handlers::Base.subclasses.delete_if {|k, _v| k.to_s =~ /^InFileHandler/ }
     end
 
     [:ruby, :ruby18].each do |parser_type|
@@ -198,13 +199,13 @@ describe YARD::Handlers::Base do
         end
 
         it "allows a Regexp as argument and test against full path" do
-          test_handler 'file_a.rbx', 'in_file /\.rbx$/', true, parser_type
-          test_handler '/path/to/file_a.rbx', 'in_file /\/to\/file_/', true, parser_type
-          test_handler '/path/to/file_a.rbx', 'in_file /^\/path/', true, parser_type
+          test_handler 'file_a.rbx', 'in_file(/\.rbx$/)', true, parser_type
+          test_handler '/path/to/file_a.rbx', 'in_file(/\/to\/file_/)', true, parser_type
+          test_handler '/path/to/file_a.rbx', 'in_file(/^\/path/)', true, parser_type
         end
 
         it "allows multiple in_file declarations" do
-          stmts = 'in_file "x"; in_file /y/; in_file "foo.rb"'
+          stmts = 'in_file "x"; in_file(/y/); in_file "foo.rb"'
           test_handler 'foo.rb', stmts, true, parser_type
           test_handler 'xyzzy.rb', stmts, true, parser_type
           test_handler 'x', stmts, true, parser_type

data/spec/handlers/c/alias_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::AliasHandler do
+RSpec.describe YARD::Handlers::C::AliasHandler do
   it "allows defining of aliases (rb_define_alias)" do
     parse <<-eof
       /* FOO */

data/spec/handlers/c/attribute_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::AttributeHandler do
+RSpec.describe YARD::Handlers::C::AttributeHandler do
   def run(read, write, commented = nil)
     parse <<-eof
       /* FOO */

data/spec/handlers/c/class_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::ClassHandler do
+RSpec.describe YARD::Handlers::C::ClassHandler do
   it "registers classes" do
     parse_init 'cFoo = rb_define_class("Foo", rb_cObject);'
     expect(Registry.at('Foo').type).to eq :class

data/spec/handlers/c/constant_handler_spec.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::ConstantHandler do
+RSpec.describe YARD::Handlers::C::ConstantHandler do
   it "registers constants" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_const(mFoo, "FOO", ID2SYM(100));
       rb_define_global_const("BAR", ID2SYM(100));
     eof
-   expect( Registry.at('Foo::FOO').type).to eq :constant
-   expect( Registry.at('BAR').type).to eq :constant
+    expect(Registry.at('Foo::FOO').type).to eq :constant
+    expect(Registry.at('BAR').type).to eq :constant
   end
 
   it "looks for override comments" do
@@ -67,4 +68,4 @@ describe YARD::Handlers::C::ConstantHandler do
     expect(foo.value).to eq '100:x:y'
     expect(foo.docstring).to eq 'foobar:x!'
   end
-end
+end

data/spec/handlers/c/init_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::InitHandler do
+RSpec.describe YARD::Handlers::C::InitHandler do
   it "adds documentation in Init_ClassName() to ClassName" do
     parse(<<-eof)
       // Bar!

data/spec/handlers/c/method_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::MethodHandler do
+RSpec.describe YARD::Handlers::C::MethodHandler do
   it "registers methods" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");

data/spec/handlers/c/mixin_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::MixinHandler do
+RSpec.describe YARD::Handlers::C::MixinHandler do
   it "adds includes to modules or classes" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");

data/spec/handlers/c/module_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::ClassHandler do
+RSpec.describe YARD::Handlers::C::ClassHandler do
   it "registers modules" do
     parse_init 'mFoo = rb_define_module("Foo");'
     expect(Registry.at('Foo').type).to eq :module

data/spec/handlers/c/override_comment_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::OverrideCommentHandler do
+RSpec.describe YARD::Handlers::C::OverrideCommentHandler do
   [:class, :module].each do |type|
     it "handles Document-#{type}" do
       parse(<<-eof)

data/spec/handlers/c/path_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe YARD::Handlers::C::PathHandler do
+RSpec.describe YARD::Handlers::C::PathHandler do
   it "tracks variable names defined under namespaces" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");

data/spec/handlers/c/spec_helper.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + "/../spec_helper"
+# frozen_string_literal: true
 
 def parse(src, file = '(stdin)')
   YARD::Registry.clear

data/spec/handlers/c/struct_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe YARD::Handlers::C::StructHandler do
+RSpec.describe YARD::Handlers::C::StructHandler do
   after { Registry.clear }
 
   it "handles Struct class definitions" do
@@ -12,4 +13,4 @@ describe YARD::Handlers::C::StructHandler do
     expect(Registry.at('Range').type).to eq :class
     expect(Registry.at('Range').superclass).to eq P(:Foo)
   end
-end
+end

data/spec/handlers/class_condition_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
   before(:all) { parse_file :class_condition_handler_001, __FILE__ }
 
   def verify_method(*names)
@@ -64,4 +65,4 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassCondition
     eof
     no_undoc_error "if caller.none? { |l| l =~ %r{lib/rails/generators\\.rb:(\\d+):in `lookup!'$} }; end"
   end
-end
+end

data/spec/handlers/class_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
   before(:all) { parse_file :class_handler_001, __FILE__ }
 
   it "parses a class block with docstring" do
@@ -243,4 +244,4 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler"
   it "handles inheritance from 'self'" do
     expect(Registry.at('Outer1::Inner1').superclass).to eq Registry.at('Outer1')
   end
-end
+end

data/spec/handlers/class_method_handler_shared_examples.rb

@@ -1,9 +1,10 @@
-shared_examples "class method visibility decorator" do
+# frozen_string_literal: true
+RSpec.shared_examples "class method visibility decorator" do
   # Use let(:visibility) to specify the name of the x_class_method
   # visibility decorator to test.
 
   describe do
-    before {
+    before do
       StubbedSourceParser.parse_string <<-CODE
         class A
           def self.b; end
@@ -15,7 +16,7 @@ shared_examples "class method visibility decorator" do
           #{visibility}_class_method("e")
         end
       CODE
-    }
+    end
 
     it "handles private_class_method statement" do
       expect(Registry.at('A.c').visibility).to eq visibility
@@ -42,7 +43,7 @@ shared_examples "class method visibility decorator" do
   end
 
   describe "handles reopened class" do
-    before {
+    before do
       StubbedSourceParser.parse_string <<-CODE
         class SingletonClass
 
@@ -78,7 +79,7 @@ shared_examples "class method visibility decorator" do
 
         end
       CODE
-    }
+    end
 
     specify do
       expect(Registry.at('SingletonClass.foo').visibility).not_to eq visibility
@@ -94,7 +95,7 @@ shared_examples "class method visibility decorator" do
     # Valid as of Ruby 2.1.0:
     # private_class_method def self.foo; end
 
-    let(:code) {
+    let(:code) do
       <<-CODE
         class SingletonClass
           # Valid Ruby 2.1.0 syntax.
@@ -103,7 +104,7 @@ shared_examples "class method visibility decorator" do
           end
         end
       CODE
-    }
+    end
 
     let(:method_def) { "#{visibility}_class_method def self.foo param1, param2" }
 
@@ -114,7 +115,7 @@ shared_examples "class method visibility decorator" do
     end
 
     it "handles parameters correctly" do
-      expect(subject.parameters.map { |p| p.first }).to eq ['param1', 'param2']
+      expect(subject.parameters.map(&:first)).to eq ['param1', 'param2']
     end
 
     it "attaches documentation to method definition" do

data/spec/handlers/class_variable_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassVariableHandler" do
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassVariableHandler" do
   before(:all) { parse_file :class_variable_handler_001, __FILE__ }
 
   it "does not parse class variables inside methods" do
@@ -8,4 +9,4 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassVariableH
     expect(obj.source).to eq "@@somevar = \"hello\""
     expect(obj.value).to eq '"hello"'
   end
-end
+end

data/spec/handlers/constant_handler_spec.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandler" do
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandler" do
   before(:all) { parse_file :constant_handler_001, __FILE__ }
 
   it "does not parse constants inside methods" do
@@ -12,7 +13,7 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandle
   end
 
   it "maintains newlines" do
-    expect(Registry.at("A::B::MYCONSTANT").value.gsub("\r", "")).to eq "A +\nB +\nC +\nD"
+    expect(Registry.at("A::B::MYCONSTANT").value.delete("\r")).to eq "A +\nB +\nC +\nD"
   end
 
   it "turns Const = Struct.new(:sym) into class Const with attr :sym" do
@@ -73,4 +74,28 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandle
       eof
     end
   end unless LEGACY_PARSER
-end
+
+  it "allows constant to have same name as constant in parent namespace" do
+    YARD.parse_string <<-eof
+      module A
+        class C; end
+        module B; C = 1 end
+      end
+    eof
+    expect(log.io.string).to eq ""
+    expect(Registry.at('A::B::C').type).to eq :constant
+  end
+
+  it "detects compound constant names" do
+    YARD.parse_string <<-eof
+      module A
+        class AA; end
+        AA::B = true
+      end
+      A::AA::C = true
+    eof
+
+    expect(Registry.at('A::AA::B').type).to eq :constant
+    expect(Registry.at('A::AA::C').type).to eq :constant
+  end if HAVE_RIPPER
+end

data/spec/handlers/decorator_handler_methods_spec.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
+RSpec.describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
   describe "#process_decorator" do
-
     # Create a YARD decorator handler.
     # @param name [Symbol] name of the mock decorator
     def create_test_handler(name)
@@ -22,11 +22,11 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
           # process_decorator params written like this due to Ruby 1.8.
           # A modern handler should splat local_nodes.
           local_data[:return] =
-          process_decorator *(local_nodes + [local_mock_handler_opts]) do |method, node, name|
-            local_data[:method] = method
-            local_data[:node] = node
-            local_data[:name] = name
-          end
+            process_decorator(*(local_nodes + [local_mock_handler_opts])) do |method, node, mname|
+              local_data[:method] = method
+              local_data[:node] = node
+              local_data[:name] = mname
+            end
         end
       end
     end
@@ -35,10 +35,10 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
     # @param symbols [Symbol] method names
     # @return [String] method definition code
     def make_defs(*symbols)
-      symbols.map { |s|
+      symbols.map do |s|
         s = "self.#{s}" if mock_handler_opts[:scope] == :class
         "def #{s}; end"
-      }.join("\n")
+      end.join("\n")
     end
 
     # Generate an AST for the given source code string.
@@ -56,15 +56,17 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
     let(:param_string)  { 'def foo param1, param2; end' }
     let(:method_defs)   { [] }
     let(:method_string) { "#{class_name}#foo" }
-    let(:code) {"
+    let(:code) do
+      <<-eof
       class #{class_name}
-        #{make_defs *method_defs}
+        #{make_defs(*method_defs)}
         # #{docstring}
         mock_decorator #{param_string}
       end
-    "}
+      eof
+    end
 
-    before {
+    before do
       Registry.clear
       YARD::Handlers::Base.clear_subclasses
 
@@ -74,7 +76,7 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
       create_test_handler :third
 
       StubbedSourceParser.parse_string code
-    }
+    end
 
     it "returns an array of hashes containing the method proxy, node, and name" do
       expect(subject[:return]).to be_an Array
@@ -84,16 +86,16 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
     end
 
     describe "method is a MethodObject if the method has been defined" do
-      let(:code) {"class DecoratorTest; mock_decorator def foo; end; end"}
+      let(:code) { "class DecoratorTest; mock_decorator def foo; end; end" }
 
       specify do
-        expect(subject[:return].first[:method]) \
-          .to be_a YARD::CodeObjects::MethodObject
+        expect(subject[:return].first[:method]).
+          to be_a YARD::CodeObjects::MethodObject
       end
     end
 
     describe "method is a Proxy if the method has not been defined" do
-      let(:code) {"class DecoratorTest; mock_decorator :foo; end"}
+      let(:code) { "class DecoratorTest; mock_decorator :foo; end" }
 
       specify do
         expect(subject[:return].first[:method]).to be_a YARD::CodeObjects::Proxy
@@ -120,7 +122,7 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
     end
 
     describe "nodes argument" do
-      subject { data[:mock][:return].map { |h| h[:method].to_s } }
+      subject { data[:mock][:return].map {|h| h[:method].to_s } }
 
       describe "assumes all params refer to methods by default" do
         let(:method_defs)  { [:foo, :bar] }
@@ -134,11 +136,11 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
 
       describe "can specify which params to capture as methods" do
         let(:method_defs) { [:foo, :bar, :baz, :bat] }
-        let(:parameters) {
+        let(:parameters) do
           [:option_1, :baz, :bat, :option_2, :foo, :bar].map do |s|
             make_ast s.inspect
           end
-        }
+        end
 
         describe "as a single param" do
           let(:nodes) { parameters[4] }
@@ -200,7 +202,6 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
       end
 
       describe "creates method proxies" do
-
         shared_examples "decorator helper scope" do
           let(:param_string) { decorator_params.map(&:inspect).join(',') }
 
@@ -234,10 +235,10 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
 
           describe "for methods" do
             let(:param_string) { decorator_params.join(',') }
-            let(:decorator_params) {[
-              "def #{'self.' if mock_handler_opts[:scope] == :class}foo f1, f2; end",
-              "def #{'self.' if mock_handler_opts[:scope] == :class}bar b1, b2; end"
-            ]}
+            let(:decorator_params) do
+              ["def #{'self.' if mock_handler_opts[:scope] == :class}foo f1, f2; end",
+              "def #{'self.' if mock_handler_opts[:scope] == :class}bar b1, b2; end"]
+            end
 
             specify do
               expect(subject.count).to eq decorator_params.count
@@ -253,7 +254,7 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
           end
         end # decorator helper scope shared examples
 
-        subject { data[:mock][:return].map { |h| h[:method] } }
+        subject { data[:mock][:return].map {|h| h[:method] } }
 
         let(:docstring) { 'the foo method' }
         let(:method_defs) { [:foo, :bar] }
@@ -281,12 +282,14 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
 
       describe "does not attach" do
         describe "to undefined methods" do
-          let(:code) {"
+          let(:code) do
+            <<-eof
             class #{class_name}
               # #{docstring}
               mock_decorator :foo
             end
-          "}
+            eof
+          end
 
           specify do
             expect(subject).not_to respond_to :docstring
@@ -294,7 +297,8 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
         end
 
         describe "to methods with existing docstring" do
-          let(:code) {"
+          let(:code) do
+            <<-eof
             class #{class_name}
 
               # original docstring
@@ -303,7 +307,8 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
               # #{docstring}
               mock_decorator :foo
             end
-          "}
+            eof
+          end
 
           specify do
             expect(subject.docstring).to eq 'original docstring'
@@ -316,13 +321,15 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
       subject { Registry.at method_string }
 
       let(:param_string) { 'def foo param1, param2; end' }
-      let(:code) {"
+      let(:code) do
+        <<-eof
         class #{class_name}
-          #{make_defs *method_defs}
+          #{make_defs(*method_defs)}
           # #{docstring}
           first_decorator second_decorator third_decorator #{param_string}
         end
-      "}
+        eof
+      end
 
       specify "register nested method defs" do
         expect(subject).to be_a YARD::CodeObjects::MethodObject
@@ -352,16 +359,16 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
       end
 
       specify "don't transfer docstring to other decorators" do
-        expect(Registry.at("#{class_name}#second_decorator")) \
-          .not_to respond_to :docstring
+        expect(Registry.at("#{class_name}#second_decorator")).
+          not_to respond_to :docstring
 
-        expect(Registry.at("#{class_name}#third_decorator")) \
-          .not_to respond_to :docstring
+        expect(Registry.at("#{class_name}#third_decorator")).
+          not_to respond_to :docstring
       end
 
-      describe "transfer source to decorated method defs" do 
+      describe "transfer source to decorated method defs" do
         specify do
-          expect(subject.source).to eq code.lines.to_a[-3].strip
+          expect(subject.source).to eq code.lines.to_a[-2].strip
         end
 
         describe "unless opt-out param is set" do
@@ -381,25 +388,6 @@ describe "YARD::Handlers::Ruby::DecoratorHandlerMethods" do
           expect(subject.source).to eq make_defs(*method_defs)
         end
       end
-
-      describe "are tagged" do
-        let(:method_defs)  { [:foo, :bar] }
-        let(:param_string) { method_defs.map(&:inspect).join(',') }
-
-        specify do
-          expect(subject.tags.count).to eq 3
-
-          subject.tags.each do |tag|
-            expect(tag.tag_name).to eq 'decorator'
-          end
-
-          expect(subject.tags.map(&:text)).to eq [
-            'third_decorator',
-            'second_decorator',
-            'first_decorator'
-          ]
-        end
-      end
     end
   end # process_decorator
 end unless LEGACY_PARSER