yard 0.9.23 → 0.9.27

data/spec/templates/markup_processor_integrations/integration_spec_helper.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_context 'shared helpers for markup processor integration specs' do
-  let(:rendered_document) { html_renderer.htmlify document }
-
-  let(:template_options) do
-    Templates::TemplateOptions.new.tap do |o|
-      o.reset_defaults
-      o.default_return = nil
-      o.markup = markup
-      o.markup_provider = markup_provider
-    end
-  end
-
-  let(:html_renderer) do
-    obj = OpenStruct.new
-    obj.options = template_options
-    obj.object = Registry.root
-    obj.extend(Templates::Helpers::HtmlHelper)
-    obj
-  end
-
-  before(:each) do
-    if html_renderer.markup_class(markup).nil?
-      skip "Missing markup renderer #{markup}"
-    end
-  end
-
-  # Works only with one-liners.
-  def highlighted_ruby_regexp(*identifiers)
-    prefix = Regexp.escape '<pre class="code ruby"><code class="ruby">'
-    any_span_tag = '<span\b'
-    escaped_identifiers = identifiers.map {|a| Regexp.escape(a) }
-
-    regexp_parts = [prefix, any_span_tag, escaped_identifiers]
-    regexp_str = regexp_parts.flatten.join(".*")
-    Regexp.compile(regexp_str)
-  end
-
-  def header_regexp(level, text)
-    prefix = "<h#{level}[^>]*?>"
-    escaped_text = Regexp.escape text
-    regexp_str = [prefix, escaped_text].join(".*")
-    Regexp.compile(regexp_str)
-  end
-end

data/spec/templates/markup_processor_integrations/rdoc_markdown_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require File.dirname(__FILE__) + '/integration_spec_helper'
-
-RSpec.describe 'Markdown via RDoc integration' do
-  include_context 'shared helpers for markup processor integration specs'
-  let(:markup) { :markdown }
-  let(:markup_provider) { :rdoc }
-
-  let(:document) do
-    <<-MARKDOWN
-## Example code listings
-
-Indented block of Ruby code:
-
-    x = 1
-
-Fenced block of Ruby code:
-
-```
-x = 2
-```
-
-Fenced and annotated block of Ruby code:
-
-```ruby
-x = 3
-```
-
-Fenced and annotated block of non-Ruby code:
-
-```plain
-x = 4
-```
-
-MARKDOWN
-  end
-
-  it 'renders level 2 header' do
-    expect(rendered_document).to match(header_regexp(2, 'Example code listings'))
-  end
-
-  it 'renders indented block of code, and applies Ruby syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '1'))
-  end
-
-  it 'renders fenced block of code, and applies Ruby syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '2'))
-  end
-
-  it 'renders fenced and annotated block of Ruby code, and applies syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '3'))
-  end
-
-  it 'renders fenced and annotated block of non-Ruby code, and does not apply syntax highlight' do
-    pending 'This is actually highlighted, but it is not a big deal'
-    expect(rendered_document).to match('x = 4')
-  end
-end

data/spec/templates/markup_processor_integrations/rdoc_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require File.dirname(__FILE__) + '/integration_spec_helper'
-
-RSpec.describe 'RDoc integration' do
-  include_context 'shared helpers for markup processor integration specs'
-  let(:markup) { :rdoc }
-  # Must be nil as this is how this provider is defined.
-  # See: https://github.com/lsegal/yard/commit/6634ae25878cd4fcb79.
-  let(:markup_provider) { nil }
-
-  let(:document) do
-    <<-RDOC
-== Example code listings
-
-Verbatim block of Ruby code:
-
-  x = 1
-
-Verbatim non-Ruby block:
-
-  This has nothing to do with Ruby.
-
-RDOC
-  end
-
-  it 'renders level 2 header' do
-    expect(rendered_document).to match(header_regexp(2, 'Example code listings'))
-  end
-
-  it 'renders indented block of code, and applies Ruby syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '1'))
-  end
-
-  it 'renders indented block of text which is not a piece of Ruby code, ' \
-    'and does not apply syntax highlight' do
-    expect(rendered_document).to match('This has nothing to do with Ruby.')
-  end
-end

data/spec/templates/markup_processor_integrations/redcarpet_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require File.dirname(__FILE__) + '/integration_spec_helper'
-
-RSpec.describe 'Redcarpet integration' do
-  include_context 'shared helpers for markup processor integration specs'
-  let(:markup) { :markdown }
-  let(:markup_provider) { :redcarpet }
-
-  let(:document) do
-    <<-MARKDOWN
-## Example code listings
-
-Indented block of Ruby code:
-
-    x = 1
-
-Fenced block of Ruby code:
-
-```
-x = 2
-```
-
-Fenced and annotated block of Ruby code:
-
-```ruby
-x = 3
-```
-
-Fenced and annotated block of non-Ruby code:
-
-```plain
-x = 4
-```
-
-MARKDOWN
-  end
-
-  it 'renders level 2 header' do
-    expect(rendered_document).to match(header_regexp(2, 'Example code listings'))
-  end
-
-  it 'renders indented block of code, and applies Ruby syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '1'))
-  end
-
-  it 'renders fenced block of code, and applies Ruby syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '2'))
-  end
-
-  it 'renders fenced and annotated block of Ruby code, and applies syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '3'))
-  end
-
-  it 'renders fenced and annotated block of non-Ruby code, and does not apply syntax highlight' do
-    pending 'This is actually highlighted, but it is not a big deal'
-    expect(rendered_document).to match('x = 4')
-  end
-end

data/spec/templates/markup_processor_integrations/redcloth_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require File.dirname(__FILE__) + '/integration_spec_helper'
-
-RSpec.describe 'RedCloth integration' do
-  include_context 'shared helpers for markup processor integration specs'
-  let(:markup) { :textile }
-  let(:markup_provider) { :redcloth }
-
-  let(:document) do
-    <<-TEXTILE
-h2. Example code listings
-
-Example paragraph.
-
-p. Example paragraph using 'p' tag.
-
-p. Block of Ruby code using 'bc' tag:
-
-bc. x = 1
-
-p. Block of Ruby code using 'pre' tag:
-
-pre. x = 2
-TEXTILE
-  end
-
-  it 'renders level 2 header' do
-    expect(rendered_document).to match(header_regexp(2, 'Example code listings'))
-  end
-
-  it 'renders paragraphs' do
-    expect(rendered_document).
-      to include('<p>Example paragraph.</p>')
-    # Textile may replace typewriter apostrophes here used as quotes with
-    # something typographically better
-    expect(rendered_document).
-      to match(%r{<p>Example paragraph using .*p.* tag.</p>})
-  end
-
-  it 'renders bc. block, and applies Ruby syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '1'))
-  end
-
-  it 'renders pre. block, and applies Ruby syntax highlight' do
-    expect(rendered_document).to match(highlighted_ruby_regexp('x', '=', '2'))
-  end
-end

data/spec/templates/method_spec.rb

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

data/spec/templates/onefile_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-class StringSerializer < YARD::Serializers::Base
-  attr_accessor :files, :string
-  def initialize(files, string)
-    @files = files
-    @string = string
-  end
-
-  def serialize(object, data)
-    files << object
-    string << data
-  end
-end
-
-RSpec.describe YARD::Templates::Engine.template(:default, :onefile) do
-  before do
-    Registry.clear
-    if defined?(::Encoding)
-      @eenc = Encoding.default_external
-      Encoding.default_external = 'ascii-8bit'
-      @ienc = Encoding.default_internal
-      Encoding.default_internal = 'ascii-8bit'
-    end
-  end
-
-  after do
-    if defined?(::Encoding)
-      Encoding.default_internal = @ienc
-      Encoding.default_external = @eenc
-    end
-  end
-
-  def render
-    @files = []
-    @output = String.new("")
-    YARD.parse_string <<-eof
-      class A
-        # Foo method
-        # @return [String]
-        def foo; end
-
-        # Bar method
-        # @return [Numeric]
-        def bar; end
-      end
-    eof
-    readme = CodeObjects::ExtraFileObject.new('README',
-      "# This is a code comment\n\n# Top of file\n\n\nclass C; end")
-    Templates::Engine.generate Registry.all(:class),
-      :serializer => StringSerializer.new(@files, @output),
-      :onefile => true, :format => :html, :readme => readme, :files => [readme,
-        CodeObjects::ExtraFileObject.new('LICENSE', 'This is a license!')]
-  end
-
-  it "renders html" do
-    render
-    expect(@files).to eq ['index.html']
-    expect(@output).to include("This is a code comment")
-    expect(@output).to include("This is a license!")
-    expect(@output).to include("Class: A")
-    expect(@output).to include("Foo method")
-    expect(@output).to include("Bar method")
-  end
-end