yard 0.9.18 → 0.9.19

data/spec/handlers/alias_handler_spec.rb

@@ -1,82 +1,82 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-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
-    expect(P(:A).aliases[P("A#b")]).to eq :a
-  end
-
-  ['c', 'd?', '[]', '[]=', '-@', '%', '*', 'cstrkey', 'cstrmeth'].each do |a|
-    it "handles the Ruby 'alias' keyword syntax for method ##{a}" do
-      expect(P('A#' + a)).to be_instance_of(CodeObjects::MethodObject)
-      expect(P('A#' + a).is_alias?).to be true
-    end
-  end
-
-  it "handles keywords as the alias name" do
-    expect(P('A#for')).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  it "allows ConstantNames to be specified as aliases" do
-    expect(P('A#ConstantName')).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  it "creates a new method object for the alias" do
-    expect(P("A#b")).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  it "pulls the method into the current class if it's from another one" do
-    expect(P(:B).aliases[P("B#q")]).to eq :x
-    expect(P(:B).aliases[P("B#r?")]).to eq :x
-  end
-
-  it "gracefully fails to pull a method in if the original method cannot be found" do
-    expect(P(:B).aliases[P("B#s")]).to eq :to_s
-  end
-
-  it "allows complex Ruby expressions after the alias parameters" do
-    expect(P(:B).aliases[P("B#t")]).to eq :inspect
-  end
-
-  it "shows up in #is_alias? for method" do
-    expect(P("B#t").is_alias?).to be true
-    expect(P('B#r?').is_alias?).to be true
-  end
-
-  it "allows operators and keywords to be specified as symbols" do
-    expect(P('B#<<')).to be_instance_of(CodeObjects::MethodObject)
-    expect(P('B#for')).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  it "handles keywords in alias names" do
-    expect(P('B#do').is_alias?).to be true
-    expect(P('B#x2').is_alias?).to be true
-    expect(P(:B).aliases[P('B#do')]).to eq :x
-    expect(P(:B).aliases[P('B#x2')]).to eq :do
-  end
-
-  it "handles quoted symbols" do
-    foo = Registry.at('A#foo')
-    expect(foo).not_to be nil
-    expect(foo.is_alias?).to be true
-    expect(Registry.at('A').aliases[foo]).to eq :a
-  end
-
-  it "prepends aliases object's docstring to comments" do
-    expect(Registry.at('D#a').tag(:return).types).to eq ['Numeric']
-    expect(Registry.at('D#b').tag(:return).types).to eq ['String']
-    expect(Registry.at('D#b').docstring).to eq "Foo bar"
-  end
-
-  it "raises an UndocumentableError if only one parameter is passed" do
-    undoc_error "alias_method :q"
-  end
-
-  it "raises an UndocumentableError if the parameter is not a Symbol or String" do
-    undoc_error "alias_method CONST, Something"
-    undoc_error "alias_method variable, ClassName"
-    undoc_error "alias_method variable, other_variable"
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+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
+    expect(P(:A).aliases[P("A#b")]).to eq :a
+  end
+
+  ['c', 'd?', '[]', '[]=', '-@', '%', '*', 'cstrkey', 'cstrmeth'].each do |a|
+    it "handles the Ruby 'alias' keyword syntax for method ##{a}" do
+      expect(P('A#' + a)).to be_instance_of(CodeObjects::MethodObject)
+      expect(P('A#' + a).is_alias?).to be true
+    end
+  end
+
+  it "handles keywords as the alias name" do
+    expect(P('A#for')).to be_instance_of(CodeObjects::MethodObject)
+  end
+
+  it "allows ConstantNames to be specified as aliases" do
+    expect(P('A#ConstantName')).to be_instance_of(CodeObjects::MethodObject)
+  end
+
+  it "creates a new method object for the alias" do
+    expect(P("A#b")).to be_instance_of(CodeObjects::MethodObject)
+  end
+
+  it "pulls the method into the current class if it's from another one" do
+    expect(P(:B).aliases[P("B#q")]).to eq :x
+    expect(P(:B).aliases[P("B#r?")]).to eq :x
+  end
+
+  it "gracefully fails to pull a method in if the original method cannot be found" do
+    expect(P(:B).aliases[P("B#s")]).to eq :to_s
+  end
+
+  it "allows complex Ruby expressions after the alias parameters" do
+    expect(P(:B).aliases[P("B#t")]).to eq :inspect
+  end
+
+  it "shows up in #is_alias? for method" do
+    expect(P("B#t").is_alias?).to be true
+    expect(P('B#r?').is_alias?).to be true
+  end
+
+  it "allows operators and keywords to be specified as symbols" do
+    expect(P('B#<<')).to be_instance_of(CodeObjects::MethodObject)
+    expect(P('B#for')).to be_instance_of(CodeObjects::MethodObject)
+  end
+
+  it "handles keywords in alias names" do
+    expect(P('B#do').is_alias?).to be true
+    expect(P('B#x2').is_alias?).to be true
+    expect(P(:B).aliases[P('B#do')]).to eq :x
+    expect(P(:B).aliases[P('B#x2')]).to eq :do
+  end
+
+  it "handles quoted symbols" do
+    foo = Registry.at('A#foo')
+    expect(foo).not_to be nil
+    expect(foo.is_alias?).to be true
+    expect(Registry.at('A').aliases[foo]).to eq :a
+  end
+
+  it "prepends aliases object's docstring to comments" do
+    expect(Registry.at('D#a').tag(:return).types).to eq ['Numeric']
+    expect(Registry.at('D#b').tag(:return).types).to eq ['String']
+    expect(Registry.at('D#b').docstring).to eq "Foo bar"
+  end
+
+  it "raises an UndocumentableError if only one parameter is passed" do
+    undoc_error "alias_method :q"
+  end
+
+  it "raises an UndocumentableError if the parameter is not a Symbol or String" do
+    undoc_error "alias_method CONST, Something"
+    undoc_error "alias_method variable, ClassName"
+    undoc_error "alias_method variable, other_variable"
+  end
+end

data/spec/handlers/attribute_handler_spec.rb

@@ -1,96 +1,96 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-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 = 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
-      expect(Registry.at(rname)).to eq nil
-    end
-
-    if write
-      expect(Registry.at(wname)).to be_kind_of(CodeObjects::MethodObject)
-    else
-      expect(Registry.at(wname)).to eq nil
-    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)
-  end
-
-  it "parses attributes inside modules too" do
-    expect(Registry.at("A#x=")).not_to eq nil
-  end
-
-  it "parses 'attr'" do
-    read_write(:B, :a, true, true)
-    read_write(:B, :a2, true, false)
-    read_write(:B, "a3", true, false)
-  end
-
-  it "parses 'attr_reader'" do
-    read_write(:B, :b, true, false)
-  end
-
-  it "parses 'attr_writer'" do
-    read_write(:B, :e, false, true)
-  end
-
-  it "parses 'attr_accessor'" do
-    read_write(:B, :f, true, true)
-  end
-
-  it "parses a list of attributes" do
-    read_write(:B, :b, true, false)
-    read_write(:B, :c, true, false)
-    read_write(:B, :d, true, false)
-  end
-
-  it "has a default docstring if one is not supplied" do
-    expect(Registry.at("B#f=").docstring).not_to be_empty
-  end
-
-  it "sets the correct docstring if one is supplied" do
-    expect(Registry.at("B#b").docstring).to eq "Docstring"
-    expect(Registry.at("B#c").docstring).to eq "Docstring"
-    expect(Registry.at("B#d").docstring).to eq "Docstring"
-  end
-
-  it "is able to differentiate between class and instance attributes" do
-    expect(P('B').class_attributes[:z][:read].scope).to eq :class
-    expect(P('B').instance_attributes[:z][:read].scope).to eq :instance
-  end
-
-  it "responds true in method's #is_attribute?" do
-    expect(P('B#a').is_attribute?).to be true
-    expect(P('B#a=').is_attribute?).to be true
-  end
-
-  it "does not return true for #is_explicit? in created methods" do
-    Registry.at(:B).meths.each do |meth|
-      expect(meth.is_explicit?).to be false
-    end
-  end
-
-  it "handles attr call with no arguments" do
-    expect { StubbedSourceParser.parse_string "attr" }.not_to raise_error
-  end
-
-  it "adds existing reader method as part of attr_writer combo" do
-    expect(Registry.at('C#foo=').attr_info[:read]).to eq Registry.at('C#foo')
-  end
-
-  it "adds existing writer method as part of attr_reader combo" do
-    expect(Registry.at('C#foo').attr_info[:write]).to eq Registry.at('C#foo=')
-  end
-
-  it "maintains visibility for attr_reader" do
-    expect(Registry.at('D#parser').visibility).to eq :protected
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+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 = 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
+      expect(Registry.at(rname)).to eq nil
+    end
+
+    if write
+      expect(Registry.at(wname)).to be_kind_of(CodeObjects::MethodObject)
+    else
+      expect(Registry.at(wname)).to eq nil
+    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)
+  end
+
+  it "parses attributes inside modules too" do
+    expect(Registry.at("A#x=")).not_to eq nil
+  end
+
+  it "parses 'attr'" do
+    read_write(:B, :a, true, true)
+    read_write(:B, :a2, true, false)
+    read_write(:B, "a3", true, false)
+  end
+
+  it "parses 'attr_reader'" do
+    read_write(:B, :b, true, false)
+  end
+
+  it "parses 'attr_writer'" do
+    read_write(:B, :e, false, true)
+  end
+
+  it "parses 'attr_accessor'" do
+    read_write(:B, :f, true, true)
+  end
+
+  it "parses a list of attributes" do
+    read_write(:B, :b, true, false)
+    read_write(:B, :c, true, false)
+    read_write(:B, :d, true, false)
+  end
+
+  it "has a default docstring if one is not supplied" do
+    expect(Registry.at("B#f=").docstring).not_to be_empty
+  end
+
+  it "sets the correct docstring if one is supplied" do
+    expect(Registry.at("B#b").docstring).to eq "Docstring"
+    expect(Registry.at("B#c").docstring).to eq "Docstring"
+    expect(Registry.at("B#d").docstring).to eq "Docstring"
+  end
+
+  it "is able to differentiate between class and instance attributes" do
+    expect(P('B').class_attributes[:z][:read].scope).to eq :class
+    expect(P('B').instance_attributes[:z][:read].scope).to eq :instance
+  end
+
+  it "responds true in method's #is_attribute?" do
+    expect(P('B#a').is_attribute?).to be true
+    expect(P('B#a=').is_attribute?).to be true
+  end
+
+  it "does not return true for #is_explicit? in created methods" do
+    Registry.at(:B).meths.each do |meth|
+      expect(meth.is_explicit?).to be false
+    end
+  end
+
+  it "handles attr call with no arguments" do
+    expect { StubbedSourceParser.parse_string "attr" }.not_to raise_error
+  end
+
+  it "adds existing reader method as part of attr_writer combo" do
+    expect(Registry.at('C#foo=').attr_info[:read]).to eq Registry.at('C#foo')
+  end
+
+  it "adds existing writer method as part of attr_reader combo" do
+    expect(Registry.at('C#foo').attr_info[:write]).to eq Registry.at('C#foo=')
+  end
+
+  it "maintains visibility for attr_reader" do
+    expect(Registry.at('D#parser').visibility).to eq :protected
+  end
+end

data/spec/handlers/base_spec.rb

@@ -1,216 +1,216 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-require 'ostruct'
-
-include Parser
-
-RSpec.describe YARD::Handlers::Base do
-  describe "#handles and inheritance" do
-    before do
-      allow(Handlers::Base).to receive(:inherited)
-    end
-
-    it "keeps track of subclasses" do
-      expect(Handlers::Base).to receive(:inherited).once
-      class TestHandler < Handlers::Base; end
-    end
-
-    it "raises NotImplementedError if process is called on a class with no #process" do
-      class TestNotImplementedHandler < Handlers::Base
-      end
-
-      expect { TestNotImplementedHandler.new(0, 0).process }.to raise_error(NotImplementedError)
-    end
-
-    it "allows multiple handles arguments" do
-      expect(Handlers::Base).to receive(:inherited).once
-      class TestHandler1 < Handlers::Base
-        handles :a, :b, :c
-      end
-      expect(TestHandler1.handlers).to eq [:a, :b, :c]
-    end
-
-    it "allows multiple handles calls" do
-      expect(Handlers::Base).to receive(:inherited).once
-      class TestHandler2 < Handlers::Base
-        handles :a
-        handles :b
-        handles :c
-      end
-      expect(TestHandler2.handlers).to eq [:a, :b, :c]
-    end
-  end
-
-  describe "#abort! (and HandlerAborted)" do
-    it "allows HandlerAborted to be raised" do
-      class AbortHandler1 < Handlers::Ruby::Base
-        process { abort! }
-      end
-      expect { AbortHandler1.new(nil, nil).process }.to raise_error(HandlerAborted)
-    end
-  end
-
-  describe "transitive tags" do
-    it "adds transitive tags to children" do
-      Registry.clear
-      YARD.parse_string <<-eof
-        # @since 1.0
-        # @author Foo
-        class A
-          def foo; end
-          # @since 1.1
-          def bar; end
-        end
-      eof
-      expect(Registry.at('A').tag(:since).text).to eq "1.0"
-      expect(Registry.at('A#foo').tag(:since).text).to eq "1.0"
-      expect(Registry.at('A#bar').tag(:since).text).to eq "1.1"
-      expect(Registry.at('A#bar').tag(:author)).to be nil
-    end
-  end
-
-  describe "sharing global state" do
-    it "allows globals to share global state among handlers" do
-      class GlobalStateHandler1 < Handlers::Ruby::Base
-        class << self; attr_accessor :state end
-        handles :class
-        process { self.class.state = globals.foo; globals.foo = :bar }
-      end
-
-      class GlobalStateHandler2 < Handlers::Ruby::Base
-        class << self; attr_accessor :state end
-        handles :def
-        process { self.class.state = globals.foo }
-      end
-
-      2.times do
-        YARD.parse_string 'class Foo; end; def foo; end'
-        expect(GlobalStateHandler1.state).to eq nil
-        expect(GlobalStateHandler2.state).to eq :bar
-      end
-    end
-  end if HAVE_RIPPER
-
-  describe "#push_state" do
-    def process(klass)
-      state = OpenStruct.new(:namespace => "ROOT", :scope => :instance, :owner => "ROOT")
-      klass.new(state, nil).process
-    end
-
-    it "pushes and return all old state info after block" do
-      class PushStateHandler1 < Handlers::Base
-        include RSpec::Matchers
-        RSpec::Expectations::Syntax.enable_expect(self)
-
-        def process
-          push_state(:namespace => "FOO", :scope => :class, :owner => "BAR") do
-            expect(namespace).to eq "FOO"
-            expect(scope).to eq :class
-            expect(owner).to eq "BAR"
-          end
-          expect(namespace).to eq "ROOT"
-          expect(owner).to eq "ROOT"
-          expect(scope).to eq :instance
-        end
-      end
-      process PushStateHandler1
-    end
-
-    it "allows owner to be pushed individually" do
-      class PushStateHandler2 < Handlers::Base
-        include RSpec::Matchers
-        RSpec::Expectations::Syntax.enable_expect(self)
-
-        def process
-          push_state(:owner => "BAR") do
-            expect(namespace).to eq "ROOT"
-            expect(scope).to eq :instance
-            expect(owner).to eq "BAR"
-          end
-          expect(owner).to eq "ROOT"
-        end
-      end
-      process PushStateHandler2
-    end
-
-    it "allows scope to be pushed individually" do
-      class PushStateHandler3 < Handlers::Base
-        include RSpec::Matchers
-        RSpec::Expectations::Syntax.enable_expect(self)
-
-        def process
-          push_state(:scope => :foo) do
-            expect(namespace).to eq "ROOT"
-            expect(scope).to eq :foo
-            expect(owner).to eq "ROOT"
-          end
-          expect(scope).to eq :instance
-        end
-      end
-      process PushStateHandler3
-    end
-  end
-
-  describe ".in_file" do
-    def parse(filename, parser_type, src = "class A; end")
-      parser = Parser::SourceParser.new(parser_type)
-      parser.instance_variable_set("@file", filename)
-      parser.parse(StringIO.new(src))
-    end
-
-    def create_handler(stmts, parser_type)
-      $handler_counter ||= 0
-      sklass = parser_type == :ruby ? "Base" : "Legacy::Base"
-      instance_eval(<<-eof, __FILE__, __LINE__ + 1)
-        class ::InFileHandler#{$handler_counter += 1} < Handlers::Ruby::#{sklass}
-          handles(/^class/)
-          #{stmts}
-          def process; MethodObject.new(:root, :FOO) end
-        end
-      eof
-    end
-
-    def test_handler(file, stmts, creates = true, parser_type = :ruby)
-      Registry.clear
-      expect(Registry.at('#FOO')).to be nil
-      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/ }
-    end
-
-    [:ruby, :ruby18].each do |parser_type|
-      next if parser_type == :ruby && LEGACY_PARSER
-      describe "Parser type = #{parser_type.inspect}" do
-        it "allows handler to be specific to a file" do
-          test_handler 'file_a.rb', 'in_file "file_a.rb"', true, parser_type
-        end
-
-        it "ignores handler if filename does not match" do
-          test_handler 'file_b.rb', 'in_file "file_a.rb"', false, parser_type
-        end
-
-        it "only tests filename part when given a String" do
-          test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false, parser_type
-        end
-
-        it "tests exact match for entire String" do
-          test_handler 'file_a.rb', 'in_file "file"', false, parser_type
-        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
-        end
-
-        it "allows multiple in_file declarations" do
-          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
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+require 'ostruct'
+
+include Parser
+
+RSpec.describe YARD::Handlers::Base do
+  describe "#handles and inheritance" do
+    before do
+      allow(Handlers::Base).to receive(:inherited)
+    end
+
+    it "keeps track of subclasses" do
+      expect(Handlers::Base).to receive(:inherited).once
+      class TestHandler < Handlers::Base; end
+    end
+
+    it "raises NotImplementedError if process is called on a class with no #process" do
+      class TestNotImplementedHandler < Handlers::Base
+      end
+
+      expect { TestNotImplementedHandler.new(0, 0).process }.to raise_error(NotImplementedError)
+    end
+
+    it "allows multiple handles arguments" do
+      expect(Handlers::Base).to receive(:inherited).once
+      class TestHandler1 < Handlers::Base
+        handles :a, :b, :c
+      end
+      expect(TestHandler1.handlers).to eq [:a, :b, :c]
+    end
+
+    it "allows multiple handles calls" do
+      expect(Handlers::Base).to receive(:inherited).once
+      class TestHandler2 < Handlers::Base
+        handles :a
+        handles :b
+        handles :c
+      end
+      expect(TestHandler2.handlers).to eq [:a, :b, :c]
+    end
+  end
+
+  describe "#abort! (and HandlerAborted)" do
+    it "allows HandlerAborted to be raised" do
+      class AbortHandler1 < Handlers::Ruby::Base
+        process { abort! }
+      end
+      expect { AbortHandler1.new(nil, nil).process }.to raise_error(HandlerAborted)
+    end
+  end
+
+  describe "transitive tags" do
+    it "adds transitive tags to children" do
+      Registry.clear
+      YARD.parse_string <<-eof
+        # @since 1.0
+        # @author Foo
+        class A
+          def foo; end
+          # @since 1.1
+          def bar; end
+        end
+      eof
+      expect(Registry.at('A').tag(:since).text).to eq "1.0"
+      expect(Registry.at('A#foo').tag(:since).text).to eq "1.0"
+      expect(Registry.at('A#bar').tag(:since).text).to eq "1.1"
+      expect(Registry.at('A#bar').tag(:author)).to be nil
+    end
+  end
+
+  describe "sharing global state" do
+    it "allows globals to share global state among handlers" do
+      class GlobalStateHandler1 < Handlers::Ruby::Base
+        class << self; attr_accessor :state end
+        handles :class
+        process { self.class.state = globals.foo; globals.foo = :bar }
+      end
+
+      class GlobalStateHandler2 < Handlers::Ruby::Base
+        class << self; attr_accessor :state end
+        handles :def
+        process { self.class.state = globals.foo }
+      end
+
+      2.times do
+        YARD.parse_string 'class Foo; end; def foo; end'
+        expect(GlobalStateHandler1.state).to eq nil
+        expect(GlobalStateHandler2.state).to eq :bar
+      end
+    end
+  end if HAVE_RIPPER
+
+  describe "#push_state" do
+    def process(klass)
+      state = OpenStruct.new(:namespace => "ROOT", :scope => :instance, :owner => "ROOT")
+      klass.new(state, nil).process
+    end
+
+    it "pushes and return all old state info after block" do
+      class PushStateHandler1 < Handlers::Base
+        include RSpec::Matchers
+        RSpec::Expectations::Syntax.enable_expect(self)
+
+        def process
+          push_state(:namespace => "FOO", :scope => :class, :owner => "BAR") do
+            expect(namespace).to eq "FOO"
+            expect(scope).to eq :class
+            expect(owner).to eq "BAR"
+          end
+          expect(namespace).to eq "ROOT"
+          expect(owner).to eq "ROOT"
+          expect(scope).to eq :instance
+        end
+      end
+      process PushStateHandler1
+    end
+
+    it "allows owner to be pushed individually" do
+      class PushStateHandler2 < Handlers::Base
+        include RSpec::Matchers
+        RSpec::Expectations::Syntax.enable_expect(self)
+
+        def process
+          push_state(:owner => "BAR") do
+            expect(namespace).to eq "ROOT"
+            expect(scope).to eq :instance
+            expect(owner).to eq "BAR"
+          end
+          expect(owner).to eq "ROOT"
+        end
+      end
+      process PushStateHandler2
+    end
+
+    it "allows scope to be pushed individually" do
+      class PushStateHandler3 < Handlers::Base
+        include RSpec::Matchers
+        RSpec::Expectations::Syntax.enable_expect(self)
+
+        def process
+          push_state(:scope => :foo) do
+            expect(namespace).to eq "ROOT"
+            expect(scope).to eq :foo
+            expect(owner).to eq "ROOT"
+          end
+          expect(scope).to eq :instance
+        end
+      end
+      process PushStateHandler3
+    end
+  end
+
+  describe ".in_file" do
+    def parse(filename, parser_type, src = "class A; end")
+      parser = Parser::SourceParser.new(parser_type)
+      parser.instance_variable_set("@file", filename)
+      parser.parse(StringIO.new(src))
+    end
+
+    def create_handler(stmts, parser_type)
+      $handler_counter ||= 0
+      sklass = parser_type == :ruby ? "Base" : "Legacy::Base"
+      instance_eval(<<-eof, __FILE__, __LINE__ + 1)
+        class ::InFileHandler#{$handler_counter += 1} < Handlers::Ruby::#{sklass}
+          handles(/^class/)
+          #{stmts}
+          def process; MethodObject.new(:root, :FOO) end
+        end
+      eof
+    end
+
+    def test_handler(file, stmts, creates = true, parser_type = :ruby)
+      Registry.clear
+      expect(Registry.at('#FOO')).to be nil
+      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/ }
+    end
+
+    [:ruby, :ruby18].each do |parser_type|
+      next if parser_type == :ruby && LEGACY_PARSER
+      describe "Parser type = #{parser_type.inspect}" do
+        it "allows handler to be specific to a file" do
+          test_handler 'file_a.rb', 'in_file "file_a.rb"', true, parser_type
+        end
+
+        it "ignores handler if filename does not match" do
+          test_handler 'file_b.rb', 'in_file "file_a.rb"', false, parser_type
+        end
+
+        it "only tests filename part when given a String" do
+          test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false, parser_type
+        end
+
+        it "tests exact match for entire String" do
+          test_handler 'file_a.rb', 'in_file "file"', false, parser_type
+        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
+        end
+
+        it "allows multiple in_file declarations" do
+          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
+        end
+      end
+    end
+  end
+end