yard 0.9.18 → 0.9.23

data/spec/handlers/examples/private_constant_handler_001.rb.txt

@@ -1,8 +1,8 @@
-module A
-  Foo = 1
-  class B; end
-  module C; end
-  module D; end
-
-  private_constant :Foo, 'B', C
-end
+module A
+  Foo = 1
+  class B; end
+  module C; end
+  module D; end
+
+  private_constant :Foo, 'B', C
+end

data/spec/handlers/examples/process_handler_001.rb.txt

@@ -1,11 +1,11 @@
-class A < NotHandler
-  process { hello }
-end
-
-class B < YARD::Handlers::Ruby::Base
-  process { test }
-end
-
-class C < YARD::Handlers::Ruby::Legacy::Base
-  process do test end
-end
+class A < NotHandler
+  process { hello }
+end
+
+class B < YARD::Handlers::Ruby::Base
+  process { test }
+end
+
+class C < YARD::Handlers::Ruby::Legacy::Base
+  process do test end
+end

data/spec/handlers/examples/visibility_handler_001.rb.txt

@@ -1,36 +1,36 @@
-class Testing
-  def pub; end
-
-  private
-
-  def priv; end
-  def notpriv; end
-  def notpriv2; end
-  def notpriv?; end
-
-  protected
-
-  def prot; end
-
-  public
-
-  def pub2; end
-
-  protected :notpriv, 'notpriv2', :notpriv?
-
-  private name
-  private *argument
-  private *(method_call)
-
-  def Foo; end
-  private :Foo
-
-  private def decpriv; end
-
-  private
-
-  class Bar; end
-  module Baz; end
-
-  private :not_exist!
+class Testing
+  def pub; end
+
+  private
+
+  def priv; end
+  def notpriv; end
+  def notpriv2; end
+  def notpriv?; end
+
+  protected
+
+  def prot; end
+
+  public
+
+  def pub2; end
+
+  protected :notpriv, 'notpriv2', :notpriv?
+
+  private name
+  private *argument
+  private *(method_call)
+
+  def Foo; end
+  private :Foo
+
+  private def decpriv; end
+
+  private
+
+  class Bar; end
+  module Baz; end
+
+  private :not_exist!
 end

data/spec/handlers/examples/yield_handler_001.rb.txt

@@ -1,54 +1,54 @@
-class Testing
-  # Ignore yields outside methods
-  yield x, y, z
-
-  # Should document this
-  def mymethod
-    yield
-  end
-
-  # Has yield and yieldparam documentation
-  # @yield [a, b] Blah
-  # @yieldparam a Blah
-  # @yieldparam b Blah
-  def mymethod2
-    yield(b, a) # Yield something else
-  end
-
-  # Has yield documentation only
-  # @yield [a, b]
-  def mymethod3
-    yield self # Should not be changed
-  end
-
-  # Has yieldparam documentation only
-  # @yieldparam _self BLAH
-  def mymethod4
-    yield self
-  end
-
-  # Some weird possibilities..
-  # Document it all.
-
-
-  def mymethod5
-    yield :a, b, self, File.read('file', 'w'), CONSTANT if x == 2
-  end
-
-  def mymethod6
-    yield(b, a)
-  end
-
-  def mymethod7
-    yield a
-    yield b
-  end
-
-  def mymethod8
-    yield self
-  end
-
-  def mymethod9
-    yield super
-  end
-end
+class Testing
+  # Ignore yields outside methods
+  yield x, y, z
+
+  # Should document this
+  def mymethod
+    yield
+  end
+
+  # Has yield and yieldparam documentation
+  # @yield [a, b] Blah
+  # @yieldparam a Blah
+  # @yieldparam b Blah
+  def mymethod2
+    yield(b, a) # Yield something else
+  end
+
+  # Has yield documentation only
+  # @yield [a, b]
+  def mymethod3
+    yield self # Should not be changed
+  end
+
+  # Has yieldparam documentation only
+  # @yieldparam _self BLAH
+  def mymethod4
+    yield self
+  end
+
+  # Some weird possibilities..
+  # Document it all.
+
+
+  def mymethod5
+    yield :a, b, self, File.read('file', 'w'), CONSTANT if x == 2
+  end
+
+  def mymethod6
+    yield(b, a)
+  end
+
+  def mymethod7
+    yield a
+    yield b
+  end
+
+  def mymethod8
+    yield self
+  end
+
+  def mymethod9
+    yield super
+  end
+end

data/spec/handlers/exception_handler_spec.rb

@@ -1,49 +1,49 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandler" do
-  before(:all) { parse_file :exception_handler_001, __FILE__ }
-
-  it "does not document an exception outside of a method" do
-    expect(P('Testing').has_tag?(:raise)).to be false
-  end
-
-  it "documents a valid raise" do
-    expect(P('Testing#mymethod').tag(:raise).types).to eq ['ArgumentError']
-  end
-
-  it "only documents non-dynamic raises" do
-    expect(P('Testing#mymethod2').tag(:raise)).to be nil
-    expect(P('Testing#mymethod6').tag(:raise)).to be nil
-    expect(P('Testing#mymethod7').tag(:raise)).to be nil
-  end
-
-  it "treats ConstantName.new as a valid exception class" do
-    expect(P('Testing#mymethod8').tag(:raise).types).to eq ['ExceptionClass']
-  end
-
-  it "does not document a method with an existing @raise tag" do
-    expect(P('Testing#mymethod3').tag(:raise).types).to eq ['A']
-  end
-
-  it "only documents the first raise message of a method (limitation of exception handler)" do
-    expect(P('Testing#mymethod4').tag(:raise).types).to eq ['A']
-  end
-
-  it "handles complex class names" do
-    expect(P('Testing#mymethod5').tag(:raise).types).to eq ['YARD::Parser::UndocumentableError']
-  end
-
-  it "ignores any raise calls on a receiver" do
-    expect(P('Testing#mymethod9').tag(:raise)).to be nil
-  end
-
-  it "handles raise expressions that are method calls" do
-    expect(P('Testing#mymethod10').tag(:raise)).to be nil
-    expect(P('Testing#mymethod11').tag(:raise)).to be nil
-  end
-
-  it "ignores empty raise call" do
-    expect(P('Testing#mymethod12').tag(:raise)).to be nil
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandler" do
+  before(:all) { parse_file :exception_handler_001, __FILE__ }
+
+  it "does not document an exception outside of a method" do
+    expect(P('Testing').has_tag?(:raise)).to be false
+  end
+
+  it "documents a valid raise" do
+    expect(P('Testing#mymethod').tag(:raise).types).to eq ['ArgumentError']
+  end
+
+  it "only documents non-dynamic raises" do
+    expect(P('Testing#mymethod2').tag(:raise)).to be nil
+    expect(P('Testing#mymethod6').tag(:raise)).to be nil
+    expect(P('Testing#mymethod7').tag(:raise)).to be nil
+  end
+
+  it "treats ConstantName.new as a valid exception class" do
+    expect(P('Testing#mymethod8').tag(:raise).types).to eq ['ExceptionClass']
+  end
+
+  it "does not document a method with an existing @raise tag" do
+    expect(P('Testing#mymethod3').tag(:raise).types).to eq ['A']
+  end
+
+  it "only documents the first raise message of a method (limitation of exception handler)" do
+    expect(P('Testing#mymethod4').tag(:raise).types).to eq ['A']
+  end
+
+  it "handles complex class names" do
+    expect(P('Testing#mymethod5').tag(:raise).types).to eq ['YARD::Parser::UndocumentableError']
+  end
+
+  it "ignores any raise calls on a receiver" do
+    expect(P('Testing#mymethod9').tag(:raise)).to be nil
+  end
+
+  it "handles raise expressions that are method calls" do
+    expect(P('Testing#mymethod10').tag(:raise)).to be nil
+    expect(P('Testing#mymethod11').tag(:raise)).to be nil
+  end
+
+  it "ignores empty raise call" do
+    expect(P('Testing#mymethod12').tag(:raise)).to be nil
+  end
+end

data/spec/handlers/extend_handler_spec.rb

@@ -1,24 +1,28 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExtendHandler" do
-  before(:all) { parse_file :extend_handler_001, __FILE__ }
-
-  it "includes modules at class scope" do
-    expect(Registry.at(:B).class_mixins).to eq [P(:A)]
-    expect(Registry.at(:B).instance_mixins).to be_empty
-  end
-
-  it "handles a module extending itself" do
-    expect(Registry.at(:C).class_mixins).to eq [P(:C)]
-    expect(Registry.at(:C).instance_mixins).to be_empty
-  end
-
-  it "extends module with correct namespace" do
-    expect(Registry.at('Q::R::S').class_mixins.first.path).to eq 'A'
-  end
-
-  it "does not allow extending self if object is a class" do
-    undoc_error "class Foo; extend self; end"
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExtendHandler" do
+  before(:all) { parse_file :extend_handler_001, __FILE__ }
+
+  it "includes modules at class scope" do
+    expect(Registry.at(:B).class_mixins).to eq [P(:A)]
+    expect(Registry.at(:B).instance_mixins).to be_empty
+  end
+
+  it "handles a module extending itself" do
+    expect(Registry.at(:C).class_mixins).to eq [P(:C)]
+    expect(Registry.at(:C).instance_mixins).to be_empty
+  end
+
+  it "extends module with correct namespace" do
+    expect(Registry.at('Q::R::S').class_mixins.first.path).to eq 'A'
+  end
+
+  it "does not allow extending self if object is a class" do
+    undoc_error "class Foo; extend self; end"
+  end
+
+  it "adds mixins from extend calls to constants" do
+    expect(P('FromConstant').class_mixins).to eq [P('A')]
+  end
+end

data/spec/handlers/legacy_base_spec.rb

@@ -1,128 +1,128 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-include Parser::Ruby::Legacy
-
-RSpec.describe YARD::Handlers::Ruby::Legacy::Base, "#tokval" do
-  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
-
-  def tokval(code, *types)
-    @handler.send(:tokval, TokenList.new(code).first, *types)
-  end
-
-  it "returns the String's value without quotes" do
-    expect(tokval('"hello"')).to eq "hello"
-  end
-
-  it "does not allow interpolated strings with TkSTRING" do
-    expect(tokval('"#{c}"', RubyToken::TkSTRING)).to be nil
-  end
-
-  it "returns a Symbol's value as a String (as if it was done via :name.to_sym)" do
-    expect(tokval(':sym')).to eq :sym
-  end
-
-  it "returns nil for any non accepted type" do
-    expect(tokval('identifier')).to be nil
-    expect(tokval(':sym', RubyToken::TkId)).to be nil
-  end
-
-  it "accepts TkVal tokens by default" do
-    expect(tokval('2.5')).to eq 2.5
-    expect(tokval(':sym')).to eq :sym
-  end
-
-  it "accepts any ID type if TkId is set" do
-    expect(tokval('variable', RubyToken::TkId)).to eq "variable"
-    expect(tokval('CONSTANT', RubyToken::TkId)).to eq "CONSTANT"
-  end
-
-  it "allows extra token types to be accepted" do
-    expect(tokval('2.5', RubyToken::TkFLOAT)).to eq 2.5
-    expect(tokval('2', RubyToken::TkFLOAT)).to be nil
-    expect(tokval(':symbol', RubyToken::TkFLOAT)).to be nil
-  end
-
-  it "allows :string for any string type" do
-    expect(tokval('"hello"', :string)).to eq "hello"
-    expect(tokval('"#{c}"', :string)).to eq '#{c}'
-  end
-
-  it "does not include interpolated strings when using :attr" do
-    expect(tokval('"#{c}"', :attr)).to be nil
-  end
-
-  it "allows any number type with :number" do
-    expect(tokval('2.5', :number)).to eq 2.5
-    expect(tokval('2', :number)).to eq 2
-  end
-
-  it "allows method names with :identifier" do
-    expect(tokval('methodname?', :identifier)).to eq "methodname?"
-  end
-
-  # it "obeys documentation expectations" do docspec end
-end
-
-RSpec.describe YARD::Handlers::Base, "#tokval_list" do
-  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
-
-  def tokval_list(code, *types)
-    @handler.send(:tokval_list, TokenList.new(code), *types)
-  end
-
-  it "returns the list of tokvalues" do
-    expect(tokval_list(":a, :b, \"\#{c}\", 'd'", :attr)).to eq [:a, :b, 'd']
-    expect(tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d",
-      RubyToken::Token)).to eq [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
-  end
-
-  it "tries to skip any invalid tokens" do
-    expect(tokval_list(":a, :b, \"\#{c}\", :d", :attr)).to eq [:a, :b, :d]
-    expect(tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr)).to eq [:a, :b, :d]
-    expect(tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2",
-      RubyToken::TkId)).to eq ['CONST1', 'identifier', 'CONST2']
-  end
-
-  it "ignores a token if another invalid token is read before a comma" do
-    expect(tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL)).to eq [:a, :c]
-  end
-
-  it "stops on most keywords" do
-    expect(tokval_list(':a rescue :x == 5', RubyToken::Token)).to eq [:a]
-  end
-
-  it "handles ignore parentheses that begin the token list" do
-    expect(tokval_list('(:a, :b, :c)', :attr)).to eq [:a, :b, :c]
-  end
-
-  it "ends when a closing parenthesis was found" do
-    expect(tokval_list(':a, :b, :c), :d', :attr)).to eq [:a, :b, :c]
-  end
-
-  it "ignores parentheses around items in a list" do
-    expect(tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr)).to eq [:a, :b, :c, :e, :g]
-    expect(tokval_list(':a, (((:f)))', :attr)).to eq [:a, :f]
-    expect(tokval_list(':a, ([:f]), :c)', RubyToken::Token)).to eq [:a, '[:f]', :c]
-  end
-
-  it "does not stop on a true/false/self keyword (cannot handle nil)" do
-    expect(tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ',
-      RubyToken::Token)).to eq [:a, true, :b, 'self', false, :c, 'File', 'super']
-  end
-
-  it "ignores invalid commas" do
-    expect(tokval_list(":a, :b, , :d")).to eq [:a, :b, :d]
-  end
-
-  it "returns an empty list if no matches were found" do
-    expect(tokval_list('attr_accessor :x')).to eq []
-  end
-
-  it "treats {} as a valid value" do
-    # FIXME: tokval_list destroys extra spaces surrounding the '=' in
-    #        this situation. This is technically a design flaw of the
-    #        tokval parser, but this is now the expected behaviour.
-    expect(tokval_list("opts = {}", :all)).to eq ["opts={}"]
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+include Parser::Ruby::Legacy
+
+RSpec.describe YARD::Handlers::Ruby::Legacy::Base, "#tokval" do
+  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
+
+  def tokval(code, *types)
+    @handler.send(:tokval, TokenList.new(code).first, *types)
+  end
+
+  it "returns the String's value without quotes" do
+    expect(tokval('"hello"')).to eq "hello"
+  end
+
+  it "does not allow interpolated strings with TkSTRING" do
+    expect(tokval('"#{c}"', RubyToken::TkSTRING)).to be nil
+  end
+
+  it "returns a Symbol's value as a String (as if it was done via :name.to_sym)" do
+    expect(tokval(':sym')).to eq :sym
+  end
+
+  it "returns nil for any non accepted type" do
+    expect(tokval('identifier')).to be nil
+    expect(tokval(':sym', RubyToken::TkId)).to be nil
+  end
+
+  it "accepts TkVal tokens by default" do
+    expect(tokval('2.5')).to eq 2.5
+    expect(tokval(':sym')).to eq :sym
+  end
+
+  it "accepts any ID type if TkId is set" do
+    expect(tokval('variable', RubyToken::TkId)).to eq "variable"
+    expect(tokval('CONSTANT', RubyToken::TkId)).to eq "CONSTANT"
+  end
+
+  it "allows extra token types to be accepted" do
+    expect(tokval('2.5', RubyToken::TkFLOAT)).to eq 2.5
+    expect(tokval('2', RubyToken::TkFLOAT)).to be nil
+    expect(tokval(':symbol', RubyToken::TkFLOAT)).to be nil
+  end
+
+  it "allows :string for any string type" do
+    expect(tokval('"hello"', :string)).to eq "hello"
+    expect(tokval('"#{c}"', :string)).to eq '#{c}'
+  end
+
+  it "does not include interpolated strings when using :attr" do
+    expect(tokval('"#{c}"', :attr)).to be nil
+  end
+
+  it "allows any number type with :number" do
+    expect(tokval('2.5', :number)).to eq 2.5
+    expect(tokval('2', :number)).to eq 2
+  end
+
+  it "allows method names with :identifier" do
+    expect(tokval('methodname?', :identifier)).to eq "methodname?"
+  end
+
+  # it "obeys documentation expectations" do docspec end
+end
+
+RSpec.describe YARD::Handlers::Base, "#tokval_list" do
+  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
+
+  def tokval_list(code, *types)
+    @handler.send(:tokval_list, TokenList.new(code), *types)
+  end
+
+  it "returns the list of tokvalues" do
+    expect(tokval_list(":a, :b, \"\#{c}\", 'd'", :attr)).to eq [:a, :b, 'd']
+    expect(tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d",
+      RubyToken::Token)).to eq [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
+  end
+
+  it "tries to skip any invalid tokens" do
+    expect(tokval_list(":a, :b, \"\#{c}\", :d", :attr)).to eq [:a, :b, :d]
+    expect(tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr)).to eq [:a, :b, :d]
+    expect(tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2",
+      RubyToken::TkId)).to eq ['CONST1', 'identifier', 'CONST2']
+  end
+
+  it "ignores a token if another invalid token is read before a comma" do
+    expect(tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL)).to eq [:a, :c]
+  end
+
+  it "stops on most keywords" do
+    expect(tokval_list(':a rescue :x == 5', RubyToken::Token)).to eq [:a]
+  end
+
+  it "handles ignore parentheses that begin the token list" do
+    expect(tokval_list('(:a, :b, :c)', :attr)).to eq [:a, :b, :c]
+  end
+
+  it "ends when a closing parenthesis was found" do
+    expect(tokval_list(':a, :b, :c), :d', :attr)).to eq [:a, :b, :c]
+  end
+
+  it "ignores parentheses around items in a list" do
+    expect(tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr)).to eq [:a, :b, :c, :e, :g]
+    expect(tokval_list(':a, (((:f)))', :attr)).to eq [:a, :f]
+    expect(tokval_list(':a, ([:f]), :c)', RubyToken::Token)).to eq [:a, '[:f]', :c]
+  end
+
+  it "does not stop on a true/false/self keyword (cannot handle nil)" do
+    expect(tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ',
+      RubyToken::Token)).to eq [:a, true, :b, 'self', false, :c, 'File', 'super']
+  end
+
+  it "ignores invalid commas" do
+    expect(tokval_list(":a, :b, , :d")).to eq [:a, :b, :d]
+  end
+
+  it "returns an empty list if no matches were found" do
+    expect(tokval_list('attr_accessor :x')).to eq []
+  end
+
+  it "treats {} as a valid value" do
+    # FIXME: tokval_list destroys extra spaces surrounding the '=' in
+    #        this situation. This is technically a design flaw of the
+    #        tokval parser, but this is now the expected behaviour.
+    expect(tokval_list("opts = {}", :all)).to eq ["opts={}"]
+  end
+end