yard 0.9.18 → 0.9.23

data/spec/handlers/ruby/base_spec.rb

@@ -1,95 +1,95 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
-  include YARD::Parser::Ruby
-  YARD::Parser::Ruby::AstNode # rubocop:disable Lint/Void
-
-  before do
-    allow(Handlers::Ruby::Base).to receive(:inherited)
-    @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
-  end
-
-  after(:all) do
-    Handlers::Base.clear_subclasses
-  end
-
-  def valid(handler, stmt)
-    expect(@processor.find_handlers(stmt)).to include(handler)
-  end
-
-  def invalid(handler, stmt)
-    expect(@processor.find_handlers(stmt)).not_to include(handler)
-  end
-
-  it "only handles Handlers inherited from Ruby::Base class" do
-    class IgnoredHandler < Handlers::Base
-      handles :list
-    end
-    class NotIgnoredHandler < Handlers::Ruby::Base
-      handles :list
-    end
-    allow(Handlers::Base).to receive(:subclasses).and_return [IgnoredHandler, NotIgnoredHandler]
-    expect(@processor.find_handlers(s)).to eq [NotIgnoredHandler]
-  end
-
-  it "handles string input (matches AstNode#source)" do
-    class StringHandler < Handlers::Ruby::Base
-      handles "x"
-    end
-    allow(Handlers::Base).to receive(:subclasses).and_return [StringHandler]
-    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
-    valid StringHandler, ast[0][0][0]
-    invalid StringHandler, ast[0][1]
-  end
-
-  it "handles symbol input (matches AstNode#type)" do
-    class SymbolHandler < Handlers::Ruby::Base
-      handles :myNodeType
-    end
-    allow(Handlers::Base).to receive(:subclasses).and_return [SymbolHandler]
-    valid SymbolHandler, s(:myNodeType, s(1, 2, 3))
-    invalid SymbolHandler, s(:NOTmyNodeType, s(1, 2, 3))
-  end
-
-  it "handles regex input (matches AstNode#source)" do
-    class RegexHandler < Handlers::Ruby::Base
-      handles(/^if x ==/)
-    end
-    allow(Handlers::Base).to receive(:subclasses).and_return [RegexHandler]
-    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
-    valid RegexHandler, ast
-    invalid RegexHandler, ast[0][1]
-  end
-
-  it "handles AstNode input (matches AST literally)" do
-    class ASTHandler < Handlers::Ruby::Base
-      handles s(:vcall, s(:ident, "hello_world"))
-    end
-    allow(Handlers::Base).to receive(:subclasses).and_return [ASTHandler]
-    valid ASTHandler, s(:vcall, s(:ident, "hello_world"))
-    invalid ASTHandler, s(:vcall, s(:ident, "NOTHELLOWORLD"))
-  end
-
-  it "handles #method_call(:methname) on a valid AST" do
-    class MethCallHandler < Handlers::Ruby::Base
-      handles method_call(:meth)
-    end
-    allow(Handlers::Base).to receive(:subclasses).and_return [MethCallHandler]
-    ast = Parser::Ruby::RubyParser.parse(<<-"eof").ast
-      meth                   # 0
-      meth()                 # 1
-      meth(1,2,3)            # 2
-      meth 1,2,3             # 3
-      NotMeth.meth           # 4
-      NotMeth.meth { }       # 5
-      NotMeth.meth do end    # 6
-      NotMeth.meth 1, 2, 3   # 7
-      NotMeth.meth(1, 2, 3)  # 8
-      NotMeth                # 9
-    eof
-    (0..8).each do |i|
-      valid MethCallHandler, ast[i]
-    end
-    invalid MethCallHandler, ast[9]
-  end
-end if HAVE_RIPPER
+# frozen_string_literal: true
+
+RSpec.describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
+  include YARD::Parser::Ruby
+  YARD::Parser::Ruby::AstNode # rubocop:disable Lint/Void
+
+  before do
+    allow(Handlers::Ruby::Base).to receive(:inherited)
+    @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
+  end
+
+  after(:all) do
+    Handlers::Base.clear_subclasses
+  end
+
+  def valid(handler, stmt)
+    expect(@processor.find_handlers(stmt)).to include(handler)
+  end
+
+  def invalid(handler, stmt)
+    expect(@processor.find_handlers(stmt)).not_to include(handler)
+  end
+
+  it "only handles Handlers inherited from Ruby::Base class" do
+    class IgnoredHandler < Handlers::Base
+      handles :list
+    end
+    class NotIgnoredHandler < Handlers::Ruby::Base
+      handles :list
+    end
+    allow(Handlers::Base).to receive(:subclasses).and_return [IgnoredHandler, NotIgnoredHandler]
+    expect(@processor.find_handlers(s)).to eq [NotIgnoredHandler]
+  end
+
+  it "handles string input (matches AstNode#source)" do
+    class StringHandler < Handlers::Ruby::Base
+      handles "x"
+    end
+    allow(Handlers::Base).to receive(:subclasses).and_return [StringHandler]
+    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
+    valid StringHandler, ast[0][0][0]
+    invalid StringHandler, ast[0][1]
+  end
+
+  it "handles symbol input (matches AstNode#type)" do
+    class SymbolHandler < Handlers::Ruby::Base
+      handles :myNodeType
+    end
+    allow(Handlers::Base).to receive(:subclasses).and_return [SymbolHandler]
+    valid SymbolHandler, s(:myNodeType, s(1, 2, 3))
+    invalid SymbolHandler, s(:NOTmyNodeType, s(1, 2, 3))
+  end
+
+  it "handles regex input (matches AstNode#source)" do
+    class RegexHandler < Handlers::Ruby::Base
+      handles(/^if x ==/)
+    end
+    allow(Handlers::Base).to receive(:subclasses).and_return [RegexHandler]
+    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
+    valid RegexHandler, ast
+    invalid RegexHandler, ast[0][1]
+  end
+
+  it "handles AstNode input (matches AST literally)" do
+    class ASTHandler < Handlers::Ruby::Base
+      handles s(:vcall, s(:ident, "hello_world"))
+    end
+    allow(Handlers::Base).to receive(:subclasses).and_return [ASTHandler]
+    valid ASTHandler, s(:vcall, s(:ident, "hello_world"))
+    invalid ASTHandler, s(:vcall, s(:ident, "NOTHELLOWORLD"))
+  end
+
+  it "handles #method_call(:methname) on a valid AST" do
+    class MethCallHandler < Handlers::Ruby::Base
+      handles method_call(:meth)
+    end
+    allow(Handlers::Base).to receive(:subclasses).and_return [MethCallHandler]
+    ast = Parser::Ruby::RubyParser.parse(<<-"eof").ast
+      meth                   # 0
+      meth()                 # 1
+      meth(1,2,3)            # 2
+      meth 1,2,3             # 3
+      NotMeth.meth           # 4
+      NotMeth.meth { }       # 5
+      NotMeth.meth do end    # 6
+      NotMeth.meth 1, 2, 3   # 7
+      NotMeth.meth(1, 2, 3)  # 8
+      NotMeth                # 9
+    eof
+    (0..8).each do |i|
+      valid MethCallHandler, ast[i]
+    end
+    invalid MethCallHandler, ast[9]
+  end
+end if HAVE_RIPPER

data/spec/handlers/ruby/legacy/base_spec.rb

@@ -1,84 +1,84 @@
-# frozen_string_literal: true
-
-include Parser::Ruby::Legacy
-
-RSpec.describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
-  before do
-    allow(Handlers::Ruby::Legacy::Base).to receive(:inherited)
-    if RUBY_VERSION > '1.8.7'
-      allow(Handlers::Ruby::Legacy::MixinHandler).to receive(:inherited) # fixes a Ruby1.9 issue
-    end
-    @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby18))
-  end
-
-  after(:all) do
-    Handlers::Base.clear_subclasses
-  end
-
-  def stmt(string)
-    Statement.new(TokenList.new(string))
-  end
-
-  it "only handles Handlers inherited from Ruby::Legacy::Base class" do
-    class IgnoredHandler < Handlers::Base
-      handles "hello"
-    end
-    class NotIgnoredHandlerLegacy < Handlers::Ruby::Legacy::Base
-      handles "hello"
-    end
-    allow(Handlers::Base).to receive(:subclasses).and_return [IgnoredHandler, NotIgnoredHandlerLegacy]
-    expect(@processor.find_handlers(stmt("hello world"))).to eq [NotIgnoredHandlerLegacy]
-  end
-
-  it "handles a string input" do
-    class TestStringHandler < Handlers::Ruby::Legacy::Base
-      handles "hello"
-    end
-
-    expect(TestStringHandler.handles?(stmt("hello world"))).to be true
-    expect(TestStringHandler.handles?(stmt("nothello world"))).to be false
-  end
-
-  it "handles regex input" do
-    class TestRegexHandler < Handlers::Ruby::Legacy::Base
-      handles(/^nothello$/)
-    end
-
-    expect(TestRegexHandler.handles?(stmt("nothello"))).to be true
-    expect(TestRegexHandler.handles?(stmt("not hello hello"))).to be false
-  end
-
-  it "handles token input" do
-    class TestTokenHandler < Handlers::Ruby::Legacy::Base
-      handles TkMODULE
-    end
-
-    expect(TestTokenHandler.handles?(stmt("module"))).to be true
-    expect(TestTokenHandler.handles?(stmt("if"))).to be false
-  end
-
-  it "parses a do/end or { } block with #parse_block" do
-    class MyBlockHandler < Handlers::Ruby::Legacy::Base
-      handles(/\AmyMethod\b/)
-      def process
-        parse_block(:owner => "test")
-      end
-    end
-
-    class MyBlockInnerHandler < Handlers::Ruby::Legacy::Base
-      handles "inner"
-      def self.reset; @@reached = false end
-      def self.reached?; @@reached ||= false end
-      def process; @@reached = true end
-    end
-
-    allow(Handlers::Base).to receive(:subclasses).and_return [MyBlockHandler, MyBlockInnerHandler]
-    Parser::SourceParser.parser_type = :ruby18
-    Parser::SourceParser.parse_string "myMethod do inner end"
-    expect(MyBlockInnerHandler).to be_reached
-    MyBlockInnerHandler.reset
-    Parser::SourceParser.parse_string "myMethod { inner }"
-    expect(MyBlockInnerHandler).to be_reached
-    Parser::SourceParser.parser_type = :ruby
-  end
-end
+# frozen_string_literal: true
+
+include Parser::Ruby::Legacy
+
+RSpec.describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
+  before do
+    allow(Handlers::Ruby::Legacy::Base).to receive(:inherited)
+    if RUBY_VERSION > '1.8.7'
+      allow(Handlers::Ruby::Legacy::MixinHandler).to receive(:inherited) # fixes a Ruby1.9 issue
+    end
+    @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby18))
+  end
+
+  after(:all) do
+    Handlers::Base.clear_subclasses
+  end
+
+  def stmt(string)
+    Statement.new(TokenList.new(string))
+  end
+
+  it "only handles Handlers inherited from Ruby::Legacy::Base class" do
+    class IgnoredHandler < Handlers::Base
+      handles "hello"
+    end
+    class NotIgnoredHandlerLegacy < Handlers::Ruby::Legacy::Base
+      handles "hello"
+    end
+    allow(Handlers::Base).to receive(:subclasses).and_return [IgnoredHandler, NotIgnoredHandlerLegacy]
+    expect(@processor.find_handlers(stmt("hello world"))).to eq [NotIgnoredHandlerLegacy]
+  end
+
+  it "handles a string input" do
+    class TestStringHandler < Handlers::Ruby::Legacy::Base
+      handles "hello"
+    end
+
+    expect(TestStringHandler.handles?(stmt("hello world"))).to be true
+    expect(TestStringHandler.handles?(stmt("nothello world"))).to be false
+  end
+
+  it "handles regex input" do
+    class TestRegexHandler < Handlers::Ruby::Legacy::Base
+      handles(/^nothello$/)
+    end
+
+    expect(TestRegexHandler.handles?(stmt("nothello"))).to be true
+    expect(TestRegexHandler.handles?(stmt("not hello hello"))).to be false
+  end
+
+  it "handles token input" do
+    class TestTokenHandler < Handlers::Ruby::Legacy::Base
+      handles TkMODULE
+    end
+
+    expect(TestTokenHandler.handles?(stmt("module"))).to be true
+    expect(TestTokenHandler.handles?(stmt("if"))).to be false
+  end
+
+  it "parses a do/end or { } block with #parse_block" do
+    class MyBlockHandler < Handlers::Ruby::Legacy::Base
+      handles(/\AmyMethod\b/)
+      def process
+        parse_block(:owner => "test")
+      end
+    end
+
+    class MyBlockInnerHandler < Handlers::Ruby::Legacy::Base
+      handles "inner"
+      def self.reset; @@reached = false end
+      def self.reached?; @@reached ||= false end
+      def process; @@reached = true end
+    end
+
+    allow(Handlers::Base).to receive(:subclasses).and_return [MyBlockHandler, MyBlockInnerHandler]
+    Parser::SourceParser.parser_type = :ruby18
+    Parser::SourceParser.parse_string "myMethod do inner end"
+    expect(MyBlockInnerHandler).to be_reached
+    MyBlockInnerHandler.reset
+    Parser::SourceParser.parse_string "myMethod { inner }"
+    expect(MyBlockInnerHandler).to be_reached
+    Parser::SourceParser.parser_type = :ruby
+  end
+end

data/spec/handlers/spec_helper.rb

@@ -1,33 +1,33 @@
-# frozen_string_literal: true
-require 'stringio'
-
-include Handlers
-
-def undoc_error(code)
-  expect { StubbedSourceParser.parse_string(code) }.to raise_error(Parser::UndocumentableError)
-end
-
-def with_parser(parser_type)
-  tmp = StubbedSourceParser.parser_type
-  StubbedSourceParser.parser_type = parser_type
-  yield
-  StubbedSourceParser.parser_type = tmp
-end
-
-class StubbedProcessor < Processor
-  def process(statements)
-    statements.each_with_index do |stmt, _index|
-      find_handlers(stmt).each do |handler|
-        handler.new(self, stmt).process
-      end
-    end
-  end
-end
-
-class StubbedSourceParser < Parser::SourceParser
-  StubbedSourceParser.parser_type = :ruby
-  def post_process
-    post = StubbedProcessor.new(self)
-    post.process(@parser.enumerator)
-  end
-end
+# frozen_string_literal: true
+require 'stringio'
+
+include Handlers
+
+def undoc_error(code)
+  expect { StubbedSourceParser.parse_string(code) }.to raise_error(Parser::UndocumentableError)
+end
+
+def with_parser(parser_type)
+  tmp = StubbedSourceParser.parser_type
+  StubbedSourceParser.parser_type = parser_type
+  yield
+  StubbedSourceParser.parser_type = tmp
+end
+
+class StubbedProcessor < Processor
+  def process(statements)
+    statements.each_with_index do |stmt, _index|
+      find_handlers(stmt).each do |handler|
+        handler.new(self, stmt).process
+      end
+    end
+  end
+end
+
+class StubbedSourceParser < Parser::SourceParser
+  StubbedSourceParser.parser_type = :ruby
+  def post_process
+    post = StubbedProcessor.new(self)
+    post.process(@parser.enumerator)
+  end
+end

data/spec/handlers/visibility_handler_spec.rb

@@ -1,44 +1,44 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
-  before(:all) { parse_file :visibility_handler_001, __FILE__ }
-
-  it "is able to set visibility to public" do
-    expect(Registry.at("Testing#pub").visibility).to eq :public
-    expect(Registry.at("Testing#pub2").visibility).to eq :public
-  end
-
-  it "is able to set visibility to private" do
-    expect(Registry.at("Testing#priv").visibility).to eq :private
-  end
-
-  it "is able to set visibility to protected" do
-    expect(Registry.at("Testing#prot").visibility).to eq :protected
-  end
-
-  it "supports parameters and only set visibility on those methods" do
-    expect(Registry.at('Testing#notpriv').visibility).to eq :protected
-    expect(Registry.at('Testing#notpriv2').visibility).to eq :protected
-    expect(Registry.at('Testing#notpriv?').visibility).to eq :protected
-  end
-
-  it "only accepts strings and symbols" do
-    expect(Registry.at('Testing#name')).to be nil
-    expect(Registry.at('Testing#argument')).to be nil
-    expect(Registry.at('Testing#method_call')).to be nil
-  end
-
-  it "handles constants passed in as symbols" do
-    expect(Registry.at('Testing#Foo').visibility).to eq :private
-  end
-
-  it "does not register classes with visibility" do
-    expect(Registry.at('Testing::Bar').visibility).to eq :public
-    expect(Registry.at('Testing::Baz').visibility).to eq :public
-  end
-
-  it "can decorate a method definition" do
-    expect(Registry.at('Testing#decpriv').visibility).to eq :private
-  end unless LEGACY_PARSER
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
+  before(:all) { parse_file :visibility_handler_001, __FILE__ }
+
+  it "is able to set visibility to public" do
+    expect(Registry.at("Testing#pub").visibility).to eq :public
+    expect(Registry.at("Testing#pub2").visibility).to eq :public
+  end
+
+  it "is able to set visibility to private" do
+    expect(Registry.at("Testing#priv").visibility).to eq :private
+  end
+
+  it "is able to set visibility to protected" do
+    expect(Registry.at("Testing#prot").visibility).to eq :protected
+  end
+
+  it "supports parameters and only set visibility on those methods" do
+    expect(Registry.at('Testing#notpriv').visibility).to eq :protected
+    expect(Registry.at('Testing#notpriv2').visibility).to eq :protected
+    expect(Registry.at('Testing#notpriv?').visibility).to eq :protected
+  end
+
+  it "only accepts strings and symbols" do
+    expect(Registry.at('Testing#name')).to be nil
+    expect(Registry.at('Testing#argument')).to be nil
+    expect(Registry.at('Testing#method_call')).to be nil
+  end
+
+  it "handles constants passed in as symbols" do
+    expect(Registry.at('Testing#Foo').visibility).to eq :private
+  end
+
+  it "does not register classes with visibility" do
+    expect(Registry.at('Testing::Bar').visibility).to eq :public
+    expect(Registry.at('Testing::Baz').visibility).to eq :public
+  end
+
+  it "can decorate a method definition" do
+    expect(Registry.at('Testing#decpriv').visibility).to eq :private
+  end unless LEGACY_PARSER
+end