yard 0.9.24 → 0.9.25

data/spec/core_ext/array_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Array do
-  describe "#place" do
-    it "creates an Insertion object" do
-      expect([].place('x')).to be_kind_of(Insertion)
-    end
-
-    it "allows multiple objects to be placed" do
-      expect([1, 2].place('x', 'y', 'z').before(2)).to eq [1, 'x', 'y', 'z', 2]
-    end
-  end
-end

data/spec/core_ext/file_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe File do
-  describe ".relative_path" do
-    it "returns the relative path between two files" do
-      expect(File.relative_path('a/b/c/d.html', 'a/b/d/q.html')).to eq '../d/q.html'
-    end
-
-    it "returns the relative path between two directories" do
-      expect(File.relative_path('a/b/c/d/', 'a/b/d/')).to eq '../d'
-    end
-
-    it "returns only the to file if from file is in the same directory as the to file" do
-      expect(File.relative_path('a/b/c/d', 'a/b/c/e')).to eq 'e'
-    end
-
-    it "handles non-normalized paths" do
-      expect(File.relative_path('Hello/./I/Am/Fred', 'Hello/Fred')).to eq '../../Fred'
-      expect(File.relative_path('A//B/C', 'Q/X')).to eq '../../Q/X'
-    end
-  end
-
-  describe ".cleanpath" do
-    it "cleans double brackets" do
-      expect(File.cleanpath('A//B/C')).to eq "A/B/C"
-    end
-
-    it "cleans a path with ." do
-      expect(File.cleanpath('Hello/./I/.Am/Fred')).to eq "Hello/I/.Am/Fred"
-    end
-
-    it "cleans a path with .." do
-      expect(File.cleanpath('Hello/../World')).to eq "World"
-    end
-
-    it "cleans a path with multiple .." do
-      expect(File.cleanpath('A/B/C/../../D')).to eq "A/D"
-    end
-
-    it "cleans a path ending in .." do
-      expect(File.cleanpath('A/B/C/D/..')).to eq "A/B/C"
-    end
-
-    it "allows '../' at the beginning if rel_root=true" do
-      expect(File.cleanpath('A/../../B', true)).to eq '../B'
-    end
-
-    it "does not allow relative path above root" do
-      expect(File.cleanpath('A/../../../../../D')).to eq "D"
-    end
-
-    it "does not remove multiple '../' at the beginning" do
-      expect(File.cleanpath('../../A/B')).to eq 'A/B'
-    end
-  end
-
-  describe ".open!" do
-    it "creates the path before opening" do
-      expect(File).to receive(:directory?).with('/path/to').and_return(false)
-      expect(FileUtils).to receive(:mkdir_p).with('/path/to')
-      expect(File).to receive(:open).with('/path/to/file', 'w')
-      File.open!('/path/to/file', 'w')
-    end
-
-    it "just opens the file if the path exists" do
-      expect(File).to receive(:directory?).with('/path/to').and_return(true)
-      expect(FileUtils).not_to receive(:mkdir_p)
-      expect(File).to receive(:open).with('/path/to/file', 'w')
-      File.open!('/path/to/file', 'w')
-    end
-  end
-end

data/spec/core_ext/hash_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hash do
-  describe ".[]" do
-    it "accepts an Array argument (Ruby 1.8.6 and older)" do
-      list = [['foo', 'bar'], ['foo2', 'bar2']]
-      expect(Hash[list]).to eq('foo' => 'bar', 'foo2' => 'bar2')
-    end
-
-    it "accepts an array as a key" do
-      expect(Hash[['a', 'b'], 1]).to eq(['a', 'b'] => 1)
-    end
-  end
-end

data/spec/core_ext/insertion_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Insertion do
-  describe "#before" do
-    it "places an object before another" do
-      expect([1, 2].place(3).before(2)).to eq [1, 3, 2]
-      expect([1, 2].place(3).before(1)).to eq [3, 1, 2]
-      expect([1, [4], 2].place(3).before(2)).to eq [1, [4], 3, 2]
-    end
-  end
-
-  describe "#after" do
-    it "places an object after another" do
-      expect([1, 2].place(3).after(2)).to eq [1, 2, 3]
-    end
-
-    it "no longer places an object after another and its subsections (0.6)" do
-      expect([1, [2]].place(3).after(1)).to eq [1, 3, [2]]
-    end
-
-    it "places an array after an object" do
-      expect([1, 2, 3].place([4]).after(1)).to eq [1, [4], 2, 3]
-    end
-  end
-
-  describe "#before_any" do
-    it "places an object before another anywhere inside list (including sublists)" do
-      expect([1, 2, [3]].place(4).before_any(3)).to eq [1, 2, [4, 3]]
-    end
-  end
-
-  describe "#after_any" do
-    it "places an object after another anywhere inside list (including sublists)" do
-      expect([1, 2, [3]].place(4).after_any(3)).to eq [1, 2, [3, 4]]
-    end
-  end
-end

data/spec/core_ext/module_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Module do
-  describe "#class_name" do
-    it "returns just the name of the class/module" do
-      expect(YARD::CodeObjects::Base.class_name).to eq "Base"
-    end
-  end
-end

data/spec/core_ext/string_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-# described_in_docs String, '#camelcase'
-# described_in_docs String, '#underscore'
-
-RSpec.describe String do
-  describe "#shell_split" do
-    it "splits simple non-quoted text" do
-      expect("a b c".shell_split).to eq %w(a b c)
-    end
-
-    it "splits double quoted text into single token" do
-      expect('a "b c d" e'.shell_split).to eq ["a", "b c d", "e"]
-    end
-
-    it "splits single quoted text into single token" do
-      expect("a 'b c d' e".shell_split).to eq ["a", "b c d", "e"]
-    end
-
-    it "handles escaped quotations in quotes" do
-      expect("'a \\' b'".shell_split).to eq ["a ' b"]
-    end
-
-    it "handles escaped quotations outside quotes" do
-      expect("\\'a 'b'".shell_split).to eq %w('a b)
-    end
-
-    it "handles escaped backslash" do
-      expect("\\\\'a b c'".shell_split).to eq ['\a b c']
-    end
-
-    it "handles any whitespace as space" do
-      text = "foo\tbar\nbaz\r\nfoo2 bar2"
-      expect(text.shell_split).to eq %w(foo bar baz foo2 bar2)
-    end
-
-    it "handles complex input" do
-      text = "hello \\\"world \"1 2\\\" 3\" a 'b \"\\\\\\'' c"
-      expect(text.shell_split).to eq ["hello", "\"world", "1 2\" 3", "a", "b \"\\'", "c"]
-    end
-  end
-end

data/spec/core_ext/symbol_hash_spec.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe SymbolHash do
-  it "allows access to keys as String or Symbol" do
-    h = SymbolHash.new(false)
-    h['test'] = true
-    expect(h[:test]).to be true
-    expect(h['test']).to be true
-  end
-
-  describe "#delete" do
-    it "accepts either Strings or Symbols as deletion key" do
-      h = SymbolHash.new
-      expect(h.keys.length).to eq 0
-
-      h['test'] = true
-      expect(h.keys.length).to eq 1
-
-      h.delete(:test)
-      expect(h.keys.length).to eq 0
-
-      h[:test] = true
-      expect(h.keys.length).to eq 1
-
-      h.delete('test')
-      expect(h.keys.length).to eq 0
-    end
-  end
-
-  describe "#key?" do
-    it "returns same result for String or Symbol" do
-      h = SymbolHash.new
-      h[:test] = 1
-      expect(h.key?(:test)).to be true
-      expect(h.has_key?('test')).to be true # rubocop:disable Style/PreferredHashMethods
-    end
-  end
-
-  it "symbolizes value if it is a String (and only a string)" do
-    class Substring < String; end
-
-    h = SymbolHash.new
-    h['test1'] = "hello"
-    h['test2'] = Substring.new("hello")
-    expect(h['test1']).to eq :hello
-    expect(h['test2']).to eq "hello"
-  end
-
-  it "does not symbolize value if SymbolHash.new(false) is created" do
-    h = SymbolHash.new(false)
-    h['test'] = "hello"
-    expect(h[:test]).to eq "hello"
-  end
-
-  it "does not symbolize value if it is not a String" do
-    h = SymbolHash.new
-    h['test'] = [1, 2, 3]
-    expect(h['test']).to eq [1, 2, 3]
-  end
-
-  it "supports symbolization using #update or #merge!" do
-    h = SymbolHash.new
-    h.update('test' => 'value')
-    expect(h[:test]).to eq :value
-    h.merge!('test' => 'value2') # rubocop:disable Performance/RedundantMerge
-    expect(h[:test]).to eq :value2
-  end
-
-  it "supports symbolization non-destructively using #merge" do
-    h = SymbolHash.new
-    expect(h.merge('test' => 'value')[:test]).to eq :value
-    expect(h).to eq SymbolHash.new
-  end
-
-  it "supports #initializing of a hash" do
-    h = SymbolHash[:test => 1]
-    expect(h[:test]).to eq 1
-    expect(h[:somethingelse]).to be nil
-  end
-
-  it "supports reverse merge syntax" do
-    opts = {}
-    opts = SymbolHash[
-      'default' => 1
-    ].update(opts)
-    expect(opts.keys).to eq [:default]
-    expect(opts[:default]).to eq 1
-  end
-end

data/spec/docstring_parser_spec.rb

@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::DocstringParser do
-  after(:all) do
-    YARD::Registry.clear
-  end
-
-  def parse(content, object = nil, handler = nil)
-    @library ||= Tags::Library.instance
-    @parser = DocstringParser.new(@library)
-    @parser.parse(content, object, handler)
-    @parser
-  end
-
-  def docstring(content, object = nil, handler = nil)
-    parse(content, object, handler).to_docstring
-  end
-
-  describe "#parse" do
-    it "parses comments into tags" do
-      doc = docstring(<<-eof)
-@param name Hello world
-  how are you?
-@param name2
-  this is a new line
-@param name3 and this
-  is a new paragraph:
-
-  right here.
-      eof
-      tags = doc.tags(:param)
-      expect(tags[0].name).to eq "name"
-      expect(tags[0].text).to eq "Hello world\nhow are you?"
-      expect(tags[1].name).to eq "name2"
-      expect(tags[1].text).to eq "this is a new line"
-      expect(tags[2].name).to eq "name3"
-      expect(tags[2].text).to eq "and this\nis a new paragraph:\n\nright here."
-    end
-
-    it "ends parsing a tag on de-dent" do
-      doc = docstring(<<-eof)
-@note test
-  one two three
-rest of docstring
-      eof
-      expect(doc.tag(:note).text).to eq "test\none two three"
-      expect(doc).to eq "rest of docstring"
-    end
-
-    it "parses examples embedded in doc" do
-      doc = docstring(<<-eof)
-test string here
-@example code
-
-  def foo(x, y, z)
-  end
-
-  class A; end
-
-more stuff
-eof
-      expect(doc).to eq "test string here\nmore stuff"
-      expect(doc.tag(:example).text).to eq "\ndef foo(x, y, z)\nend\n\nclass A; end"
-    end
-
-    it "removes only original indentation from beginning of line in tags" do
-      doc = docstring(<<-eof)
-@param name
-  some value
-  foo bar
-   baz
-eof
-      expect(doc.tag(:param).text).to eq "some value\nfoo bar\n baz"
-    end
-
-    it "allows numbers in tags" do
-      Tags::Library.define_tag(nil, :foo1)
-      Tags::Library.define_tag(nil, :foo2)
-      Tags::Library.define_tag(nil, :foo3)
-      doc = docstring(<<-eof)
-@foo1 bar1
-@foo2 bar2
-@foo3 bar3
-eof
-      expect(doc.tag(:foo1).text).to eq "bar1"
-      expect(doc.tag(:foo2).text).to eq "bar2"
-    end
-
-    it "ends tag on newline if next line is not indented" do
-      doc = docstring(<<-eof)
-@author bar1
-@api bar2
-Hello world
-eof
-      expect(doc.tag(:author).text).to eq "bar1"
-      expect(doc.tag(:api).text).to eq "bar2"
-    end
-
-    it "warns about unknown tag" do
-      expect(log).to receive(:warn).with(/Unknown tag @hello$/)
-      docstring("@hello world")
-    end
-
-    it "does not add trailing whitespace to freeform tags" do
-      doc = docstring("@api private   \t   ")
-      expect(doc.tag(:api).text).to eq "private"
-    end
-  end
-
-  describe "#parse with custom tag library" do
-    class TestLibrary < Tags::Library; end
-
-    before { @library = TestLibrary.new }
-
-    it "accepts valid tags" do
-      valid = %w(testing valid is_a is_A __)
-      valid.each do |tag|
-        TestLibrary.define_tag("Tag", tag)
-        doc = docstring('@' + tag + ' foo bar')
-        expect(doc.tag(tag).text).to eq 'foo bar'
-      end
-    end
-
-    it "does not parse invalid tag names" do
-      invalid = %w(@ @return@ @p,aram @x-y @.x.y.z)
-      invalid.each do |tag|
-        expect(docstring(tag + ' foo bar')).to eq tag + ' foo bar'
-      end
-    end
-
-    it "allows namespaced tags in the form @x.y.z" do
-      TestLibrary.define_tag("Tag", 'x.y.z')
-      doc = docstring("@x.y.z foo bar")
-      expect(doc.tag('x.y.z').text).to eq 'foo bar'
-    end
-
-    it "ignores new directives without @! prefix syntax" do
-      TestLibrary.define_directive('dir1', Tags::ScopeDirective)
-      expect(log).to receive(:warn).with(/@dir1/)
-      docstring("@dir1")
-    end
-
-    %w(attribute endgroup group macro method scope visibility).each do |tag|
-      it "handles non prefixed @#{tag} syntax as directive, not tag" do
-        TestLibrary.define_directive(tag, Tags::ScopeDirective)
-        parse("@#{tag}")
-        expect(@parser.directives.first).to be_a(Tags::ScopeDirective)
-      end
-    end
-
-    it "handles directives with @! prefix syntax" do
-      TestLibrary.define_directive('dir2', Tags::ScopeDirective)
-      docstring("@!dir2 class")
-      expect(@parser.state.scope).to eq :class
-    end
-  end
-
-  describe "#text" do
-    it "only returns text data" do
-      parse("Foo\n@param foo x y z\nBar")
-      expect(@parser.text).to eq "Foo\nBar"
-    end
-  end
-
-  describe "#raw_text" do
-    it "returns the entire original data" do
-      data = "Foo\n@param foo x y z\nBar"
-      parse(data)
-      expect(@parser.raw_text).to eq data
-    end
-  end
-
-  describe "#tags" do
-    it "returns the parsed tags" do
-      data = "Foo\n@param foo x y z\nBar"
-      parse(data)
-      expect(@parser.tags.size).to eq 1
-      expect(@parser.tags.first.tag_name).to eq 'param'
-    end
-  end
-
-  describe "#directives" do
-    it "groups all processed directives" do
-      data = "Foo\n@!scope class\n@!visibility private\nBar"
-      parse(data)
-      dirs = @parser.directives
-      expect(dirs[0]).to be_a(Tags::ScopeDirective)
-      expect(dirs[0].tag.text).to eq 'class'
-      expect(dirs[1]).to be_a(Tags::VisibilityDirective)
-      expect(dirs[1].tag.text).to eq 'private'
-    end
-  end
-
-  describe "#state" do
-    it "handles modified state" do
-      parse("@!scope class")
-      expect(@parser.state.scope).to eq :class
-    end
-  end
-
-  describe "after_parse (param)" do
-    it "allows specifying of callbacks" do
-      parser = DocstringParser.new
-      the_yielded_obj = nil
-      DocstringParser.after_parse {|obj| the_yielded_obj = obj }
-      parser.parse("Some text")
-      expect(the_yielded_obj).to eq parser
-    end
-
-    it "warns about invalid named parameters" do
-      expect(log).to receive(:warn).with(/@param tag has unknown parameter name: notaparam/)
-      YARD.parse_string <<-eof
-        # @param notaparam foo
-        def foo(a) end
-      eof
-    end
-
-    it "warns about invalid named parameters on @!method directives" do
-      expect(log).to receive(:warn).with(/@param tag has unknown parameter name: notaparam/)
-      YARD.parse_string <<-eof
-        # @!method foo(a)
-        #   @param notaparam foo
-        test
-      eof
-    end
-
-    it "warns about duplicate named parameters" do
-      expect(log).to receive(:warn).with(/@param tag has duplicate parameter name: a/)
-      YARD.parse_string <<-eof
-        # @param a foo
-        # @param a foo
-        def foo(a) end
-      eof
-    end
-
-    it "does not warn on aliases" do
-      expect(log).to_not receive(:warn)
-      YARD.parse_string <<-eof
-        # @param a foo
-        def foo(a) end
-        alias bar foo
-      eof
-    end
-
-    it "does not warn on matching param with inline method modifier" do
-      expect(log).to_not receive(:warn)
-      YARD.parse_string <<-eof
-        # @param [Numeric] a
-        # @return [Numeric]
-        private_class_method def self.foo(a); a + 1; end
-      eof
-    end
-
-    it "warns on mismatching param with inline method modifier" do
-      expect(log).to receive(:warn).with(/@param tag has unknown parameter name: notaparam/)
-      YARD.parse_string <<-eof
-        # @param [Numeric] notaparam
-        # @return [Numeric]
-        private_class_method def self.foo(a); a + 1; end
-      eof
-    end
-  end
-
-  describe "after_parse (see)" do
-    it "does not warn on valid see tag" do
-      expect(log).to_not receive(:warn)
-      YARD.parse_string "# @see valid\nclass Foo;end"
-    end
-
-    it "warns if {} wraps single name" do
-      expect(log).to receive(:warn).with(/@see tag \(#1\) should not be wrapped in \{\}/)
-      YARD.parse_string "# @see {invalid}\nclass Foo;end"
-    end
-
-    it "warns if {} wraps across name and text" do
-      expect(log).to receive(:warn).with(/@see tag \(#1\) should not be wrapped in \{\}/)
-      YARD.parse_string "# @see {invalid tag}\nclass Foo;end"
-    end
-  end
-end