yard 0.9.16 → 0.9.17

data/spec/templates/helpers/text_helper_spec.rb

@@ -1,65 +1,65 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/shared_signature_examples"
-
-RSpec.describe YARD::Templates::Helpers::TextHelper do
-  include YARD::Templates::Helpers::BaseHelper
-  include YARD::Templates::Helpers::TextHelper
-  include YARD::Templates::Helpers::MethodHelper
-
-  describe "#signature" do
-    before do
-      @results = {
-        :regular => "root.foo -> Object",
-        :default_return => "root.foo -> Hello",
-        :no_default_return => "root.foo",
-        :private_class => "A.foo -> Object (private)",
-        :single => "root.foo -> String",
-        :two_types => "root.foo -> (String, Symbol)",
-        :two_types_multitag => "root.foo -> (String, Symbol)",
-        :type_nil => "root.foo -> Type?",
-        :type_array => "root.foo -> Type+",
-        :multitype => "root.foo -> (Type, ...)",
-        :void => "root.foo -> void",
-        :hide_void => "root.foo",
-        :block => "root.foo {|a, b, c| ... } -> Object",
-        :empty_overload => 'root.foobar -> String'
-      }
-    end
-
-    def signature(obj) super(obj).strip end
-
-    it_should_behave_like "signature"
-  end
-
-  describe "#align_right" do
-    it "aligns text right" do
-      text = "Method: #some_method (SomeClass)"
-      expect(align_right(text)).to eq ' ' * 40 + text
-    end
-
-    it "truncates text that is longer than allowed width" do
-      text = "(Defined in: /home/user/.rip/.packages/some_gem-2460672e333ac07b9190ade88ec9a91c/long/path.rb)"
-      expect(align_right(text)).to eq ' ' + text[0, 68] + '...'
-    end
-  end
-
-  describe "#h" do
-    let(:object) do
-      YARD::CodeObjects::MethodObject.new(:root, :foo, :instance).tap do |o|
-        o.docstring = "test"
-      end
-    end
-
-    it "resolves links" do
-      expect(h("{include:#foo} 1 2 3").strip).to eq "test 1 2 3"
-    end
-
-    it "uses title when present" do
-      expect(h("{A b}").strip).to eq "b"
-    end
-
-    it "uses object name when no title is present" do
-      expect(h("{A}").strip).to eq "A"
-    end
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + "/shared_signature_examples"
+
+RSpec.describe YARD::Templates::Helpers::TextHelper do
+  include YARD::Templates::Helpers::BaseHelper
+  include YARD::Templates::Helpers::TextHelper
+  include YARD::Templates::Helpers::MethodHelper
+
+  describe "#signature" do
+    before do
+      @results = {
+        :regular => "root.foo -> Object",
+        :default_return => "root.foo -> Hello",
+        :no_default_return => "root.foo",
+        :private_class => "A.foo -> Object (private)",
+        :single => "root.foo -> String",
+        :two_types => "root.foo -> (String, Symbol)",
+        :two_types_multitag => "root.foo -> (String, Symbol)",
+        :type_nil => "root.foo -> Type?",
+        :type_array => "root.foo -> Type+",
+        :multitype => "root.foo -> (Type, ...)",
+        :void => "root.foo -> void",
+        :hide_void => "root.foo",
+        :block => "root.foo {|a, b, c| ... } -> Object",
+        :empty_overload => 'root.foobar -> String'
+      }
+    end
+
+    def signature(obj) super(obj).strip end
+
+    it_should_behave_like "signature"
+  end
+
+  describe "#align_right" do
+    it "aligns text right" do
+      text = "Method: #some_method (SomeClass)"
+      expect(align_right(text)).to eq ' ' * 40 + text
+    end
+
+    it "truncates text that is longer than allowed width" do
+      text = "(Defined in: /home/user/.rip/.packages/some_gem-2460672e333ac07b9190ade88ec9a91c/long/path.rb)"
+      expect(align_right(text)).to eq ' ' + text[0, 68] + '...'
+    end
+  end
+
+  describe "#h" do
+    let(:object) do
+      YARD::CodeObjects::MethodObject.new(:root, :foo, :instance).tap do |o|
+        o.docstring = "test"
+      end
+    end
+
+    it "resolves links" do
+      expect(h("{include:#foo} 1 2 3").strip).to eq "test 1 2 3"
+    end
+
+    it "uses title when present" do
+      expect(h("{A b}").strip).to eq "b"
+    end
+
+    it "uses object name when no title is present" do
+      expect(h("{A}").strip).to eq "A"
+    end
+  end
+end

data/spec/templates/method_spec.rb

@@ -1,118 +1,118 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-# $COPY = :method001
-# $COPYT = :html
-
-RSpec.describe YARD::Templates::Engine.template(:default, :method) do
-  before { Registry.clear }
-
-  shared_examples_for "all formats" do
-    it "renders html format correctly" do
-      html_equals(Registry.at('#m').format(html_options), @template)
-    end
-
-    it "renders text format correctly" do
-      text_equals(Registry.at('#m').format(text_options), @template)
-    end
-  end
-
-  describe "regular (deprecated) method" do
-    before do
-      @template = :method001
-      YARD.parse_string <<-'eof'
-        private
-        # Comments
-        # @param [Hash] x the x argument
-        # @option x [String] :key1 (default) first key
-        # @option x [Symbol] :key2 second key
-        # @return [String] the result
-        # @raise [Exception] hi!
-        # @deprecated for great justice
-        def m(x) end
-        alias x m
-      eof
-    end
-
-    it_should_behave_like "all formats"
-  end
-
-  describe "method with 1 overload" do
-    before do
-      @template = :method002
-      YARD.parse_string <<-'eof'
-        private
-        # Comments
-        # @overload m(x, y)
-        #   @param [String] x parameter x
-        #   @param [Boolean] y parameter y
-        def m(x) end
-      eof
-    end
-
-    it_should_behave_like "all formats"
-  end
-
-  describe "method with 2 overloads" do
-    before do
-      @template = :method003
-      YARD.parse_string <<-'eof'
-        private
-        # Method comments
-        # @overload m(x, y)
-        #   Overload docstring
-        #   @param [String] x parameter x
-        #   @param [Boolean] y parameter y
-        # @overload m(x, y, z)
-        #   @param [String] x parameter x
-        #   @param [Boolean] y parameter y
-        #   @param [Boolean] z parameter z
-        def m(*args) end
-      eof
-    end
-
-    it_should_behave_like "all formats"
-  end
-
-  describe "method void return" do
-    before do
-      @template = :method004
-      YARD.parse_string <<-'eof'
-        # @return [void]
-        def m(*args) end
-      eof
-    end
-
-    it_should_behave_like "all formats"
-  end
-
-  describe "method void return in an overload" do
-    before do
-      @template = :method005
-      YARD.parse_string <<-'eof'
-        # @overload m(a)
-        #   @return [void]
-        # @overload m(b)
-        #   @param [String] b hi
-        def m(*args) end
-      eof
-    end
-
-    it_should_behave_like "all formats"
-  end
-
-  describe "method with keyword arguments spalt" do
-    before do
-      @template = :method006
-      YARD.parse_string <<-'eof'
-        # @param [String] x the x argument
-        # @param [Boolean] y the y argument
-        # @param [kword1] keyword 1
-        # @param [kword2] keyword 2
-        def m(x, y, *args, kword1: 123, kword2:, **) end
-      eof
-    end
-
-    it_should_behave_like "all formats"
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+# $COPY = :method001
+# $COPYT = :html
+
+RSpec.describe YARD::Templates::Engine.template(:default, :method) do
+  before { Registry.clear }
+
+  shared_examples_for "all formats" do
+    it "renders html format correctly" do
+      html_equals(Registry.at('#m').format(html_options), @template)
+    end
+
+    it "renders text format correctly" do
+      text_equals(Registry.at('#m').format(text_options), @template)
+    end
+  end
+
+  describe "regular (deprecated) method" do
+    before do
+      @template = :method001
+      YARD.parse_string <<-'eof'
+        private
+        # Comments
+        # @param [Hash] x the x argument
+        # @option x [String] :key1 (default) first key
+        # @option x [Symbol] :key2 second key
+        # @return [String] the result
+        # @raise [Exception] hi!
+        # @deprecated for great justice
+        def m(x) end
+        alias x m
+      eof
+    end
+
+    it_should_behave_like "all formats"
+  end
+
+  describe "method with 1 overload" do
+    before do
+      @template = :method002
+      YARD.parse_string <<-'eof'
+        private
+        # Comments
+        # @overload m(x, y)
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        def m(x) end
+      eof
+    end
+
+    it_should_behave_like "all formats"
+  end
+
+  describe "method with 2 overloads" do
+    before do
+      @template = :method003
+      YARD.parse_string <<-'eof'
+        private
+        # Method comments
+        # @overload m(x, y)
+        #   Overload docstring
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        # @overload m(x, y, z)
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        #   @param [Boolean] z parameter z
+        def m(*args) end
+      eof
+    end
+
+    it_should_behave_like "all formats"
+  end
+
+  describe "method void return" do
+    before do
+      @template = :method004
+      YARD.parse_string <<-'eof'
+        # @return [void]
+        def m(*args) end
+      eof
+    end
+
+    it_should_behave_like "all formats"
+  end
+
+  describe "method void return in an overload" do
+    before do
+      @template = :method005
+      YARD.parse_string <<-'eof'
+        # @overload m(a)
+        #   @return [void]
+        # @overload m(b)
+        #   @param [String] b hi
+        def m(*args) end
+      eof
+    end
+
+    it_should_behave_like "all formats"
+  end
+
+  describe "method with keyword arguments" do
+    before do
+      @template = :method006
+      YARD.parse_string <<-'eof'
+        # @param [String] x the x argument
+        # @param [Boolean] y the y argument
+        # @param [kword1] keyword 1
+        # @param [kword2] keyword 2
+        def m(x, y, *args, kword1: 123, kword2:, **) end
+      eof
+    end
+
+    it_should_behave_like "all formats"
+  end if RUBY_VERSION >= "2.1"
+end

data/spec/templates/module_spec.rb

@@ -1,203 +1,203 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Templates::Engine.template(:default, :module) do
-  before do
-    Registry.clear
-    YARD.parse_string <<-'eof'
-      module B
-        def c; end
-        def d; end
-        private
-        def e; end
-      end
-
-      module BaseMod
-        attr_reader :base_attr1
-        attr_writer :base_attr2
-        attr_accessor :base_attr3
-      end
-
-      # Comments
-      module A
-        include BaseMod
-        attr_accessor :attr1
-        attr_reader :attr2
-
-        # @overload attr3
-        #   @return [String] a string
-        # @overload attr3=(value)
-        #   @param [String] value sets the string
-        #   @return [void]
-        attr_accessor :attr3
-
-        attr_writer :attr4
-
-        def self.a; end
-        def a; end
-        alias b a
-
-        # @overload test_overload(a)
-        #   hello2
-        #   @param [String] a hi
-        def test_overload(*args) end
-
-        # @overload test_multi_overload(a)
-        # @overload test_multi_overload(a, b)
-        def test_multi_overload(*args) end
-
-        # @return [void]
-        def void_meth; end
-
-        include B
-
-        class Y; end
-        class Q; end
-        class X; end
-        module Z; end
-        # A long docstring for the constant. With extra text
-        # and newlines.
-        CONSTANT = 'value'
-        @@cvar = 'value' # @deprecated
-      end
-
-      module TMP; include A end
-      class TMP2; extend A end
-    eof
-  end
-
-  it "renders html format correctly" do
-    html_equals(Registry.at('A').format(html_options(:hide_void_return => true,
-      :verifier => Verifier.new('object.type != :method || object.visibility == :public'))),
-        :module001)
-  end
-
-  it "renders text format correctly" do
-    YARD.parse_string <<-'eof'
-      module A
-        include D, E, F, A::B::C
-      end
-    eof
-
-    text_equals(Registry.at('A').format(text_options), :module001)
-  end
-
-  it "renders dot format correctly" do
-    expect(Registry.at('A').format(:format => :dot, :dependencies => true, :full => true)).to eq example_contents(:module001, 'dot')
-  end
-
-  it "renders groups correctly in html" do
-    Registry.clear
-    YARD.parse_string <<-'eof'
-      module A
-        # @group Foo
-        attr_accessor :foo_attr
-        def foo; end
-        def self.bar; end
-
-        # @group Bar
-        def baz; end
-
-        # @endgroup
-
-        def self.baz; end
-      end
-    eof
-
-    html_equals(Registry.at('A').format(html_options), :module002)
-  end
-
-  it "ignores overwritten/private attributes/constants from inherited list" do
-    Registry.clear
-    YARD.parse_string <<-'eof'
-      module B
-        attr_reader :foo
-        attr_accessor :bar
-        # @private
-        attr_writer :baz
-        FOO = 1
-      end
-      module A
-        include B
-        def foo; end
-        attr_reader :bar
-        FOO = 2
-      end
-    eof
-
-    html_equals(Registry.at('A').
-      format(html_options(:verifier => Verifier.new('!@private'))), :module003)
-  end
-
-  it "embeds mixins with :embed_mixins = ['Foo', 'Bar', 'Baz::A*']" do
-    Registry.clear
-    YARD.parse_string <<-'eof'
-      class A
-        # This method is in A
-        def foo; end
-
-        include Foo
-        extend Bar
-        include BarFooBar
-        include Baz::XYZ
-        include Baz::ABC
-      end
-
-      module BarFooBar
-        def bar_foo_bar; end
-      end
-
-      module Foo
-        def self.not_included; end
-
-        # Docs for xyz
-        def xyz; end
-        # Docs for bar_attr
-        attr_accessor :bar_attr
-      end
-
-      module Bar
-        def self.not_included; end
-
-        # @group Booya
-
-        # Docs for baz in Booya group
-        def baz; end
-      end
-
-      module Baz
-        module XYZ
-          # listed as inherited
-          def baz_xyz; end
-        end
-
-        module ABC
-          def baz_abc; end
-        end
-      end
-    eof
-
-    html_equals(Registry.at('A').format(html_options(:embed_mixins => ['Foo', 'Bar', 'Baz::A*'])), :module004)
-  end
-
-  it "renders constant groups correctly in html" do
-    Registry.clear
-    YARD.parse_string <<-'eof'
-      module A
-        # @group Foo
-        FOO = 1
-
-        # @deprecated
-        BAR = 2
-
-        # @group Bar
-        BAZ = 3
-
-        # @endgroup
-
-        WORLD = 4
-      end
-    eof
-    html_equals(Registry.at('A').format(html_options), :module005)
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe YARD::Templates::Engine.template(:default, :module) do
+  before do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module B
+        def c; end
+        def d; end
+        private
+        def e; end
+      end
+
+      module BaseMod
+        attr_reader :base_attr1
+        attr_writer :base_attr2
+        attr_accessor :base_attr3
+      end
+
+      # Comments
+      module A
+        include BaseMod
+        attr_accessor :attr1
+        attr_reader :attr2
+
+        # @overload attr3
+        #   @return [String] a string
+        # @overload attr3=(value)
+        #   @param [String] value sets the string
+        #   @return [void]
+        attr_accessor :attr3
+
+        attr_writer :attr4
+
+        def self.a; end
+        def a; end
+        alias b a
+
+        # @overload test_overload(a)
+        #   hello2
+        #   @param [String] a hi
+        def test_overload(*args) end
+
+        # @overload test_multi_overload(a)
+        # @overload test_multi_overload(a, b)
+        def test_multi_overload(*args) end
+
+        # @return [void]
+        def void_meth; end
+
+        include B
+
+        class Y; end
+        class Q; end
+        class X; end
+        module Z; end
+        # A long docstring for the constant. With extra text
+        # and newlines.
+        CONSTANT = 'value'
+        @@cvar = 'value' # @deprecated
+      end
+
+      module TMP; include A end
+      class TMP2; extend A end
+    eof
+  end
+
+  it "renders html format correctly" do
+    html_equals(Registry.at('A').format(html_options(:hide_void_return => true,
+      :verifier => Verifier.new('object.type != :method || object.visibility == :public'))),
+        :module001)
+  end
+
+  it "renders text format correctly" do
+    YARD.parse_string <<-'eof'
+      module A
+        include D, E, F, A::B::C
+      end
+    eof
+
+    text_equals(Registry.at('A').format(text_options), :module001)
+  end
+
+  it "renders dot format correctly" do
+    expect(Registry.at('A').format(:format => :dot, :dependencies => true, :full => true)).to eq example_contents(:module001, 'dot')
+  end
+
+  it "renders groups correctly in html" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module A
+        # @group Foo
+        attr_accessor :foo_attr
+        def foo; end
+        def self.bar; end
+
+        # @group Bar
+        def baz; end
+
+        # @endgroup
+
+        def self.baz; end
+      end
+    eof
+
+    html_equals(Registry.at('A').format(html_options), :module002)
+  end
+
+  it "ignores overwritten/private attributes/constants from inherited list" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module B
+        attr_reader :foo
+        attr_accessor :bar
+        # @private
+        attr_writer :baz
+        FOO = 1
+      end
+      module A
+        include B
+        def foo; end
+        attr_reader :bar
+        FOO = 2
+      end
+    eof
+
+    html_equals(Registry.at('A').
+      format(html_options(:verifier => Verifier.new('!@private'))), :module003)
+  end
+
+  it "embeds mixins with :embed_mixins = ['Foo', 'Bar', 'Baz::A*']" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      class A
+        # This method is in A
+        def foo; end
+
+        include Foo
+        extend Bar
+        include BarFooBar
+        include Baz::XYZ
+        include Baz::ABC
+      end
+
+      module BarFooBar
+        def bar_foo_bar; end
+      end
+
+      module Foo
+        def self.not_included; end
+
+        # Docs for xyz
+        def xyz; end
+        # Docs for bar_attr
+        attr_accessor :bar_attr
+      end
+
+      module Bar
+        def self.not_included; end
+
+        # @group Booya
+
+        # Docs for baz in Booya group
+        def baz; end
+      end
+
+      module Baz
+        module XYZ
+          # listed as inherited
+          def baz_xyz; end
+        end
+
+        module ABC
+          def baz_abc; end
+        end
+      end
+    eof
+
+    html_equals(Registry.at('A').format(html_options(:embed_mixins => ['Foo', 'Bar', 'Baz::A*'])), :module004)
+  end
+
+  it "renders constant groups correctly in html" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module A
+        # @group Foo
+        FOO = 1
+
+        # @deprecated
+        BAR = 2
+
+        # @group Bar
+        BAZ = 3
+
+        # @endgroup
+
+        WORLD = 4
+      end
+    eof
+    html_equals(Registry.at('A').format(html_options), :module005)
+  end
+end