yard 0.9.5 → 0.9.6

data/spec/templates/examples/method006.html

@@ -0,0 +1,108 @@
+<h1>Method: #m</h1>
+<div class="box_info">
+  <dl>
+    <dt class="">Defined in:</dt>
+    <dd class="">
+    (stdin)
+    </dd>
+  </dl>
+</div>
+
+<div class="method_details_list">
+  <div id="method_details">
+    <div class="method_details first">
+  <h3 class="signature first" id="m-instance_method">
+  
+    #<strong>m</strong>(x, y, *args, kword1: 123, kword2:)  
+  
+
+  
+
+  
+</h3><div class="docstring">
+  <div class="discussion">
+    
+
+  </div>
+</div>
+<div class="tags">
+  <p class="tag_title">Parameters:</p>
+<ul class="param">
+  
+    <li>
+      
+        <span class='name'>x</span>
+      
+      
+        <span class='type'>(<tt>String</tt>)</span>
+      
+      
+      
+        &mdash;
+        <div class='inline'>the x argument</div>
+      
+    </li>
+  
+    <li>
+      
+        <span class='name'>y</span>
+      
+      
+        <span class='type'>(<tt>Boolean</tt>)</span>
+      
+      
+      
+        &mdash;
+        <div class='inline'>the y argument</div>
+      
+    </li>
+  
+    <li>
+      
+        <span class='name'>keyword</span>
+      
+      
+        <span class='type'>(<tt>kword1</tt>)</span>
+      
+      
+      
+        &mdash;
+        <div class='inline'>1</div>
+      
+    </li>
+  
+    <li>
+      
+        <span class='name'>keyword</span>
+      
+      
+        <span class='type'>(<tt>kword2</tt>)</span>
+      
+      
+      
+        &mdash;
+        <div class='inline'>2</div>
+      
+    </li>
+  
+</ul>
+
+
+</div><table class="source_code">
+  <tr>
+    <td>
+      <pre class="lines">
+
+
+5</pre>
+    </td>
+    <td>
+      <pre class="code"><span class="info file"># File '(stdin)', line 5</span>
+
+def m(x, y, *args, kword1: 123, kword2:, **) end</pre>
+    </td>
+  </tr>
+</table>
+</div>
+  </div>
+</div>

data/spec/templates/examples/method006.txt

@@ -0,0 +1,20 @@
+------------------------------------------------------------- Method: #m
+                                                   (Defined in: (stdin))
+
+    root.m(x, y, *args, kword1: 123, kword2:) 
+------------------------------------------------------------------------
+
+    
+Parameters:
+-----------
+
+    (String) x - the x argument
+
+    (Boolean) y - the y argument
+
+    (kword1) keyword - 1
+
+    (kword2) keyword - 2
+
+
+

data/spec/templates/helpers/base_helper_spec.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+# frozen_string_literal: true
 
-describe YARD::Templates::Helpers::BaseHelper do
+RSpec.describe YARD::Templates::Helpers::BaseHelper do
   include YARD::Templates::Helpers::BaseHelper
 
   describe "#run_verifier" do
@@ -97,7 +97,7 @@ describe YARD::Templates::Helpers::BaseHelper do
 
     it "passes off to #link_url if argument is recognized as a URL" do
       url = "http://yardoc.org/"
-      expect(self).to receive(:link_url).with(url, nil, {:target => '_parent'})
+      expect(self).to receive(:link_url).with(url, nil, :target => '_parent')
       linkify url
     end
 
@@ -142,13 +142,13 @@ describe YARD::Templates::Helpers::BaseHelper do
   describe "#format_object_type" do
     it "returns Exception if type is Exception" do
       obj = double(:object, :is_exception? => true)
-      allow(obj).to receive(:is_a?) { |arg| arg == YARD::CodeObjects::ClassObject }
+      allow(obj).to receive(:is_a?) {|arg| arg == YARD::CodeObjects::ClassObject }
       expect(format_object_type(obj)).to eq "Exception"
     end
 
     it "returns Class if type is Class" do
       obj = double(:object, :is_exception? => false)
-      allow(obj).to receive(:is_a?) { |arg| arg == YARD::CodeObjects::ClassObject }
+      allow(obj).to receive(:is_a?) {|arg| arg == YARD::CodeObjects::ClassObject }
       expect(format_object_type(obj)).to eq "Class"
     end
 

data/spec/templates/helpers/html_helper_spec.rb

@@ -1,8 +1,8 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+# frozen_string_literal: true
 require File.dirname(__FILE__) + "/shared_signature_examples"
 require 'ostruct'
 
-describe YARD::Templates::Helpers::HtmlHelper do
+RSpec.describe YARD::Templates::Helpers::HtmlHelper do
   include YARD::Templates::Helpers::BaseHelper
   include YARD::Templates::Helpers::HtmlHelper
   include YARD::Templates::Helpers::MethodHelper
@@ -43,7 +43,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
 
     it "takes file encoding if there is a file" do
-      @file = OpenStruct.new(:contents => 'foo'.force_encoding('sjis'))
+      @file = OpenStruct.new(:contents => String.new('foo').force_encoding('sjis'))
       # not the correct charset name, but good enough
       expect(['Shift_JIS', 'Windows-31J']).to include(charset)
     end if YARD.ruby19?
@@ -81,7 +81,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
       expect(format_types(["String", "Symbol"], false)).to eq "<tt>String</tt>, <tt>Symbol</tt>"
     end
 
-    { "String" => [["String"],
+    {"String" => [["String"],
         "<tt><a href=''>String</a></tt>"],
       "A::B::C" => [["A::B::C"],
         "<tt><a href=''>A::B::C</a></tt>"],
@@ -90,9 +90,8 @@ describe YARD::Templates::Helpers::HtmlHelper do
       "Array<String, Symbol>" => [["Array", "String", "Symbol"],
         "<tt><a href=''>Array</a>&lt;<a href=''>String</a>, <a href=''>Symbol</a>&gt;</tt>"],
       "Array<{String => Array<Symbol>}>" => [["Array", "String", "Array", "Symbol"],
-        "<tt><a href=''>Array</a>&lt;{<a href=''>String</a> =&gt; " +
-        "<a href=''>Array</a>&lt;<a href=''>Symbol</a>&gt;}&gt;</tt>"]
-    }.each do |text, values|
+        "<tt><a href=''>Array</a>&lt;{<a href=''>String</a> =&gt; " \
+          "<a href=''>Array</a>&lt;<a href=''>Symbol</a>&gt;}&gt;</tt>"]}.each do |text, values|
       it "links all classes in #{text}" do
         if text.count('<') > 0
           expect(self).to receive(:h).with('<').at_least(text.count('<')).times.and_return("&lt;")
@@ -119,9 +118,11 @@ describe YARD::Templates::Helpers::HtmlHelper do
 
     it "handles various encodings" do
       allow(self).to receive(:object).and_return(Registry.root)
-      text = "\xB0\xB1"
+      text = String.new("\xB0\xB1")
       if defined?(Encoding)
-        Encoding.default_internal = 'utf-8'
+        utf8 = Encoding.find('utf-8')
+
+        Encoding.default_internal = utf8 unless Encoding.default_internal == utf8
         text = text.force_encoding('binary')
       end
       htmlify(text, :text)
@@ -141,7 +142,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
 
     it "highlights ruby if markup is :ruby" do
-      expect(htmlify("class Foo; end", :ruby)).to match /\A<pre class="code ruby"><span/
+      expect(htmlify("class Foo; end", :ruby)).to match(/\A<pre class="code ruby"><span/)
     end
 
     it "includes file and htmlifies it" do
@@ -165,7 +166,8 @@ describe YARD::Templates::Helpers::HtmlHelper do
         end
       end
       expect(htmlify('http://example.com', :markdown).chomp.gsub('&#47;', '/')).to eq(
-        '<p><a href="http://example.com">http://example.com</a></p>')
+        '<p><a href="http://example.com">http://example.com</a></p>'
+      )
     end
 
     it "does not autolink URLs inside of {} (markdown specific)" do
@@ -173,15 +175,17 @@ describe YARD::Templates::Helpers::HtmlHelper do
         pending 'This test depends on markdown' unless markup_class(:markdown)
       end
       expect(htmlify('{http://example.com Title}', :markdown).chomp).to match(
-        %r{<p><a href="http://example.com".*>Title</a></p>})
+        %r{<p><a href="http://example.com".*>Title</a></p>}
+      )
       expect(htmlify('{http://example.com}', :markdown).chomp).to match(
-        %r{<p><a href="http://example.com".*>http://example.com</a></p>})
+        %r{<p><a href="http://example.com".*>http://example.com</a></p>}
+      )
     end
 
     it "creates tables (markdown specific)" do
       log.enter_level(Logger::FATAL) do
         unless markup_class(:markdown).to_s == "RedcarpetCompat"
-          skip "This test depends on a markdown engine that supports tables"
+          pending "This test depends on a markdown engine that supports tables"
         end
       end
 
@@ -193,7 +197,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
       EOF
 
       html = htmlify(markdown, :markdown)
-      expect(html).to match %r{<table>}
+      expect(html).to match(/<table>/)
       expect(html).to match %r{<th>City</th>}
       expect(html).to match %r{<td>NC</td>}
     end
@@ -235,11 +239,9 @@ describe YARD::Templates::Helpers::HtmlHelper do
         end
       eof
       obj = Registry.at('Foo::Baz#a').tag(:overload)
-      foobar = Registry.at('Foo::Bar')
-      foobaz = Registry.at('Foo::Baz')
       allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
       allow(self).to receive(:object).and_return(obj)
-      expect(link_object("Bar#a")).to match %r{href="Bar.html#a-instance_method"}
+      expect(link_object("Bar#a")).to match(/href="Bar.html#a-instance_method"/)
     end
 
     it "uses relative path in title" do
@@ -255,7 +257,6 @@ describe YARD::Templates::Helpers::HtmlHelper do
       CodeObjects::ClassObject.new(P('YARD'), :Bar)
       allow(Registry.at('YARD::Bar')).to receive(:title).and_return('TITLE!')
       allow(self).to receive(:object).and_return(Registry.at('YARD::Bar'))
-      serializer = Serializers::FileSystemSerializer.new
       allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
       expect(link_object("Bar")).to match %r{>TITLE!</a>}
     end
@@ -270,7 +271,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
 
     it "uses Klass.foo when linking to class method in current namespace" do
       root = CodeObjects::ModuleObject.new(:root, :Klass)
-      obj = CodeObjects::MethodObject.new(root, :foo, :class)
+      CodeObjects::MethodObject.new(root, :foo, :class)
       allow(self).to receive(:object).and_return(root)
       allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
       expect(link_object("foo")).to match %r{>Klass.foo</a>}
@@ -286,7 +287,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
       obj = Registry.at('Array#&')
       allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
       allow(self).to receive(:object).and_return(obj)
-      expect(link_object("Array#&")).to match %r{title="Array#&amp; \(method\)"}
+      expect(link_object("Array#&")).to match(/title="Array#&amp; \(method\)"/)
     end
   end
 
@@ -351,8 +352,9 @@ describe YARD::Templates::Helpers::HtmlHelper do
   describe "#resolve_links" do
     def parse_link(link)
       results = {}
-      link =~ /<a (.+?)>(.+?)<\/a>/m
-      params, results[:inner_text] = $1, $2
+      link =~ %r{<a (.+?)>(.+?)</a>}m
+      params = $1
+      results[:inner_text] = $2
       params.scan(/\s*(\S+?)=['"](.+?)['"]\s*/).each do |key, value|
         results[key.to_sym] = value.gsub(/^["'](.+)["']$/, '\1')
       end
@@ -375,46 +377,46 @@ describe YARD::Templates::Helpers::HtmlHelper do
       allow(self).to receive(:serializer).and_return Serializers::FileSystemSerializer.new
       allow(self).to receive(:object).and_return Registry.root
 
-      expect(parse_link(resolve_links("{file:TEST.txt#abc}"))).to eq({
+      expect(parse_link(resolve_links("{file:TEST.txt#abc}"))).to eq(
         :inner_text => "TEST",
         :title => "TEST",
         :href => "file.TEST.html#abc"
-      })
-      expect(parse_link(resolve_links("{file:TEST.txt title}"))).to eq({
+      )
+      expect(parse_link(resolve_links("{file:TEST.txt title}"))).to eq(
         :inner_text => "title",
         :title => "title",
         :href => "file.TEST.html"
-      })
+      )
     end
 
     it "creates regular links with http:// or https:// prefixes" do
-      expect(parse_link(resolve_links("{http://example.com}"))).to eq({
+      expect(parse_link(resolve_links("{http://example.com}"))).to eq(
         :inner_text => "http://example.com",
         :target => "_parent",
         :href => "http://example.com",
         :title => "http://example.com"
-      })
-      expect(parse_link(resolve_links("{http://example.com title}"))).to eq({
+      )
+      expect(parse_link(resolve_links("{http://example.com title}"))).to eq(
         :inner_text => "title",
         :target => "_parent",
         :href => "http://example.com",
         :title => "title"
-      })
+      )
     end
 
     it "creates mailto links with mailto: prefixes" do
-      expect(parse_link(resolve_links('{mailto:joanna@example.com}'))).to eq({
+      expect(parse_link(resolve_links('{mailto:joanna@example.com}'))).to eq(
         :inner_text => 'mailto:joanna@example.com',
         :target => '_parent',
         :href => 'mailto:joanna@example.com',
         :title => 'mailto:joanna@example.com'
-      })
-      expect(parse_link(resolve_links('{mailto:steve@example.com Steve}'))).to eq({
+      )
+      expect(parse_link(resolve_links('{mailto:steve@example.com Steve}'))).to eq(
         :inner_text => 'Steve',
         :target => '_parent',
         :href => 'mailto:steve@example.com',
         :title => 'Steve'
-      })
+      )
     end
 
     it "ignores {links} that begin with |...|" do
@@ -444,12 +446,12 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
 
     it "resolves link with newline in title-part" do
-      expect(parse_link(resolve_links("{http://example.com foo\nbar}"))).to eq({
+      expect(parse_link(resolve_links("{http://example.com foo\nbar}"))).to eq(
         :inner_text => "foo bar",
         :target => "_parent",
         :href => "http://example.com",
         :title => "foo bar"
-      })
+      )
     end
 
     it "resolves links to methods whose names have been escaped" do
@@ -464,8 +466,9 @@ describe YARD::Templates::Helpers::HtmlHelper do
         class MyObject; end
       eof
       logger = double(:log)
-      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':2: Cannot resolve link to InvalidObject from text:")
-      expect(logger).to receive(:warn).ordered.with("...{InvalidObject}")
+      expect(logger).to receive(:warn).ordered.with(
+        "In file `(stdin)':2: Cannot resolve link to InvalidObject from text:\n\t...{InvalidObject}"
+      )
       allow(self).to receive(:log).and_return(logger)
       allow(self).to receive(:object).and_return(Registry.at('MyObject'))
       resolve_links(object.docstring)
@@ -480,14 +483,10 @@ describe YARD::Templates::Helpers::HtmlHelper do
         class MyObject; end
       eof
       logger = double(:log)
-      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':1: Cannot resolve link to InvalidObject1 from text:")
-      expect(logger).to receive(:warn).ordered.with("{InvalidObject1}...")
-      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':2: Cannot resolve link to InvalidObject2 from text:")
-      expect(logger).to receive(:warn).ordered.with("...{InvalidObject2}")
-      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':3: Cannot resolve link to InvalidObject3 from text:")
-      expect(logger).to receive(:warn).ordered.with("...{InvalidObject3}...")
-      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':4: Cannot resolve link to InvalidObject4 from text:")
-      expect(logger).to receive(:warn).ordered.with("{InvalidObject4}")
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':1: Cannot resolve link to InvalidObject1 from text:\n\t{InvalidObject1}...")
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':2: Cannot resolve link to InvalidObject2 from text:\n\t...{InvalidObject2}")
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':3: Cannot resolve link to InvalidObject3 from text:\n\t...{InvalidObject3}...")
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':4: Cannot resolve link to InvalidObject4 from text:\n\t{InvalidObject4}")
       allow(self).to receive(:log).and_return(logger)
       allow(self).to receive(:object).and_return(Registry.at('MyObject'))
       resolve_links(object.docstring)
@@ -496,8 +495,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
     it "warns about missing reference for file template (no object)" do
       @file = CodeObjects::ExtraFileObject.new('myfile.txt', '')
       logger = double(:log)
-      expect(logger).to receive(:warn).ordered.with("In file `myfile.txt':3: Cannot resolve link to InvalidObject from text:")
-      expect(logger).to receive(:warn).ordered.with("...{InvalidObject Some Title}")
+      expect(logger).to receive(:warn).ordered.with("In file `myfile.txt':3: Cannot resolve link to InvalidObject from text:\n\t...{InvalidObject Some Title}")
       allow(self).to receive(:log).and_return(logger)
       allow(self).to receive(:object).and_return(Registry.root)
       resolve_links(<<-eof)
@@ -530,7 +528,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
       }
     end
 
-    def format_types(types, brackets = false) types.join(", ") end
+    def format_types(types, _brackets = false) types.join(", ") end
     def signature(obj, link = false) super(obj, link).strip end
 
     it_should_behave_like "signature"
@@ -547,7 +545,8 @@ describe YARD::Templates::Helpers::HtmlHelper do
       allow(self).to receive(:serializer).and_return(serializer)
       allow(self).to receive(:object).and_return(Registry.at('Foo'))
       expect(signature(Registry.at('Foo#foo').tag(:overload), true)).to eq(
-        "<a href=\"#foo-instance_method\" title=\"#bar (instance method)\">#<strong>bar</strong>(a, b, c)  </a>")
+        "<a href=\"#foo-instance_method\" title=\"#bar (instance method)\">#<strong>bar</strong>(a, b, c)  </a>"
+      )
     end
   end
 
@@ -572,18 +571,20 @@ describe YARD::Templates::Helpers::HtmlHelper do
 
     it "calls #html_syntax_highlight_NAME if there's an object with a #source_type" do
       subject.object = OpenStruct.new(:source_type => :NAME)
-      expect(subject).to receive(:html_markup_html) { |text| text }
+      expect(subject).to receive(:html_markup_html) {|text| text }
       expect(subject).to receive(:html_syntax_highlight_NAME).and_return("foobar")
       expect(subject.htmlify('<pre><code>def x; end</code></pre>', :html)).to eq(
-        '<pre class="code NAME"><code class="NAME">foobar</code></pre>')
+        '<pre class="code NAME"><code class="NAME">foobar</code></pre>'
+      )
     end
 
     it "adds !!!LANG to className in outputted pre tag" do
       subject.object = OpenStruct.new(:source_type => :LANG)
-      expect(subject).to receive(:html_markup_html) { |text| text }
+      expect(subject).to receive(:html_markup_html) {|text| text }
       expect(subject).to receive(:html_syntax_highlight_LANG).and_return("foobar")
       expect(subject.htmlify("<pre><code>!!!LANG\ndef x; end</code></pre>", :html)).to eq(
-        '<pre class="code LANG"><code class="LANG">foobar</code></pre>')
+        '<pre class="code LANG"><code class="LANG">foobar</code></pre>'
+      )
     end
 
     it "calls html_syntax_highlight_NAME if source starts with !!!NAME" do
@@ -592,7 +593,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
         !!!NAME
         def x; end
       eof
-      )).to eq "foobar"
+                                          )).to eq "foobar"
     end
 
     it "does not highlight if highlight option is false" do
@@ -602,7 +603,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
 
     it "does not highlight if there is no highlight method specified by !!!NAME" do
-      def subject.respond_to?(method, include_all=false)
+      def subject.respond_to?(method, include_all = false)
         return false if method == 'html_syntax_highlight_NAME'
         super
       end
@@ -623,17 +624,20 @@ describe YARD::Templates::Helpers::HtmlHelper do
 
     it "doesn't escape code snippets twice" do
       expect(subject.htmlify('<pre lang="foo"><code>{"foo" => 1}</code></pre>', :html)).to eq(
-        '<pre class="code foo"><code class="foo">{&quot;foo&quot; =&gt; 1}</code></pre>')
+        '<pre class="code foo"><code class="foo">{&quot;foo&quot; =&gt; 1}</code></pre>'
+      )
     end
 
     it "highlights source when matching a pre lang= tag" do
       expect(subject.htmlify('<pre lang="foo"><code>x = 1</code></pre>', :html)).to eq(
-        '<pre class="code foo"><code class="foo">x = 1</code></pre>')
+        '<pre class="code foo"><code class="foo">x = 1</code></pre>'
+      )
     end
 
     it "highlights source when matching a code class= tag" do
       expect(subject.htmlify('<pre><code class="foo">x = 1</code></pre>', :html)).to eq(
-        '<pre class="code foo"><code class="foo">x = 1</code></pre>')
+        '<pre class="code foo"><code class="foo">x = 1</code></pre>'
+      )
     end
   end