yard 0.9.17 → 0.9.22

data/spec/templates/helpers/method_helper_spec.rb

@@ -1,107 +1,107 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Templates::Helpers::MethodHelper do
-  include YARD::Templates::Helpers::BaseHelper
-  include YARD::Templates::Helpers::MethodHelper
-
-  describe "#format_args" do
-    it "displays keyword arguments" do
-      params = [['a:', '1'], ['b:', '2'], ['**kwargs', nil]]
-      YARD.parse_string 'def foo; end'
-      allow(Registry.at('#foo')).to receive(:parameters) { params }
-      expect(format_args(Registry.at('#foo'))).to eq '(a: 1, b: 2, **kwargs)'
-    end
-
-    it "does not show &blockarg if no @param tag and has @yield" do
-      YARD.parse_string <<-'eof'
-        # @yield blah
-        def foo(&block); end
-      eof
-      expect(format_args(Registry.at('#foo'))).to eq ''
-    end
-
-    it "does not show &blockarg if no @param tag and has @yieldparam" do
-      YARD.parse_string <<-'eof'
-        # @yieldparam blah test
-        def foo(&block); end
-      eof
-      expect(format_args(Registry.at('#foo'))).to eq ''
-    end
-
-    it "shows &blockarg if @param block is documented (even with @yield)" do
-      YARD.parse_string <<-'eof'
-        # @yield [a,b]
-        # @yieldparam a test
-        # @param block test
-        def foo(&block) end
-      eof
-      expect(format_args(Registry.at('#foo'))).to eq '(&block)'
-    end
-  end
-
-  describe "#format_block" do
-    before { YARD::Registry.clear }
-
-    it "shows block for method with yield" do
-      YARD.parse_string <<-'eof'
-        def foo; yield(a, b, c) end
-      eof
-      expect(format_block(Registry.at('#foo'))).to eq "{|a, b, c| ... }"
-    end
-
-    it "shows block for method with @yieldparam tags" do
-      YARD.parse_string <<-'eof'
-        # @yieldparam _self me!
-        def foo; end
-      eof
-      expect(format_block(Registry.at('#foo'))).to eq "{|_self| ... }"
-    end
-
-    it "shows block for method with @yield but no types" do
-      YARD.parse_string <<-'eof'
-        # @yield blah
-        # @yieldparam a
-        def foo; end
-
-        # @yield blah
-        def foo2; end
-      eof
-      expect(format_block(Registry.at('#foo'))).to eq "{|a| ... }"
-      expect(format_block(Registry.at('#foo2'))).to eq "{ ... }"
-    end
-
-    it "shows block for method with @yield and types" do
-      YARD.parse_string <<-'eof'
-        # @yield [a, b, c] blah
-        # @yieldparam a
-        def foo; end
-      eof
-      expect(format_block(Registry.at('#foo'))).to eq "{|a, b, c| ... }"
-    end
-  end
-
-  describe "#format_constant" do
-    include YARD::Templates::Helpers::HtmlHelper
-
-    it "displays correctly constant values which are quoted symbols" do
-      YARD.parse_string %(
-        class TestFmtConst
-          Foo = :''
-          Bar = :BAR
-          Baz = :'B+z'
-        end
-      )
-      # html_syntax_highlight will be called by format_constant for
-      # Foo, Bar and Baz and in turn will enquire for options.highlight
-      expect(self).to receive(:options).exactly(3).times.and_return(
-        Options.new.update(:highlight => false)
-      )
-      foo, bar, baz = %w(Foo Bar Baz).map do |c|
-        Registry.at("TestFmtConst::#{c}").value
-      end
-      expect(format_constant(foo)).to eq ":&quot;&quot;"
-      expect(format_constant(bar)).to eq ':BAR'
-      expect(format_constant(baz)).to eq ":&quot;B+z&quot;"
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Templates::Helpers::MethodHelper do
+  include YARD::Templates::Helpers::BaseHelper
+  include YARD::Templates::Helpers::MethodHelper
+
+  describe "#format_args" do
+    it "displays keyword arguments" do
+      params = [['a:', '1'], ['b:', '2'], ['**kwargs', nil]]
+      YARD.parse_string 'def foo; end'
+      allow(Registry.at('#foo')).to receive(:parameters) { params }
+      expect(format_args(Registry.at('#foo'))).to eq '(a: 1, b: 2, **kwargs)'
+    end
+
+    it "does not show &blockarg if no @param tag and has @yield" do
+      YARD.parse_string <<-'eof'
+        # @yield blah
+        def foo(&block); end
+      eof
+      expect(format_args(Registry.at('#foo'))).to eq ''
+    end
+
+    it "does not show &blockarg if no @param tag and has @yieldparam" do
+      YARD.parse_string <<-'eof'
+        # @yieldparam blah test
+        def foo(&block); end
+      eof
+      expect(format_args(Registry.at('#foo'))).to eq ''
+    end
+
+    it "shows &blockarg if @param block is documented (even with @yield)" do
+      YARD.parse_string <<-'eof'
+        # @yield [a,b]
+        # @yieldparam a test
+        # @param block test
+        def foo(&block) end
+      eof
+      expect(format_args(Registry.at('#foo'))).to eq '(&block)'
+    end
+  end
+
+  describe "#format_block" do
+    before { YARD::Registry.clear }
+
+    it "shows block for method with yield" do
+      YARD.parse_string <<-'eof'
+        def foo; yield(a, b, c) end
+      eof
+      expect(format_block(Registry.at('#foo'))).to eq "{|a, b, c| ... }"
+    end
+
+    it "shows block for method with @yieldparam tags" do
+      YARD.parse_string <<-'eof'
+        # @yieldparam _self me!
+        def foo; end
+      eof
+      expect(format_block(Registry.at('#foo'))).to eq "{|_self| ... }"
+    end
+
+    it "shows block for method with @yield but no types" do
+      YARD.parse_string <<-'eof'
+        # @yield blah
+        # @yieldparam a
+        def foo; end
+
+        # @yield blah
+        def foo2; end
+      eof
+      expect(format_block(Registry.at('#foo'))).to eq "{|a| ... }"
+      expect(format_block(Registry.at('#foo2'))).to eq "{ ... }"
+    end
+
+    it "shows block for method with @yield and types" do
+      YARD.parse_string <<-'eof'
+        # @yield [a, b, c] blah
+        # @yieldparam a
+        def foo; end
+      eof
+      expect(format_block(Registry.at('#foo'))).to eq "{|a, b, c| ... }"
+    end
+  end
+
+  describe "#format_constant" do
+    include YARD::Templates::Helpers::HtmlHelper
+
+    it "displays correctly constant values which are quoted symbols" do
+      YARD.parse_string %(
+        class TestFmtConst
+          Foo = :''
+          Bar = :BAR
+          Baz = :'B+z'
+        end
+      )
+      # html_syntax_highlight will be called by format_constant for
+      # Foo, Bar and Baz and in turn will enquire for options.highlight
+      expect(self).to receive(:options).exactly(3).times.and_return(
+        Options.new.update(:highlight => false)
+      )
+      foo, bar, baz = %w(Foo Bar Baz).map do |c|
+        Registry.at("TestFmtConst::#{c}").value
+      end
+      expect(format_constant(foo)).to eq ":&#39;&#39;"
+      expect(format_constant(bar)).to eq ':BAR'
+      expect(format_constant(baz)).to eq ":&#39;B+z&#39;"
+    end
+  end
+end

data/spec/templates/helpers/module_helper_spec.rb

@@ -1,35 +1,35 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Templates::Helpers::ModuleHelper do
-  include YARD::Templates::Helpers::BaseHelper
-  include YARD::Templates::Helpers::ModuleHelper
-
-  describe "#prune_method_listing" do
-    before { YARD::Registry.clear }
-    let(:options) { OpenStruct.new }
-    let(:object) { YARD::Registry.at("Foo#bar") }
-    let(:objects) { [object] }
-
-    it "filters aliases" do
-      YARD.parse_string "class Foo; def orig; end; alias bar orig end"
-      expect(prune_method_listing(objects)).to eq []
-    end
-
-    it "filters attributes" do
-      YARD.parse_string "class Foo; attr_accessor :bar end"
-      expect(prune_method_listing(objects)).to eq []
-    end
-
-    it "ignores methods if namespace object is filtered" do
-      YARD.parse_string <<-eof
-        # @author test
-        class Foo
-          def bar; end
-        end
-      eof
-
-      options.verifier = YARD::Verifier.new('@author.text != "test"')
-      expect(prune_method_listing(objects)).to eq []
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Templates::Helpers::ModuleHelper do
+  include YARD::Templates::Helpers::BaseHelper
+  include YARD::Templates::Helpers::ModuleHelper
+
+  describe "#prune_method_listing" do
+    before { YARD::Registry.clear }
+    let(:options) { OpenStruct.new }
+    let(:object) { YARD::Registry.at("Foo#bar") }
+    let(:objects) { [object] }
+
+    it "filters aliases" do
+      YARD.parse_string "class Foo; def orig; end; alias bar orig end"
+      expect(prune_method_listing(objects)).to eq []
+    end
+
+    it "filters attributes" do
+      YARD.parse_string "class Foo; attr_accessor :bar end"
+      expect(prune_method_listing(objects)).to eq []
+    end
+
+    it "ignores methods if namespace object is filtered" do
+      YARD.parse_string <<-eof
+        # @author test
+        class Foo
+          def bar; end
+        end
+      eof
+
+      options.verifier = YARD::Verifier.new('@author.text != "test"')
+      expect(prune_method_listing(objects)).to eq []
+    end
+  end
+end

data/spec/templates/helpers/shared_signature_examples.rb

@@ -1,126 +1,126 @@
-# frozen_string_literal: true
-RSpec.shared_examples_for "signature" do
-  before do
-    YARD::Registry.clear
-    @options = Templates::TemplateOptions.new
-    @options.reset_defaults
-    allow(self).to receive(:options).and_return(@options)
-  end
-
-  def trim(sig) sig.gsub(/\s+/, ' ') end
-
-  it "shows signature for regular instance method" do
-    YARD.parse_string "def foo; end"
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:regular]
-  end
-
-  it "allows default return type to be changed" do
-    @options.default_return = "Hello"
-    YARD.parse_string "def foo; end"
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:default_return]
-  end
-
-  it "allows default return type to be omitted" do
-    @options.default_return = ""
-    YARD.parse_string "def foo; end"
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:no_default_return]
-  end
-
-  it "shows signature for private class method" do
-    YARD.parse_string "class A; private; def self.foo; end end"
-    expect(trim(signature(Registry.at('A.foo')))).to eq @results[:private_class]
-  end
-
-  it "shows return type for single type" do
-    YARD.parse_string <<-'eof'
-      # @return [String]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:single]
-  end
-
-  it "shows return type for 2 types" do
-    YARD.parse_string <<-'eof'
-      # @return [String, Symbol]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:two_types]
-  end
-
-  it "shows return type for 2 types over multiple tags" do
-    YARD.parse_string <<-'eof'
-      # @return [String]
-      # @return [Symbol]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:two_types_multitag]
-  end
-
-  it "shows 'Type?' if return types are [Type, nil]" do
-    YARD.parse_string <<-'eof'
-      # @return [Type, nil]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_nil]
-  end
-
-  it "shows 'Type?' if return types are [Type, nil, nil] (extra nil)" do
-    YARD.parse_string <<-'eof'
-      # @return [Type, nil]
-      # @return [nil]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_nil]
-  end
-
-  it "shows 'Type+' if return types are [Type, Array<Type>]" do
-    YARD.parse_string <<-'eof'
-      # @return [Type, <Type>]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_array]
-  end
-
-  it "shows (Type, ...) for more than 2 return types" do
-    YARD.parse_string <<-'eof'
-      # @return [Type, <Type>]
-      # @return [AnotherType]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:multitype]
-  end
-
-  it "shows (void) for @return [void] by default" do
-    YARD.parse_string <<-'eof'
-      # @return [void]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:void]
-  end
-
-  it "does not show return for @return [void] if :hide_void_return is true" do
-    @options.hide_void_return = true
-    YARD.parse_string <<-'eof'
-      # @return [void]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:hide_void]
-  end
-
-  it "shows block for method with yield" do
-    YARD.parse_string <<-'eof'
-      def foo; yield(a, b, c) end
-    eof
-    expect(trim(signature(Registry.at('#foo')))).to eq @results[:block]
-  end
-
-  it "uses regular return tag if the @overload is empty" do
-    YARD.parse_string <<-'eof'
-      # @overload foobar
-      #   Hello world
-      # @return [String]
-      def foo; end
-    eof
-    expect(trim(signature(Registry.at('#foo').tag(:overload)))).to eq @results[:empty_overload]
-  end
-end
+# frozen_string_literal: true
+RSpec.shared_examples_for "signature" do
+  before do
+    YARD::Registry.clear
+    @options = Templates::TemplateOptions.new
+    @options.reset_defaults
+    allow(self).to receive(:options).and_return(@options)
+  end
+
+  def trim(sig) sig.gsub(/\s+/, ' ') end
+
+  it "shows signature for regular instance method" do
+    YARD.parse_string "def foo; end"
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:regular]
+  end
+
+  it "allows default return type to be changed" do
+    @options.default_return = "Hello"
+    YARD.parse_string "def foo; end"
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:default_return]
+  end
+
+  it "allows default return type to be omitted" do
+    @options.default_return = ""
+    YARD.parse_string "def foo; end"
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:no_default_return]
+  end
+
+  it "shows signature for private class method" do
+    YARD.parse_string "class A; private; def self.foo; end end"
+    expect(trim(signature(Registry.at('A.foo')))).to eq @results[:private_class]
+  end
+
+  it "shows return type for single type" do
+    YARD.parse_string <<-'eof'
+      # @return [String]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:single]
+  end
+
+  it "shows return type for 2 types" do
+    YARD.parse_string <<-'eof'
+      # @return [String, Symbol]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:two_types]
+  end
+
+  it "shows return type for 2 types over multiple tags" do
+    YARD.parse_string <<-'eof'
+      # @return [String]
+      # @return [Symbol]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:two_types_multitag]
+  end
+
+  it "shows 'Type?' if return types are [Type, nil]" do
+    YARD.parse_string <<-'eof'
+      # @return [Type, nil]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_nil]
+  end
+
+  it "shows 'Type?' if return types are [Type, nil, nil] (extra nil)" do
+    YARD.parse_string <<-'eof'
+      # @return [Type, nil]
+      # @return [nil]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_nil]
+  end
+
+  it "shows 'Type+' if return types are [Type, Array<Type>]" do
+    YARD.parse_string <<-'eof'
+      # @return [Type, <Type>]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_array]
+  end
+
+  it "shows (Type, ...) for more than 2 return types" do
+    YARD.parse_string <<-'eof'
+      # @return [Type, <Type>]
+      # @return [AnotherType]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:multitype]
+  end
+
+  it "shows (void) for @return [void] by default" do
+    YARD.parse_string <<-'eof'
+      # @return [void]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:void]
+  end
+
+  it "does not show return for @return [void] if :hide_void_return is true" do
+    @options.hide_void_return = true
+    YARD.parse_string <<-'eof'
+      # @return [void]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:hide_void]
+  end
+
+  it "shows block for method with yield" do
+    YARD.parse_string <<-'eof'
+      def foo; yield(a, b, c) end
+    eof
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:block]
+  end
+
+  it "uses regular return tag if the @overload is empty" do
+    YARD.parse_string <<-'eof'
+      # @overload foobar
+      #   Hello world
+      # @return [String]
+      def foo; end
+    eof
+    expect(trim(signature(Registry.at('#foo').tag(:overload)))).to eq @results[:empty_overload]
+  end
+end