yard 0.9.23 → 0.9.27

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

data/spec/templates/tag_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Templates::Engine.template(:default, :tags) do
-  before { Registry.clear }
-
-  describe "all known tags" do
-    before do
-      YARD.parse_string <<-'eof'
-        # Comments
-        # @abstract override me
-        # @param [Hash] opts the options
-        # @option opts :key ('') hello
-        # @option opts :key2 (X) hello
-        # @return [String] the result
-        # @raise [Exception] Exception class
-        # @deprecated for great justice
-        # @see A
-        # @see http://url.com
-        # @see http://url.com Example
-        # @author Name
-        # @since 1.0
-        # @version 1.0
-        # @yield a block
-        # @yieldparam [String] a a value
-        # @yieldreturn [Hash] a hash
-        # @example Wash your car
-        #   car.wash
-        # @example To kill a mockingbird
-        #   a = String.new
-        #   flip(a.reverse)
-        def m(opts = {}) end
-      eof
-    end
-
-    it "renders text format correctly" do
-      text_equals(Registry.at('#m').format(text_options), :tag001)
-    end
-  end
-
-  describe "param tags on non-methods" do
-    it "does not display @param tags on non-method objects" do
-      YARD.parse_string <<-'eof'
-        # @param [#to_s] name the name
-        module Foo; end
-      eof
-
-      proc = lambda { Registry.at('Foo').format(html_options) }
-      expect(proc).not_to raise_error
-    end
-  end
-end

data/spec/templates/template_spec.rb

@@ -1,410 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Templates::Template do
-  def template(path)
-    YARD::Templates::Engine.template!(path, '/full/path/' + path.to_s)
-  end
-
-  before :each do
-    YARD::Templates::ErbCache.clear!
-  end
-
-  describe ".include_parent" do
-    it "does not include parent directory if parent directory is a template root path" do
-      mod = template('q')
-      expect(mod).not_to include(template(''))
-    end
-
-    it "includes overridden parent directory" do
-      allow(Engine).to receive(:template_paths).and_return(['/foo', '/bar'])
-      expect(File).to receive(:directory?).with('/foo/a/b').and_return(true)
-      expect(File).to receive(:directory?).with('/bar/a/b').and_return(false)
-      expect(File).to receive(:directory?).with('/foo/a').at_least(1).times.and_return(true)
-      expect(File).to receive(:directory?).with('/bar/a').at_least(1).times.and_return(true)
-      ancestors = Engine.template('a/b').ancestors.map(&:class_name)
-      expect(ancestors[0, 3]).to eq %w(Template__foo_a_b Template__bar_a Template__foo_a)
-    end
-
-    it "includes parent directory template if exists" do
-      mod1 = template('x')
-      mod2 = template('x/y')
-      expect(mod2).to include(mod1)
-    end
-  end
-
-  describe ".full_paths" do
-    it "lists full_path" do
-      mod = template(:a)
-      expect(mod.full_paths).to eq ['/full/path/a']
-    end
-
-    it "lists paths of included modules" do
-      mod = template(:a)
-      mod.send(:include, template(:b))
-      expect(mod.full_paths).to eq ['/full/path/a', '/full/path/b']
-    end
-
-    it "lists paths from modules of included modules" do
-      mod = template(:c)
-      mod.send(:include, template(:d))
-      mod.send(:include, template(:a))
-      expect(mod.full_paths).to eq ['c', 'a', 'b', 'd'].map {|o| '/full/path/' + o }
-    end
-
-    it "only lists full paths of modules that respond to full_paths" do
-      mod = template(:d)
-      mod.send(:include, Enumerable)
-      expect(mod.full_paths).to eq ['/full/path/d']
-    end
-  end
-
-  describe ".load_setup_rb" do
-    it "loads setup.rb file for module" do
-      expect(File).to receive(:file?).with('/full/path/e/setup.rb').and_return(true)
-      expect(File).to receive(:read).with('/full/path/e/setup.rb').and_return(String.new('def success; end'))
-      expect(template(:e).new).to respond_to(:success)
-    end
-  end
-
-  describe ".T" do
-    it "loads template from absolute path" do
-      mod = template(:a)
-      expect(Engine).to receive(:template).with('other')
-      mod.T('other')
-    end
-  end
-
-  describe ".find_file" do
-    it "finds file in the module's full_path" do
-      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(false)
-      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(true)
-      expect(template(:a).find_file('basename')).to eq '/full/path/b/basename'
-    end
-
-    it "returns nil if no file is found" do
-      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(false)
-      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(false)
-      expect(template(:a).find_file('basename')).to be nil
-    end
-  end
-
-  describe ".find_nth_file" do
-    it "finds 2nd existing file in template paths" do
-      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(true)
-      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(true)
-      expect(template(:a).find_nth_file('basename', 2)).to eq '/full/path/b/basename'
-    end
-
-    it "returns nil if no file is found" do
-      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(true)
-      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(true)
-      expect(template(:a).find_nth_file('basename', 3)).to be nil
-    end
-  end
-
-  describe ".extra_includes" do
-    it "is included when a module is initialized" do
-      module MyModule; end
-      Template.extra_includes << MyModule
-      expect(template(:e).new).to be_kind_of(MyModule)
-    end
-
-    it "supports lambdas in list" do
-      module MyModule2; end
-      Template.extra_includes << lambda {|opts| MyModule2 if opts.format == :html }
-      expect(template(:f).new(:format => :html)).to be_kind_of(MyModule2)
-      metaclass = (class << template(:g).new(:format => :text); self end)
-      expect(metaclass.ancestors).not_to include(MyModule2)
-    end
-  end
-
-  describe ".is_a?" do
-    it "is kind of Template" do
-      expect(template(:e).is_a?(Template)).to be true
-    end
-  end
-
-  describe "#T" do
-    it "delegates to class method" do
-      expect(template(:e)).to receive(:T).with('test')
-      template(:e).new.T('test')
-    end
-  end
-
-  describe "#init" do
-    it "is called during initialization" do
-      module YARD::Templates::Engine::Template__full_path_e # rubocop:disable Style/ClassAndModuleCamelCase
-        def init; sections 1, 2, 3 end
-      end
-      expect(template(:e).new.sections).to eq Section.new(nil, 1, 2, 3)
-    end
-  end
-
-  describe "#file" do
-    it "reads the file if it exists" do
-      expect(File).to receive(:file?).with('/full/path/e/abc').and_return(true)
-      expect(IO).to receive(:read).with('/full/path/e/abc').and_return('hello world')
-      expect(template(:e).new.file('abc')).to eq 'hello world'
-    end
-
-    it "raises ArgumentError if the file does not exist" do
-      expect(File).to receive(:file?).with('/full/path/e/abc').and_return(false)
-      expect { template(:e).new.file('abc') }.to raise_error(ArgumentError)
-    end
-
-    it "replaces {{{__super__}}} with inherited template contents if allow_inherited=true" do
-      expect(File).to receive(:file?).with('/full/path/a/abc').twice.and_return(true)
-      expect(File).to receive(:file?).with('/full/path/b/abc').and_return(true)
-      expect(IO).to receive(:read).with('/full/path/a/abc').and_return(String.new('foo {{{__super__}}}'))
-      expect(IO).to receive(:read).with('/full/path/b/abc').and_return(String.new('bar'))
-      expect(template(:a).new.file('abc', true)).to eq "foo bar"
-    end
-
-    it "does not replace {{{__super__}}} with inherited template contents if allow_inherited=false" do
-      expect(File).to receive(:file?).with('/full/path/a/abc').and_return(true)
-      expect(IO).to receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
-      expect(template(:a).new.file('abc')).to eq "foo {{{__super__}}}"
-    end
-  end
-
-  describe "#superb" do
-    it "returns the inherited erb template contents" do
-      expect(File).to receive(:file?).with('/full/path/a/test.erb').and_return(true)
-      expect(File).to receive(:file?).with('/full/path/b/test.erb').and_return(true)
-      expect(IO).to receive(:read).with('/full/path/b/test.erb').and_return('bar')
-      template = template(:a).new
-      template.section = :test
-      expect(template.superb).to eq "bar"
-    end
-
-    it "works inside an erb template" do
-      expect(File).to receive(:file?).with('/full/path/a/test.erb').twice.and_return(true)
-      expect(File).to receive(:file?).with('/full/path/b/test.erb').and_return(true)
-      expect(IO).to receive(:read).with('/full/path/a/test.erb').and_return('foo<%= superb %>!')
-      expect(IO).to receive(:read).with('/full/path/b/test.erb').and_return('bar')
-      template = template(:a).new
-      template.section = :test
-      expect(template.erb(:test)).to eq "foobar!"
-    end
-  end
-
-  describe "#sections" do
-    it "allows sections to be set if arguments are provided" do
-      mod = template(:e).new
-      mod.sections 1, 2, [3]
-      expect(mod.sections).to eq Section.new(nil, 1, 2, [3])
-    end
-  end
-
-  describe "#run" do
-    it "renders all sections" do
-      mod = template(:e).new
-      allow(mod).to receive(:render_section) {|section| section.name.to_s }
-      mod.sections :a, :b, :c
-      expect(mod.run).to eq 'abc'
-    end
-
-    it "renders all sections with options" do
-      mod = template(:e).new
-      allow(mod).to receive(:render_section) {|section| section.name.to_s }
-      expect(mod).to receive(:add_options).with(:a => 1).and_yield
-      mod.sections :a
-      expect(mod.run(:a => 1)).to eq 'a'
-    end
-
-    it "runs section list if provided" do
-      mod = template(:e).new
-      expect(mod).to receive(:render_section).exactly(2).times do |section|
-        expect([:q, :x]).to include(section.name)
-        section.name.to_s
-      end
-      mod.run({}, [:q, :x])
-    end
-
-    it "accepts a nil section as empty string" do
-      mod = template(:e).new
-      allow(mod).to receive(:render_section) { nil }
-      mod.sections :a
-      expect(mod.run).to eq ""
-    end
-  end
-
-  describe "#add_options" do
-    it "sets instance variables in addition to options" do
-      mod = template(:f).new
-      mod.send(:add_options, :a => 1, :b => 2)
-      expect(mod.options).to eq(:a => 1, :b => 2)
-      expect(mod.instance_variable_get("@a")).to eq 1
-      expect(mod.instance_variable_get("@b")).to eq 2
-    end
-
-    it "sets instance variables and options only for the block" do
-      mod = template(:f).new
-      mod.send(:add_options, :a => 100, :b => 200) do
-        expect(mod.options).to eq(:a => 100, :b => 200)
-      end
-      expect(mod.options).not_to eq(:a => 100, :b => 200)
-    end
-  end
-
-  describe "#render_section" do
-    it "calls method if method exists by section name as Symbol" do
-      mod = template(:f).new
-      expect(mod).to receive(:respond_to?).with(:a).and_return(true)
-      expect(mod).to receive(:respond_to?).with('a').and_return(true)
-      expect(mod).to receive(:send).with(:a).and_return('a')
-      expect(mod).to receive(:send).with('a').and_return('a')
-      expect(mod.run({}, [:a, 'a'])).to eq 'aa'
-    end
-
-    it "calls erb if no method exists by section name" do
-      mod = template(:f).new
-      expect(mod).to receive(:respond_to?).with(:a).and_return(false)
-      expect(mod).to receive(:respond_to?).with('a').and_return(false)
-      expect(mod).to receive(:erb).with(:a).and_return('a')
-      expect(mod).to receive(:erb).with('a').and_return('a')
-      expect(mod.run({}, [:a, 'a'])).to eq 'aa'
-    end
-
-    it "runs a template if section is one" do
-      mod2 = template(:g)
-      expect(mod2).to receive(:run)
-      mod = template(:f).new
-      mod.sections mod2
-      mod.run
-    end
-
-    it "runs a template instance if section is one" do
-      mod2 = template(:g).new
-      expect(mod2).to receive(:run)
-      mod = template(:f).new
-      mod.sections mod2
-      mod.run
-    end
-  end
-
-  describe "#yield" do
-    it "yields a subsection" do
-      mod = template(:e).new
-      mod.sections :a, [:b, :c]
-      class << mod
-        def a; "(" + yield + ")" end
-        def b; "b" end
-        def c; "c" end
-      end
-
-      expect(mod.run).to eq "(b)"
-    end
-
-    it "yields a subsection within a yielded subsection" do
-      mod = template(:e).new
-      mod.sections :a, [:b, [:c]]
-      class << mod
-        def a; "(" + yield + ")" end
-        def b; yield end
-        def c; "c" end
-      end
-
-      expect(mod.run).to eq "(c)"
-    end
-
-    it "supports arbitrary nesting" do
-      mod = template(:e).new
-      mod.sections :a, [:b, [:c, [:d, [:e]]]]
-      class << mod
-        def a; "(" + yield + ")" end
-        def b; yield end
-        def c; yield end
-        def d; yield end
-        def e; "e" end
-      end
-
-      expect(mod.run).to eq "(e)"
-    end
-
-    it "yields first two elements if yield is called twice" do
-      mod = template(:e).new
-      mod.sections :a, [:b, :c, :d]
-      class << mod
-        def a; "(" + yield + yield + ")" end
-        def b; 'b' end
-        def c; "c" end
-      end
-
-      expect(mod.run).to eq "(bc)"
-    end
-
-    it "ignores any subsections inside subsection yields" do
-      mod = template(:e).new
-      mod.sections :a, [:b, [:c], :d]
-      class << mod
-        def a; "(" + yield + yield + ")" end
-        def b; 'b' end
-        def d; "d" end
-      end
-
-      expect(mod.run).to eq "(bd)"
-    end
-
-    it "allows extra options passed via yield" do
-      mod = template(:e).new
-      mod.sections :a, [:b]
-      class << mod
-        def a; "(" + yield(:x => "a") + ")" end
-        def b; options.x + @x end
-      end
-
-      expect(mod.run).to eq "(aa)"
-    end
-  end
-
-  describe "#yieldall" do
-    it "yields all subsections" do
-      mod = template(:e).new
-      mod.sections :a, [:b, [:d, [:e]], :c]
-      class << mod
-        def a; "(" + yieldall + ")" end
-        def b; "b" + yieldall end
-        def c; "c" end
-        def d; 'd' + yieldall end
-        def e; 'e' end
-      end
-
-      expect(mod.run).to eq "(bdec)"
-    end
-
-    it "yields options to all subsections" do
-      mod = template(:e).new
-      mod.sections :a, [:b, :c]
-      class << mod
-        def a; "(" + yieldall(:x => "2") + ")" end
-        def b; @x end
-        def c; @x end
-      end
-      expect(mod.run).to eq "(22)"
-    end
-
-    it "yields all subsections more than once" do
-      mod = template(:e).new
-      mod.sections :a, [:b]
-      class << mod
-        def a; "(" + yieldall + yieldall + ")" end
-        def b; "b" end
-      end
-
-      expect(mod.run).to eq "(bb)"
-    end
-
-    it "does not yield if no yieldall is called" do
-      mod = template(:e).new
-      mod.sections :a, [:b]
-      class << mod
-        def a; "()" end
-        def b; "b" end
-      end
-
-      expect(mod.run).to eq "()"
-    end
-  end
-end