yard 0.9.23 → 0.9.27

data/spec/handlers/module_handler_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ModuleHandler" do
-  before(:all) { parse_file :module_handler_001, __FILE__ }
-
-  it "parses a module block" do
-    expect(Registry.at(:ModName)).not_to eq nil
-    expect(Registry.at("ModName::OtherModName")).not_to eq nil
-  end
-
-  it "attaches docstring" do
-    expect(Registry.at("ModName::OtherModName").docstring).to eq "Docstring"
-  end
-
-  it "handles any formatting" do
-    expect(Registry.at(:StressTest)).not_to eq nil
-  end
-
-  it "handles complex module names" do
-    expect(Registry.at("A::B")).not_to eq nil
-  end
-
-  it "handles modules in the form ::ModName" do
-    expect(Registry.at("Kernel")).not_to be nil
-  end
-
-  it "lists mixins in proper order" do
-    expect(Registry.at('D').mixins).to eq [P(:C), P(:B), P(:A)]
-  end
-
-  it "creates proper module when constant is in namespace" do
-    expect(Registry.at('Q::FOO::A')).not_to be nil
-  end
-end

data/spec/handlers/private_class_method_handler_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateClassMethodHandler" do
-  before { Registry.clear }
-
-  let(:visibility) { :private }
-
-  include_examples "class method visibility decorator"
-end

data/spec/handlers/private_constant_handler_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateConstantHandler" do
-  before(:all) { parse_file :private_constant_handler_001, __FILE__ }
-
-  it "handles private_constant statement" do
-    expect(Registry.at('A::Foo').visibility).to eq :private
-    expect(Registry.at('A::B').visibility).to eq :private
-    expect(Registry.at('A::C').visibility).to eq :private
-  end
-
-  it "makes all other constants public" do
-    expect(Registry.at('A::D').visibility).to eq :public
-  end
-
-  it "fails if parameter is not String, Symbol or Constant" do
-    undoc_error 'class Foo; private_constant x; end'
-    undoc_error 'class Foo; X = 1; private_constant X.new("hi"); end'
-  end unless LEGACY_PARSER
-
-  it "fails if constant can't be recognized" do
-    undoc_error 'class Foo2; private_constant :X end'
-  end
-end

data/spec/handlers/processor_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Handlers::Processor do
-  before do
-    @proc = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
-  end
-
-  it "starts with public visibility" do
-    expect(@proc.visibility).to eq :public
-  end
-
-  it "starts in instance scope" do
-    expect(@proc.scope).to eq :instance
-  end
-
-  it "starts in root namespace" do
-    expect(@proc.namespace).to eq Registry.root
-  end
-
-  it "has a globals structure" do
-    expect(@proc.globals).to be_a(OpenStruct)
-  end
-
-  it "ignores HandlerAborted exceptions (but print debug info)" do
-    class AbortHandlerProcessor < YARD::Handlers::Ruby::Base
-      process { abort! }
-    end
-    stmt = OpenStruct.new(:line => 1, :show => 'SOURCE')
-    allow(@proc).to receive(:find_handlers).and_return([AbortHandlerProcessor])
-    expect(log).to receive(:debug).with(/AbortHandlerProcessor cancelled from/)
-    expect(log).to receive(:debug).with("\tin file '(stdin)':1:\n\nSOURCE\n")
-    @proc.process([stmt])
-  end
-end

data/spec/handlers/public_class_method_handler_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PublicClassMethodHandler" do
-  before { Registry.clear }
-
-  let(:visibility) { :public }
-
-  include_examples "class method visibility decorator"
-end

data/spec/handlers/ruby/base_spec.rb

@@ -1,95 +0,0 @@
-# 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 +0,0 @@
-# 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 +0,0 @@
-# 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 +0,0 @@
-# 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

data/spec/handlers/yield_handler_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}YieldHandler" do
-  before(:all) { parse_file :yield_handler_001, __FILE__ }
-
-  it "only parses yield blocks in methods" do
-    expect(P(:Testing).tag(:yield)).to be nil
-    expect(P(:Testing).tag(:yieldparam)).to be nil
-  end
-
-  it "handles an empty yield statement" do
-    expect(P('Testing#mymethod').tag(:yield)).to be nil
-    expect(P('Testing#mymethod').tag(:yieldparam)).to be nil
-  end
-
-  it "does not document a yield statement in a method with either @yield or @yieldparam" do
-    expect(P('Testing#mymethod2').tag(:yield).types).to eq ['a', 'b']
-    expect(P('Testing#mymethod2').tag(:yield).text).to eq "Blah"
-    expect(P('Testing#mymethod2').tags(:yieldparam).size).to eq 2
-
-    expect(P('Testing#mymethod3').tag(:yield).types).to eq ['a', 'b']
-    expect(P('Testing#mymethod3').tags(:yieldparam).size).to eq 0
-
-    expect(P('Testing#mymethod4').tag(:yieldparam).name).to eq '_self'
-    expect(P('Testing#mymethod4').tag(:yieldparam).text).to eq 'BLAH'
-  end
-
-  it "handles any arbitrary yield statement" do
-    expect(P('Testing#mymethod5').tag(:yield).types).to eq [':a', 'b', '_self', 'File.read(\'file\', \'w\')', 'CONSTANT']
-  end
-
-  it "handles parentheses" do
-    expect(P('Testing#mymethod6').tag(:yield).types).to eq ['b', 'a']
-  end
-
-  it "only documents the first yield statement in a method (limitation of yield handler)" do
-    expect(P('Testing#mymethod7').tag(:yield).types).to eq ['a']
-  end
-
-  it "handles `self` keyword and list object type as yieldparam for _self" do
-    expect(P('Testing#mymethod8').tag(:yield).types).to eq ['_self']
-    expect(P('Testing#mymethod8').tag(:yieldparam).types).to eq ['Testing']
-    expect(P('Testing#mymethod8').tag(:yieldparam).text).to eq "the object that the method was called on"
-  end
-
-  it "handles `super` keyword and document it under _super" do
-    expect(P('Testing#mymethod9').tag(:yield).types).to eq ['_super']
-    expect(P('Testing#mymethod9').tag(:yieldparam).types).to be nil
-    expect(P('Testing#mymethod9').tag(:yieldparam).text).to eq "the result of the method from the superclass"
-  end
-end

data/spec/i18n/locale_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::Locale do
-  def locale(name)
-    YARD::I18n::Locale.new(name)
-  end
-
-  before do
-    @locale = locale("fr")
-  end
-
-  describe "#name" do
-    it "returns name" do
-      expect(locale("fr").name).to eq "fr"
-    end
-  end
-
-  describe "#load" do
-    it "returns false for nonexistent PO" do
-      expect(File).to receive(:exist?).with('foo/fr.po').and_return(false)
-      expect(@locale.load('foo')).to be false
-    end
-
-    have_gettext_gem = true
-    if RUBY_VERSION < "1.9"
-      begin
-        require "gettext/tools/poparser"
-      rescue LoadError
-        have_gettext_gem = false
-      end
-    else
-      begin
-        require "gettext/po_parser"
-      rescue LoadError
-        begin
-          require "gettext/tools/poparser"
-        rescue LoadError
-          have_gettext_gem = false
-        end
-      end
-    end
-
-    it "returns true for existent PO", :if => have_gettext_gem do
-      data = <<-eop
-msgid ""
-msgstr ""
-"Language: fr\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-msgid "Hello"
-msgstr "Bonjour"
-eop
-      parser = GetText::POParser.new
-      expect(File).to receive(:exist?).with('foo/fr.po').and_return(true)
-      expect(GetText::POParser).to receive(:new).and_return(parser)
-      expect(parser).to receive(:parse_file) do |file, hash|
-        expect(file).to eq 'foo/fr.po'
-        parser.parse(String.new(data), hash)
-      end
-      expect(@locale.load('foo')).to be true
-      expect(@locale.translate('Hello')).to eq "Bonjour"
-    end
-  end
-
-  describe "#translate" do
-    before do
-      messages = @locale.instance_variable_get(:@messages)
-      messages["Hello"] = "Bonjour"
-    end
-
-    it "returns translated string for existent string" do
-      expect(@locale.translate("Hello")) == "Bonjour"
-    end
-
-    it "returns original string for nonexistent string" do
-      expect(@locale.translate("nonexistent")) == "nonexistent"
-    end
-  end
-end

data/spec/i18n/message_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::Message do
-  def message(id)
-    YARD::I18n::Message.new(id)
-  end
-
-  before do
-    @message = message("Hello World!")
-  end
-
-  describe "#id" do
-    it "returns ID" do
-      expect(message("Hello World!").id).to eq "Hello World!"
-    end
-  end
-
-  describe "#add_location" do
-    it "adds some locations" do
-      @message.add_location("hello.rb", 10)
-      @message.add_location("message.rb", 5)
-      expect(@message.locations).to eq Set.new([["hello.rb", 10], ["message.rb", 5]])
-    end
-  end
-
-  describe "#add_comment" do
-    it "adds some comments" do
-      @message.add_comment("YARD.title")
-      @message.add_comment("Hello#message")
-      expect(@message.comments).to eq Set.new(["YARD.title", "Hello#message"])
-    end
-  end
-
-  describe "#==" do
-    it "returns true for same value messages" do
-      locations = [["hello.rb", 10], ["message.rb", 5]]
-      comments = ["YARD.title", "Hello#message"]
-
-      other_message = message(@message.id)
-      locations.each do |path, line|
-        @message.add_location(path, line)
-        other_message.add_location(path, line)
-      end
-      comments.each do |comment|
-        @message.add_comment(comment)
-        other_message.add_comment(comment)
-      end
-
-      expect(@message).to eq other_message
-    end
-  end
-end

data/spec/i18n/messages_spec.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::Messages do
-  def message(id)
-    YARD::I18n::Message.new(id)
-  end
-
-  def messages
-    YARD::I18n::Messages.new
-  end
-
-  before do
-    @messages = messages
-  end
-
-  describe "#each" do
-    it "enumerates messages" do
-      @messages.register("Hello World!")
-      @messages.register("Title")
-      enumerated_messages = []
-      @messages.each do |message|
-        enumerated_messages << message
-      end
-      enumerated_messages = enumerated_messages.sort_by(&:id)
-      expect(enumerated_messages).to eq [message("Hello World!"), message("Title")]
-    end
-
-    it "does not yield any message if there are none" do
-      enumerated_messages = []
-      @messages.each do |message|
-        enumerated_messages << message
-      end
-      expect(enumerated_messages).to eq []
-    end
-  end
-
-  describe "#[]" do
-    it "returns registered message" do
-      @messages.register("Hello World!")
-      expect(@messages["Hello World!"]).to eq message("Hello World!")
-    end
-
-    it "returns nil for nonexistent message ID" do
-      expect(@messages["Hello World!"]).to eq nil
-    end
-  end
-
-  describe "#register" do
-    it "returns registered message" do
-      expect(@messages.register("Hello World!")).to eq message("Hello World!")
-    end
-
-    it "returns existent message" do
-      message = @messages.register("Hello World!")
-      expect(@messages.register("Hello World!").object_id).to eq message.object_id
-    end
-  end
-
-  describe "#==" do
-    it "returns true for same value messages" do
-      @messages.register("Hello World!")
-      other_messages = messages
-      other_messages.register("Hello World!")
-      expect(@messages).to eq other_messages
-    end
-  end
-end