yard 0.9.24 → 0.9.25

data/spec/templates/helpers/html_syntax_highlight_helper_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
-  include YARD::Templates::Helpers::HtmlHelper
-  include YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
-
-  describe "#html_syntax_highlight" do
-    let(:object) { CodeObjects::NamespaceObject.new(:root, :YARD) }
-
-    before do
-      Registry.root.source_type = :ruby
-    end
-
-    it "does not highlight source if options.highlight is false" do
-      expect(self).to receive(:options).and_return(Options.new.update(:highlight => false))
-      expect(html_syntax_highlight("def x\nend")).to eq "def x\nend"
-    end
-
-    it "highlights source (legacy)" do
-      type = Parser::SourceParser.parser_type
-      Parser::SourceParser.parser_type = :ruby18
-      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      expect = "<span class='rubyid_def def kw'>def</span><span class='rubyid_x identifier id'>x</span>
-        <span class='string val'>'x'</span><span class='plus op'>+</span>
-        <span class='regexp val'>/x/i</span><span class='rubyid_end end kw'>end</span>"
-      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
-      html_equals_string(result, expect)
-      Parser::SourceParser.parser_type = type
-    end
-
-    it "highlights source (ripper)" do
-      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      Parser::SourceParser.parser_type = :ruby
-      expect = "<span class='kw'>def</span> <span class='id identifier rubyid_x'>x</span>
-        <span class='tstring'><span class='tstring_beg'>'</span>
-        <span class='tstring_content'>x</span><span class='tstring_end'>'</span>
-        </span> <span class='op'>+</span> <span class='tstring'>
-        <span class='regexp_beg'>/</span><span class='tstring_content'>x</span>
-        <span class='regexp_end'>/i</span></span>\n<span class='kw'>end</span>"
-      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
-      html_equals_string(result, expect)
-    end if HAVE_RIPPER
-
-    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
-      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      expect(html_syntax_highlight("def &x; ... end")).to eq "def &amp;x; ... end"
-    end if HAVE_RIPPER
-
-    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
-      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      expect(html_syntax_highlight("$ git clone http://url")).to eq "$ git clone http://url"
-    end if HAVE_RIPPER
-
-    it "links constants/methods" do
-      other = CodeObjects::NamespaceObject.new(:root, :Other)
-      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      allow(self).to receive(:run_verifier).with([other]).and_return([other])
-      allow(self).to receive(:link_object).with(other, "Other").and_return("LINK!")
-      result = html_syntax_highlight("def x; Other end")
-      html_equals_string(result, "<span class='kw'>def</span>
-        <span class='id identifier rubyid_x'>x</span><span class='semicolon'>;</span>
-        <span class='const'>LINK!</span> <span class='kw'>end</span>")
-    end if HAVE_RIPPER
-  end
-end

data/spec/templates/helpers/markup/rdoc_markup_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Templates::Helpers::Markup::RDocMarkup do
-  describe "loading mechanism" do
-    before { @good_libs = [] }
-
-    def require(lib)
-      return true if @good_libs.include?(lib)
-      raise LoadError
-    end
-
-    def load_markup
-      require 'rdoc/markup'
-      require 'rdoc/markup/to_html'
-      return :RDoc2
-    rescue LoadError
-      begin
-        require 'rdoc/markup/simple_markup'
-        require 'rdoc/markup/simple_markup/to_html'
-        return :RDoc1
-      rescue LoadError
-        raise NameError, "could not load RDocMarkup (rdoc is not installed)"
-      end
-    end
-
-    it "loads RDoc2.x if rdoc/markup is present" do
-      @good_libs += ['rdoc/markup', 'rdoc/markup/to_html']
-      expect(load_markup).to eq :RDoc2
-    end
-
-    it "fails on RDoc2.x if rdoc/markup/to_html is not present" do
-      @good_libs += ['rdoc/markup']
-      expect { load_markup }.to raise_error(NameError)
-    end
-
-    it "loads RDoc1.x if RDoc2 fails and rdoc/markup/simple_markup is present" do
-      @good_libs += ['rdoc/markup/simple_markup', 'rdoc/markup/simple_markup/to_html']
-      expect(load_markup).to eq :RDoc1
-    end
-
-    it "raises an error on loading if neither lib is present" do
-      expect { load_markup }.to raise_error(NameError)
-    end
-  end
-
-  describe "#to_html" do
-    def to_html(text)
-      html = YARD::Templates::Helpers::Markup::RDocMarkup.new(text).to_html
-      html.strip.gsub(/\r?\n/, '')
-    end
-
-    it "handles typewriter text" do
-      expect(to_html('Hello +<code>+')).to eq '<p>Hello <tt>&lt;code&gt;</tt></p>'
-    end
-  end
-
-  describe "#fix_typewriter" do
-    def fix_typewriter(text)
-      YARD::Templates::Helpers::Markup::RDocMarkup.new('').send(:fix_typewriter, text)
-    end
-
-    it "converts +text+ to <tt>text</tt>" do
-      expect(fix_typewriter("Some +typewriter text &lt;+.")).to eq "Some <tt>typewriter text &lt;</tt>."
-      expect(fix_typewriter("Not +typewriter text.")).to eq "Not +typewriter text."
-      expect(fix_typewriter("Alternating +type writer+ text +here+.")).to eq "Alternating <tt>type writer</tt> text <tt>here</tt>."
-      expect(fix_typewriter("No ++problem.")).to eq "No ++problem."
-      expect(fix_typewriter("Math + stuff +is ok+")).to eq "Math + stuff <tt>is ok</tt>"
-      expect(fix_typewriter("Hello +{Foo}+ World")).to eq "Hello <tt>{Foo}</tt> World"
-    end
-
-    it "does not apply to code blocks" do
-      expect(fix_typewriter("<code>Hello +hello+</code>")).to eq "<code>Hello +hello+</code>"
-    end
-
-    it "does not apply to HTML tag attributes" do
-      expect(fix_typewriter("<a href='http://foo.com/A+b+c'>A+b+c</a>")).to eq "<a href='http://foo.com/A+b+c'>A+b+c</a>"
-      expect(fix_typewriter("<foo class='foo+bar+baz'/>")).to eq "<foo class='foo+bar+baz'/>"
-    end
-
-    it "still applies inside of other tags" do
-      expect(fix_typewriter("<p>+foo+</p>")).to eq "<p><tt>foo</tt></p>"
-    end
-  end
-end

data/spec/templates/helpers/markup_helper_spec.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module YARD::Templates::Helpers::MarkupHelper
-  public :load_markup_provider, :markup_class, :markup_provider
-end
-
-class GeneratorMock
-  attr_accessor :options
-  include YARD::Templates::Helpers::MarkupHelper
-  def initialize(options = Templates::TemplateOptions.new)
-    self.options = options
-  end
-end
-
-RSpec.describe YARD::Templates::Helpers::MarkupHelper do
-  before do
-    YARD::Templates::Helpers::MarkupHelper.clear_markup_cache
-  end
-
-  describe "#load_markup_provider" do
-    before do
-      allow(log).to receive(:error)
-      @gen = GeneratorMock.new
-      @gen.options.reset_defaults
-    end
-
-    it "exits on an invalid markup type" do
-      @gen.options.markup = :invalid
-      expect(@gen.load_markup_provider).to be false
-    end
-
-    it "fails when an invalid markup provider is specified" do
-      @gen.options.update(:markup => :markdown, :markup_provider => :invalid)
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_class).to eq nil
-    end
-
-    it "loads RDocMarkup if rdoc is specified and it is installed" do
-      @gen.options.markup = :rdoc
-      expect(@gen.load_markup_provider).to be true
-      expect(@gen.markup_class).to eq YARD::Templates::Helpers::Markup::RDocMarkup
-    end
-
-    it "fails if RDoc cannot be loaded" do
-      @gen.options.markup = :rdoc
-      expect(@gen).to receive(:eval).with('::YARD::Templates::Helpers::Markup::RDocMarkup').and_raise(NameError)
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-
-    it "searches through available markup providers for the markup type if none is set" do
-      expect(@gen).to receive(:eval).with('::RedcarpetCompat').and_return(double(:bluecloth))
-      expect(@gen).to receive(:require).with('redcarpet').and_return(true)
-      expect(@gen).not_to receive(:require).with('maruku')
-      @gen.options.markup = :markdown
-      # this only raises an exception because we mock out require to avoid
-      # loading any libraries but our implementation tries to return the library
-      # name as a constant
-      expect(@gen.load_markup_provider).to be true
-      expect(@gen.markup_provider).to eq :redcarpet
-    end
-
-    it "continues searching if some of the providers are unavailable" do
-      expect(@gen).to receive(:require).with('redcarpet').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('kramdown').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('bluecloth').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('maruku').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('rpeg-markdown').and_return(true)
-      expect(@gen).to receive(:eval).with('::PEGMarkdown').and_return(true)
-      @gen.options.markup = :markdown
-      # this only raises an exception because we mock out require to avoid
-      # loading any libraries but our implementation tries to return the library
-      # name as a constant
-      @gen.load_markup_provider
-      expect(@gen.markup_provider).to eq :"rpeg-markdown"
-    end
-
-    it "overrides the search if `:markup_provider` is set in options" do
-      expect(@gen).to receive(:require).with('rdiscount').and_return(true)
-      expect(@gen).to receive(:eval).with('::RDiscount').and_return(true)
-      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
-      @gen.load_markup_provider
-      expect(@gen.markup_provider).to eq :rdiscount
-    end
-
-    it "fails if no provider is found" do
-      YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
-        expect(@gen).to receive(:require).with(p[:lib].to_s).and_raise(LoadError)
-      end
-      @gen.options.markup = :markdown
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-
-    it "fails if overridden provider is not found" do
-      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
-      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-
-    it "fails if the markup type is not found" do
-      expect(log).to receive(:error).with(/Invalid markup/)
-      @gen.options.markup = :xxx
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-  end
-
-  describe "#markup_for_file" do
-    include YARD::Templates::Helpers::MarkupHelper
-
-    it "looks for a shebang line" do
-      expect(markup_for_file("#!text\ntext here", 'file.rdoc')).to eq :text
-    end
-
-    it "returns the default markup type if no shebang is found or no valid ext is found" do
-      allow(self).to receive(:options).and_return(Options.new.update(:markup => :default_type))
-      expect(markup_for_file('', 'filename')).to eq :default_type
-    end
-
-    it "looks for a file extension if no shebang is found" do
-      expect(markup_for_file('', 'filename.MD')).to eq :markdown
-      expect(markup_for_file('', 'filename.ORG')).to eq :org
-    end
-
-    Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS.each do |type, exts|
-      exts.each do |ext|
-        it "recognizes .#{ext} as #{type} markup type" do
-          expect(markup_for_file('', "filename.#{ext}")).to eq type
-        end
-      end
-    end
-  end
-end

data/spec/templates/helpers/method_helper_spec.rb

@@ -1,107 +0,0 @@
-# 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 +0,0 @@
-# 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 +0,0 @@
-# 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