yard 0.9.18 → 0.9.19

data/spec/handlers/module_function_handler_spec.rb

@@ -1,106 +1,106 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
-  after { Registry.clear }
-
-  def assert_module_function(namespace, name)
-    klass = Registry.at("#{namespace}.#{name}")
-    instance = Registry.at("#{namespace}##{name}")
-    expect(klass).not_to be nil
-    expect(instance).not_to be nil
-    expect(klass).to be_module_function
-    expect(instance).not_to be_module_function
-    expect(klass.visibility).to eq :public
-    expect(instance.visibility).to eq :private
-  end
-
-  it "is able to create a module function with parameters" do
-    YARD.parse_string <<-eof
-      module Foo
-        def bar; end
-        def baz; end
-
-        module_function :bar, :baz
-      end
-    eof
-    assert_module_function('Foo', 'bar')
-    assert_module_function('Foo', 'baz')
-  end
-
-  it "is able to set scope for duration of block without params" do
-    YARD.parse_string <<-eof
-      module Foo
-        def qux; end
-
-        module_function
-
-        def bar; end
-        def baz; end
-      end
-    eof
-    expect(Registry.at('Foo.qux')).to be nil
-    assert_module_function('Foo', 'bar')
-    assert_module_function('Foo', 'baz')
-  end
-
-  # @bug gh-563
-  it "copies tags to module function properly" do
-    YARD.parse_string <<-eof
-      module Foo
-        # @param [String] foo bar
-        # @option foo [String] bar (nil) baz
-        # @return [void]
-        def bar(foo); end
-        module_function :bar
-      end
-    eof
-    assert_module_function('Foo', 'bar')
-    o = Registry.at('Foo.bar')
-    expect(o.tag(:param).types).to eq ['String']
-    expect(o.tag(:param).name).to eq 'foo'
-    expect(o.tag(:param).text).to eq 'bar'
-    expect(o.tag(:option).name).to eq 'foo'
-    expect(o.tag(:option).pair.types).to eq ['String']
-    expect(o.tag(:option).pair.defaults).to eq ['nil']
-    expect(o.tag(:option).pair.text).to eq 'baz'
-    expect(o.tag(:return).types).to eq ['void']
-  end
-
-  it "handles all method names in parameters" do
-    YARD.parse_string <<-eof
-      module Foo
-        def -(t); end
-        def ==(other); end
-        def a?; end
-        module_function :-, '==', :a?
-      end
-    eof
-    assert_module_function('Foo', '-')
-    assert_module_function('Foo', '==')
-    assert_module_function('Foo', 'a?')
-  end
-
-  it "only accepts strings and symbols" do
-    YARD.parse_string <<-eof
-      module Foo
-        module_function name
-        module_function *argument
-        module_function *(method_call)
-      end
-    eof
-    expect(Registry.at('Foo#name')).to be nil
-    expect(Registry.at('Foo#argument')).to be nil
-    expect(Registry.at('Foo#method_call')).to be nil
-  end
-
-  it "handles constants passed in as symbols" do
-    YARD.parse_string <<-eof
-      module Foo
-        def Foo; end
-        module_function :Foo
-      end
-    eof
-    assert_module_function('Foo', 'Foo')
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
+  after { Registry.clear }
+
+  def assert_module_function(namespace, name)
+    klass = Registry.at("#{namespace}.#{name}")
+    instance = Registry.at("#{namespace}##{name}")
+    expect(klass).not_to be nil
+    expect(instance).not_to be nil
+    expect(klass).to be_module_function
+    expect(instance).not_to be_module_function
+    expect(klass.visibility).to eq :public
+    expect(instance.visibility).to eq :private
+  end
+
+  it "is able to create a module function with parameters" do
+    YARD.parse_string <<-eof
+      module Foo
+        def bar; end
+        def baz; end
+
+        module_function :bar, :baz
+      end
+    eof
+    assert_module_function('Foo', 'bar')
+    assert_module_function('Foo', 'baz')
+  end
+
+  it "is able to set scope for duration of block without params" do
+    YARD.parse_string <<-eof
+      module Foo
+        def qux; end
+
+        module_function
+
+        def bar; end
+        def baz; end
+      end
+    eof
+    expect(Registry.at('Foo.qux')).to be nil
+    assert_module_function('Foo', 'bar')
+    assert_module_function('Foo', 'baz')
+  end
+
+  # @bug gh-563
+  it "copies tags to module function properly" do
+    YARD.parse_string <<-eof
+      module Foo
+        # @param [String] foo bar
+        # @option foo [String] bar (nil) baz
+        # @return [void]
+        def bar(foo); end
+        module_function :bar
+      end
+    eof
+    assert_module_function('Foo', 'bar')
+    o = Registry.at('Foo.bar')
+    expect(o.tag(:param).types).to eq ['String']
+    expect(o.tag(:param).name).to eq 'foo'
+    expect(o.tag(:param).text).to eq 'bar'
+    expect(o.tag(:option).name).to eq 'foo'
+    expect(o.tag(:option).pair.types).to eq ['String']
+    expect(o.tag(:option).pair.defaults).to eq ['nil']
+    expect(o.tag(:option).pair.text).to eq 'baz'
+    expect(o.tag(:return).types).to eq ['void']
+  end
+
+  it "handles all method names in parameters" do
+    YARD.parse_string <<-eof
+      module Foo
+        def -(t); end
+        def ==(other); end
+        def a?; end
+        module_function :-, '==', :a?
+      end
+    eof
+    assert_module_function('Foo', '-')
+    assert_module_function('Foo', '==')
+    assert_module_function('Foo', 'a?')
+  end
+
+  it "only accepts strings and symbols" do
+    YARD.parse_string <<-eof
+      module Foo
+        module_function name
+        module_function *argument
+        module_function *(method_call)
+      end
+    eof
+    expect(Registry.at('Foo#name')).to be nil
+    expect(Registry.at('Foo#argument')).to be nil
+    expect(Registry.at('Foo#method_call')).to be nil
+  end
+
+  it "handles constants passed in as symbols" do
+    YARD.parse_string <<-eof
+      module Foo
+        def Foo; end
+        module_function :Foo
+      end
+    eof
+    assert_module_function('Foo', 'Foo')
+  end
+end

data/spec/handlers/module_handler_spec.rb

@@ -1,35 +1,35 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ModuleHandler" do
-  before(:all) { parse_file :module_handler_001, __FILE__ }
-
-  it "parses a module block" do
-    expect(Registry.at(:ModName)).not_to eq nil
-    expect(Registry.at("ModName::OtherModName")).not_to eq nil
-  end
-
-  it "attaches docstring" do
-    expect(Registry.at("ModName::OtherModName").docstring).to eq "Docstring"
-  end
-
-  it "handles any formatting" do
-    expect(Registry.at(:StressTest)).not_to eq nil
-  end
-
-  it "handles complex module names" do
-    expect(Registry.at("A::B")).not_to eq nil
-  end
-
-  it "handles modules in the form ::ModName" do
-    expect(Registry.at("Kernel")).not_to be nil
-  end
-
-  it "lists mixins in proper order" do
-    expect(Registry.at('D').mixins).to eq [P(:C), P(:B), P(:A)]
-  end
-
-  it "creates proper module when constant is in namespace" do
-    expect(Registry.at('Q::FOO::A')).not_to be nil
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ModuleHandler" do
+  before(:all) { parse_file :module_handler_001, __FILE__ }
+
+  it "parses a module block" do
+    expect(Registry.at(:ModName)).not_to eq nil
+    expect(Registry.at("ModName::OtherModName")).not_to eq nil
+  end
+
+  it "attaches docstring" do
+    expect(Registry.at("ModName::OtherModName").docstring).to eq "Docstring"
+  end
+
+  it "handles any formatting" do
+    expect(Registry.at(:StressTest)).not_to eq nil
+  end
+
+  it "handles complex module names" do
+    expect(Registry.at("A::B")).not_to eq nil
+  end
+
+  it "handles modules in the form ::ModName" do
+    expect(Registry.at("Kernel")).not_to be nil
+  end
+
+  it "lists mixins in proper order" do
+    expect(Registry.at('D').mixins).to eq [P(:C), P(:B), P(:A)]
+  end
+
+  it "creates proper module when constant is in namespace" do
+    expect(Registry.at('Q::FOO::A')).not_to be nil
+  end
+end

data/spec/handlers/private_class_method_handler_spec.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateClassMethodHandler" do
-  before { Registry.clear }
-
-  let(:visibility) { :private }
-
-  include_examples "class method visibility decorator"
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateClassMethodHandler" do
+  before { Registry.clear }
+
+  let(:visibility) { :private }
+
+  include_examples "class method visibility decorator"
+end

data/spec/handlers/private_constant_handler_spec.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateConstantHandler" do
-  before(:all) { parse_file :private_constant_handler_001, __FILE__ }
-
-  it "handles private_constant statement" do
-    expect(Registry.at('A::Foo').visibility).to eq :private
-    expect(Registry.at('A::B').visibility).to eq :private
-    expect(Registry.at('A::C').visibility).to eq :private
-  end
-
-  it "makes all other constants public" do
-    expect(Registry.at('A::D').visibility).to eq :public
-  end
-
-  it "fails if parameter is not String, Symbol or Constant" do
-    undoc_error 'class Foo; private_constant x; end'
-    undoc_error 'class Foo; X = 1; private_constant X.new("hi"); end'
-  end unless LEGACY_PARSER
-
-  it "fails if constant can't be recognized" do
-    undoc_error 'class Foo2; private_constant :X end'
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateConstantHandler" do
+  before(:all) { parse_file :private_constant_handler_001, __FILE__ }
+
+  it "handles private_constant statement" do
+    expect(Registry.at('A::Foo').visibility).to eq :private
+    expect(Registry.at('A::B').visibility).to eq :private
+    expect(Registry.at('A::C').visibility).to eq :private
+  end
+
+  it "makes all other constants public" do
+    expect(Registry.at('A::D').visibility).to eq :public
+  end
+
+  it "fails if parameter is not String, Symbol or Constant" do
+    undoc_error 'class Foo; private_constant x; end'
+    undoc_error 'class Foo; X = 1; private_constant X.new("hi"); end'
+  end unless LEGACY_PARSER
+
+  it "fails if constant can't be recognized" do
+    undoc_error 'class Foo2; private_constant :X end'
+  end
+end

data/spec/handlers/processor_spec.rb

@@ -1,35 +1,35 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Handlers::Processor do
-  before do
-    @proc = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
-  end
-
-  it "starts with public visibility" do
-    expect(@proc.visibility).to eq :public
-  end
-
-  it "starts in instance scope" do
-    expect(@proc.scope).to eq :instance
-  end
-
-  it "starts in root namespace" do
-    expect(@proc.namespace).to eq Registry.root
-  end
-
-  it "has a globals structure" do
-    expect(@proc.globals).to be_a(OpenStruct)
-  end
-
-  it "ignores HandlerAborted exceptions (but print debug info)" do
-    class AbortHandlerProcessor < YARD::Handlers::Ruby::Base
-      process { abort! }
-    end
-    stmt = OpenStruct.new(:line => 1, :show => 'SOURCE')
-    allow(@proc).to receive(:find_handlers).and_return([AbortHandlerProcessor])
-    expect(log).to receive(:debug).with(/AbortHandlerProcessor cancelled from/)
-    expect(log).to receive(:debug).with("\tin file '(stdin)':1:\n\nSOURCE\n")
-    @proc.process([stmt])
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe YARD::Handlers::Processor do
+  before do
+    @proc = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
+  end
+
+  it "starts with public visibility" do
+    expect(@proc.visibility).to eq :public
+  end
+
+  it "starts in instance scope" do
+    expect(@proc.scope).to eq :instance
+  end
+
+  it "starts in root namespace" do
+    expect(@proc.namespace).to eq Registry.root
+  end
+
+  it "has a globals structure" do
+    expect(@proc.globals).to be_a(OpenStruct)
+  end
+
+  it "ignores HandlerAborted exceptions (but print debug info)" do
+    class AbortHandlerProcessor < YARD::Handlers::Ruby::Base
+      process { abort! }
+    end
+    stmt = OpenStruct.new(:line => 1, :show => 'SOURCE')
+    allow(@proc).to receive(:find_handlers).and_return([AbortHandlerProcessor])
+    expect(log).to receive(:debug).with(/AbortHandlerProcessor cancelled from/)
+    expect(log).to receive(:debug).with("\tin file '(stdin)':1:\n\nSOURCE\n")
+    @proc.process([stmt])
+  end
+end

data/spec/handlers/public_class_method_handler_spec.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PublicClassMethodHandler" do
-  before { Registry.clear }
-
-  let(:visibility) { :public }
-
-  include_examples "class method visibility decorator"
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PublicClassMethodHandler" do
+  before { Registry.clear }
+
+  let(:visibility) { :public }
+
+  include_examples "class method visibility decorator"
+end