yard 0.9.18 → 0.9.23

data/spec/core_ext/array_spec.rb

@@ -1,13 +1,13 @@
-# 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
+# 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 +1,72 @@
-# 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
+# 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 +1,14 @@
-# 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
+# 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 +1,37 @@
-# 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
+# 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,15 +1,9 @@
-# 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
-
-  describe "#namespace" do
-    it "returns everything before the class name" do
-      expect(YARD::CodeObjects::Base.namespace_name).to eq "YARD::CodeObjects"
-    end
-  end
-end
+# 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 +1,42 @@
-# 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
+# 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 +1,89 @@
-# 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
+# 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