yard 0.9.24 → 0.9.25

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

data/spec/templates/section_spec.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Templates::Section do
-  include YARD::Templates
-
-  describe "#initialize" do
-    it "converts first argument to splat if it is array" do
-      s = Section.new(:name, [:foo, :bar])
-      expect(s.name).to eq :name
-      expect(s[0].name).to eq :foo
-      expect(s[1].name).to eq :bar
-    end
-
-    it "allows initialization with Section objects" do
-      s = Section.new(:name, [:foo, Section.new(:bar)])
-      expect(s.name).to eq :name
-      expect(s[0]).to eq Section.new(:foo)
-      expect(s[1]).to eq Section.new(:bar)
-    end
-
-    it "makes a list of sections" do
-      s = Section.new(:name, [:foo, [:bar]])
-      expect(s).to eq Section.new(:name, Section.new(:foo, Section.new(:bar)))
-    end
-  end
-
-  describe "#[]" do
-    it "uses Array#[] if argument is integer" do
-      expect(Section.new(:name, [:foo, :bar])[0].name).to eq :foo
-    end
-
-    it "returns new Section object if more than one argument" do
-      expect(Section.new(:name, :foo, :bar, :baz)[1, 2]).to eq Section.new(:name, :bar, :baz)
-    end
-
-    it "returns new Section object if arg is Range" do
-      expect(Section.new(:name, :foo, :bar, :baz)[1..2]).to eq Section.new(:name, :bar, :baz)
-    end
-
-    it "looks for section by name if arg is object" do
-      expect(Section.new(:name, :foo, :bar, [:baz])[:bar][:baz]).to eq Section.new(:baz)
-    end
-  end
-
-  describe "#eql?" do
-    it "checks for equality of two equal sections" do
-      expect(Section.new(:foo, [:a, :b])).to eql(Section.new(:foo, :a, :b))
-      expect(Section.new(:foo, [:a, :b])).to eq Section.new(:foo, :a, :b)
-    end
-
-    it "is not equal if section names are different" do
-      expect(Section.new(:foo, [:a, :b])).not_to eql(Section.new(:bar, :a, :b))
-      expect(Section.new(:foo, [:a, :b])).not_to eq Section.new(:bar, :a, :b)
-    end
-  end
-
-  describe "#==" do
-    it "allows comparison to Symbol" do
-      expect(Section.new(:foo, 2, 3)).to eq :foo
-    end
-
-    it "allows comparison to String" do
-      expect(Section.new("foo", 2, 3)).to eq "foo"
-    end
-
-    it "allows comparison to Template" do
-      t = YARD::Templates::Engine.template!(:xyzzy, '/full/path/xyzzy')
-      expect(Section.new(t, 2, 3)).to eq t
-    end
-
-    it "allows comparison to Section" do
-      expect(Section.new(1, [2, 3])).to eq Section.new(1, 2, 3)
-    end
-
-    it "allows comparison to Object" do
-      expect(Section.new(1, [2, 3])).to eq 1
-    end
-
-    it "allows comparison to Array" do
-      expect(Section.new(1, 2, [3])).to eq [1, [2, [3]]]
-    end
-  end
-
-  describe "#to_a" do
-    it "converts Section to regular Array list" do
-      arr = Section.new(1, 2, [3, [4]]).to_a
-      expect(arr.class).to eq Array
-      expect(arr).to eq [1, [2, [3, [4]]]]
-    end
-  end
-
-  describe "#place" do
-    it "places objects as Sections" do
-      expect(Section.new(1, 2, 3).place(4).before(3)).to eq [1, [2, 4, 3]]
-    end
-
-    it "places objects anywhere inside Section with before/after_any" do
-      expect(Section.new(1, 2, [3, [4]]).place(5).after_any(4)).to eq [1, [2, [3, [4, 5]]]]
-      expect(Section.new(1, 2, [3, [4]]).place(5).before_any(4)).to eq [1, [2, [3, [5, 4]]]]
-    end
-
-    it "allows multiple sections to be placed" do
-      expect(Section.new(1, 2, 3).place(4, 5).after(3).to_a).to eq [1, [2, 3, 4, 5]]
-      expect(Section.new(1, 2, 3).place(4, [5]).after(3).to_a).to eq [1, [2, 3, 4, [5]]]
-    end
-  end
-
-  describe "#push" do
-    it "pushes objects as Sections" do
-      s = Section.new(:foo)
-      s.push :bar
-      expect(s[0]).to eq Section.new(:bar)
-    end
-
-    it "is aliased as #<<" do
-      s = Section.new(1)
-      s << :index
-      expect(s[:index]).to be_a(Section)
-    end
-  end
-
-  describe "#unshift" do
-    it "unshifts objects as Sections" do
-      s = Section.new(:foo)
-      s.unshift :bar
-      expect(s[0]).to eq Section.new(:bar)
-    end
-  end
-
-  describe "#any" do
-    it "finds item inside sections" do
-      s = Section.new(:foo, Section.new(:bar, Section.new(:bar)))
-      s.any(:bar).push(:baz)
-      expect(s.to_a).to eq [:foo, [:bar, [:bar, :baz]]]
-    end
-
-    it "finds item in any deeply nested set of sections" do
-      s = Section.new(:foo, Section.new(:bar, Section.new(:baz)))
-      s.any(:baz).push(:qux)
-      expect(s.to_a).to eq [:foo, [:bar, [:baz, [:qux]]]]
-    end
-  end
-end

data/spec/templates/spec_helper.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-include YARD::Templates
-
-def only_copy?(result, example, type)
-  return false unless defined?($COPY)
-
-  if $COPY == :all || $COPY == example
-    puts(result) unless $COPYT && $COPYT != type
-  end
-  $COPY ? true : false
-end
-
-def text_equals(result, expected_example)
-  return if only_copy?(result, expected_example, :text)
-  text_equals_string(result, example_contents(expected_example, :txt))
-end
-
-def text_equals_string(result, expected)
-  expect(result).to eq expected
-end
-
-def html_equals(result, expected_example)
-  return if only_copy?(result, expected_example, :html)
-  html_equals_string(result, example_contents(expected_example))
-end
-
-def html_equals_string(result, expected)
-  result = String.new(result)
-  expected = String.new(expected)
-  [expected, result].each do |value|
-    value.gsub!(/(>)\s+|\s+(<)/, '\1\2')
-    value.gsub!(/&#39;/, "'")
-    value.strip!
-  end
-  text_equals_string(result, expected)
-end
-
-def example_contents(filename, ext = 'html')
-  File.read(File.join(File.dirname(__FILE__), 'examples', "#{filename}.#{ext}"))
-end
-
-module YARD::Templates::Engine
-  class << self
-    public :find_template_paths
-  end
-end
-
-class TestHtmlTemplateOptions < Templates::TemplateOptions
-  default_attr :markup, :none
-  default_attr :default_return, ""
-  default_attr :format, :html
-  default_attr :highlight, false
-end
-
-class TestTextTemplateOptions < Templates::TemplateOptions
-  default_attr :markup, :none
-  default_attr :default_return, ""
-  default_attr :format, :text
-  default_attr :highlight, false
-end
-
-def html_options(opts = {})
-  template_options(opts, TestHtmlTemplateOptions)
-end
-
-def text_options(opts = {})
-  template_options(opts, TestTextTemplateOptions)
-end
-
-def template_options(opts, klass)
-  options = klass.new
-  options.reset_defaults
-  options.update(opts)
-  options
-end