yard 0.9.21 → 0.9.26

data/spec/serializers/data/serialized_yardoc/proxy_types

@@ -1,2 +0,0 @@
-{I"Object:EF:
-class

data/spec/serializers/file_system_serializer_spec.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-require 'stringio'
-
-RSpec.describe YARD::Serializers::FileSystemSerializer do
-  before do
-    allow(FileUtils).to receive(:mkdir_p)
-    allow(File).to receive(:open)
-  end
-
-  describe "#basepath" do
-    it "defaults the base path to the 'doc/'" do
-      obj = Serializers::FileSystemSerializer.new
-      expect(obj.basepath).to eq 'doc'
-    end
-  end
-
-  describe "#extension" do
-    it "defaults the file extension to .html" do
-      obj = Serializers::FileSystemSerializer.new
-      expect(obj.extension).to eq "html"
-    end
-  end
-
-  describe "#serialized_path" do
-    it "allows no extension to be used" do
-      obj = Serializers::FileSystemSerializer.new :extension => nil
-      yard = CodeObjects::ClassObject.new(nil, :FooBar)
-      expect(obj.serialized_path(yard)).to eq 'FooBar'
-    end
-
-    it "serializes to top-level-namespace for root" do
-      obj = Serializers::FileSystemSerializer.new :extension => nil
-      expect(obj.serialized_path(Registry.root)).to eq "top-level-namespace"
-    end
-
-    it "returns serialized_path for a String" do
-      s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
-      expect(s.serialized_path('test.txt')).to eq 'test.txt'
-    end
-
-    it "removes special chars from path" do
-      m = CodeObjects::MethodObject.new(nil, 'a')
-      s = Serializers::FileSystemSerializer.new
-
-      {:gsub! => 'gsub_21_i.html',
-        :ask? => 'ask_3F_i.html',
-        :=== => '_3D_3D_3D_i.html',
-        :+ => '_2B_i.html',
-        :- => '-_i.html',
-        :[]= => '_5B_5D_3D_i.html',
-        :<< => '_3C_3C_i.html',
-        :>= => '_3E_3D_i.html',
-        :` => '_60_i.html',
-        :& => '_26_i.html',
-        :* => '_2A_i.html',
-        :| => '_7C_i.html',
-        :/ => '_2F_i.html',
-        :=~ => '_3D_7E_i.html'}.each do |meth, value|
-        allow(m).to receive(:name).and_return(meth)
-        expect(s.serialized_path(m)).to eq value
-      end
-    end
-
-    it "handles ExtraFileObject's" do
-      s = Serializers::FileSystemSerializer.new
-      e = CodeObjects::ExtraFileObject.new('filename.txt', '')
-      expect(s.serialized_path(e)).to eq 'file.filename.html'
-    end
-
-    it "differentiates instance and class methods from serialized path" do
-      s = Serializers::FileSystemSerializer.new
-      m1 = CodeObjects::MethodObject.new(nil, 'meth')
-      m2 = CodeObjects::MethodObject.new(nil, 'meth', :class)
-      expect(s.serialized_path(m1)).not_to eq s.serialized_path(m2)
-    end
-
-    it "serializes path from overload tag" do
-      YARD.parse_string <<-'eof'
-        class Foo
-          # @overload bar
-          def bar; end
-        end
-      eof
-
-      serializer = Serializers::FileSystemSerializer.new
-      object = Registry.at('Foo#bar').tag(:overload)
-      expect(serializer.serialized_path(object)).to eq "Foo/bar_i.html"
-    end
-
-    it "maps matching case sensitive object names to different files on disk" do
-      Registry.clear
-      o1 = CodeObjects::ClassObject.new(:root, "AB")
-      o2 = CodeObjects::ClassObject.new(:root, "Ab")
-      s = Serializers::FileSystemSerializer.new
-      expect([["AB_.html", "Ab.html"], ["AB.html", "Ab_.html"]]).to include(
-        [s.serialized_path(o1), s.serialized_path(o2)]
-      )
-    end
-
-    it "handles case sensitivity of nested paths for objects with matching names" do
-      Registry.clear
-      YARD.parse_string <<-eof
-        class Abc; class D; end end
-        class ABC; class D; end end
-      eof
-
-      s = Serializers::FileSystemSerializer.new
-      expect(s.serialized_path(Registry.at('ABC::D'))).to eq "ABC/D.html"
-      expect(s.serialized_path(Registry.at('Abc::D'))).to eq "Abc/D.html"
-    end
-  end
-
-  describe "#serialize" do
-    it "serializes to the correct path" do
-      yard = CodeObjects::ClassObject.new(nil, :FooBar)
-      meth = CodeObjects::MethodObject.new(yard, :baz, :class)
-      meth2 = CodeObjects::MethodObject.new(yard, :baz)
-
-      {'foo/FooBar/baz_c.txt' => meth,
-        'foo/FooBar/baz_i.txt' => meth2,
-        'foo/FooBar.txt' => yard}.each do |path, obj|
-        io = StringIO.new
-        expect(File).to receive(:open).with(path, 'wb').and_yield(io)
-        expect(io).to receive(:write).with("data")
-
-        s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
-        s.serialize(obj, "data")
-      end
-    end
-
-    it "guarantees the directory exists" do
-      o1 = CodeObjects::ClassObject.new(nil, :Really)
-      o2 = CodeObjects::ClassObject.new(o1, :Long)
-      o3 = CodeObjects::ClassObject.new(o2, :PathName)
-      obj = CodeObjects::MethodObject.new(o3, :foo)
-
-      expect(FileUtils).to receive(:mkdir_p).once.with('doc/Really/Long/PathName')
-
-      s = Serializers::FileSystemSerializer.new
-      s.serialize(obj, "data")
-    end
-  end
-end

data/spec/serializers/spec_helper.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-include YARD

data/spec/serializers/yardoc_serializer_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-instance_eval do
-  class YARD::Serializers::YardocSerializer
-    public :dump
-    public :internal_dump
-  end
-end
-
-RSpec.describe YARD::Serializers::YardocSerializer do
-  before do
-    @serializer = YARD::Serializers::YardocSerializer.new('.yardoc')
-
-    Registry.clear
-    @foo = CodeObjects::ClassObject.new(:root, :Foo)
-    @bar = CodeObjects::MethodObject.new(@foo, :bar)
-  end
-
-  describe "#dump" do
-    it "maintains object equality when loading a dumped object" do
-      newfoo = @serializer.internal_dump(@foo)
-      expect(newfoo).to equal(@foo)
-      expect(newfoo).to eq @foo
-      expect(@foo).to equal(newfoo)
-      expect(@foo).to eq newfoo
-      expect(newfoo.hash).to eq @foo.hash
-    end
-
-    it "maintains hash key equality when loading a dumped object" do
-      newfoo = @serializer.internal_dump(@foo)
-      expect(@foo => 1).to have_key(newfoo)
-      expect(newfoo => 1).to have_key(@foo)
-    end
-  end
-
-  describe "#serialize" do
-    it "accepts a hash of codeobjects (and write to root)" do
-      data = {:root => Registry.root}
-      marshaldata = Marshal.dump(data)
-      filemock = double(:file)
-      expect(filemock).to receive(:write).with(marshaldata)
-      expect(File).to receive(:open!).with('.yardoc/objects/root.dat', 'wb').and_yield(filemock)
-      @serializer.serialize(data)
-    end
-  end
-
-  describe "#lock_for_writing" do
-    it "creates a lock file during writing and cleans up" do
-      expect(File).to receive(:open!).with(@serializer.processing_path, 'w')
-      expect(File).to receive(:exist?).with(@serializer.processing_path).exactly(2).times.and_return(true)
-      expect(File).to receive(:unlink).with(@serializer.processing_path)
-      @serializer.lock_for_writing do
-        expect(@serializer.locked_for_writing?).to eq true
-      end
-    end
-  end
-
-  describe "#complete?" do
-    it "returns false if complete file does not exist" do
-      allow(File).to receive(:exist?).with(@serializer.complete_lock_path).and_return(false)
-      allow(File).to receive(:exist?).with(@serializer.processing_path).and_return(false)
-      expect(@serializer.complete?).to eq false
-    end
-
-    it "returns false if processing file exists" do
-      allow(File).to receive(:exist?).with(@serializer.complete_lock_path).and_return(true)
-      allow(File).to receive(:exist?).with(@serializer.processing_path).and_return(true)
-      expect(@serializer.complete?).to eq false
-    end
-
-    it "returns true if complete file exists with no processing file" do
-      allow(File).to receive(:exist?).with(@serializer.complete_lock_path).and_return(true)
-      allow(File).to receive(:exist?).with(@serializer.processing_path).and_return(false)
-      expect(@serializer.complete?).to eq true
-    end
-  end
-end

data/spec/server/adapter_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Server::Adapter do
-  after(:all) { Server::Adapter.shutdown }
-
-  describe "#add_library" do
-    it "adds a library" do
-      lib = LibraryVersion.new('yard')
-      a = Adapter.new({})
-      expect(a.libraries).to be_empty
-      a.add_library(lib)
-      expect(a.libraries['yard']).to eq [lib]
-    end
-  end
-
-  describe "#start" do
-    it "does not implement #start" do
-      expect { Adapter.new({}).start }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe ".setup" do
-    it "adds template paths and helpers" do
-      Adapter.setup
-      expect(Templates::Template.extra_includes).to include(DocServerHelper)
-      expect(Templates::Engine.template_paths).to include(YARD::ROOT + '/yard/server/templates')
-    end
-  end
-
-  describe ".shutdown" do
-    it "cleans up template paths and helpers" do
-      Adapter.setup
-      Adapter.shutdown
-      expect(Templates::Template.extra_includes).not_to include(DocServerHelper)
-      expect(Templates::Engine.template_paths).not_to include(YARD::ROOT + '/yard/server/templates')
-    end
-  end
-end

data/spec/server/commands/base_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-class MyProcCommand < Base
-  def initialize(&block)
-    self.class.send(:undef_method, :run)
-    self.class.send(:define_method, :run, &block)
-  end
-end
-
-class MyCacheCommand < Base
-  def run; cache 'foo' end
-end
-
-RSpec.describe YARD::Server::Commands::Base do
-  describe "#cache" do
-    before do
-      @command = MyCacheCommand.new(:adapter => mock_adapter, :caching => true)
-      @command.request = mock_request(nil)
-    end
-
-    it "does not cache if caching == false" do
-      expect(File).not_to receive(:open)
-      @command.caching = false
-      @command.run
-    end
-
-    it "requires document root to cache" do
-      expect(File).not_to receive(:open)
-      @command.adapter.document_root = nil
-      @command.run
-    end
-
-    it "caches to path/to/file.html and create directories" do
-      expect(FileUtils).to receive(:mkdir_p).with('/public/path/to')
-      expect(File).to receive(:open).with('/public/path/to/file.html', anything)
-      @command.request.path_info = '/path/to/file.html'
-      @command.run
-    end
-  end
-
-  describe "#redirect" do
-    it "returns a valid redirection" do
-      cmd = MyProcCommand.new { redirect '/foo' }
-      expect(cmd.call(mock_request('/foo'))).to eq(
-        [302, {"Content-Type" => "text/html", "Location" => "/foo"}, [""]]
-      )
-    end
-  end
-
-  describe "#call" do
-    it "handles a NotFoundError and use message as body" do
-      cmd = MyProcCommand.new { raise NotFoundError, "hello world" }
-      s, _, b = *cmd.call(mock_request('/foo'))
-      expect(s).to eq 404
-      expect(b).to eq ["hello world"]
-    end
-
-    it "does not use message as body if not provided in NotFoundError" do
-      cmd = MyProcCommand.new { raise NotFoundError }
-      s, _, b = *cmd.call(mock_request('/foo'))
-      expect(s).to eq 404
-      expect(b).to eq ["Not found: /foo"]
-    end
-
-    it "handles 404 status code from #run" do
-      cmd = MyProcCommand.new { self.status = 404 }
-      s, _, b = *cmd.call(mock_request('/foo'))
-      expect(s).to eq 404
-      expect(b).to eq ["Not found: /foo"]
-    end
-
-    it "does not override body if status is 404 and body is defined" do
-      cmd = MyProcCommand.new { self.body = "foo"; self.status = 404 }
-      s, _, b = *cmd.call(mock_request('/bar'))
-      expect(s).to eq 404
-      expect(b).to eq ['foo']
-    end
-
-    it "handles body as Array" do
-      cmd = MyProcCommand.new { self.body = ['a', 'b', 'c'] }
-      _, _, b = *cmd.call(mock_request('/foo'))
-      expect(b).to eq %w(a b c)
-    end
-
-    it "allows headers to be defined" do
-      cmd = MyProcCommand.new { headers['Foo'] = 'BAR' }
-      _, h, = *cmd.call(mock_request('/foo'))
-      expect(h['Foo']).to eq 'BAR'
-    end
-  end
-end

data/spec/server/commands/library_command_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-
-RSpec.describe YARD::Server::Commands::LibraryCommand do
-  before do
-    allow(Templates::Engine).to receive(:render)
-    allow(Templates::Engine).to receive(:generate)
-    allow(YARD).to receive(:parse)
-    allow(Registry).to receive(:load)
-    allow(Registry).to receive(:save)
-
-    @cmd = LibraryCommand.new(:adapter => mock_adapter)
-    @request = mock_request("/foo", :xhr? => false)
-    @library = OpenStruct.new(:source_path => '.')
-    @cmd.library = @library
-    allow(@cmd).to receive(:load_yardoc).and_return(nil)
-  end
-
-  def call
-    expect { @cmd.call(@request) }.to raise_error(NotImplementedError)
-  end
-
-  describe "#call" do
-    it "raises NotImplementedError" do
-      call
-    end
-
-    it "sets :rdoc as the default markup in incremental mode" do
-      @cmd.incremental = true
-      call
-      expect(@cmd.options[:markup]).to eq :rdoc
-    end
-
-    it "sets :rdoc as the default markup in regular mode" do
-      call
-      expect(@cmd.options[:markup]).to eq :rdoc
-    end
-  end
-end

data/spec/server/doc_server_helper_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-class MyDocServerSerializerRouter
-  attr_accessor :request
-  def docs_prefix; 'PREFIX' end
-  def initialize; @request = mock_request end
-end
-
-class MockDocServerHelper
-  include YARD::Templates::Helpers::BaseHelper
-  include YARD::Templates::Helpers::HtmlHelper
-  include YARD::Server::DocServerHelper
-
-  attr_accessor :adapter
-  attr_accessor :single_library
-  attr_accessor :library
-
-  def initialize
-    @single_library = false
-    @library = LibraryVersion.new('foo')
-    @adapter = mock_adapter(:router => MyDocServerSerializerRouter.new)
-    @serializer = YARD::Server::DocServerSerializer.new
-    @object = YARD::Registry.root
-  end
-
-  def options; OpenStruct.new end
-end
-
-RSpec.describe YARD::Server::DocServerHelper do
-  before do
-    @helper = MockDocServerHelper.new
-  end
-
-  describe "#url_for" do
-    it "does not link to /library/ if single_library = true" do
-      @helper.single_library = true
-      expect(@helper.url_for(Registry.root)).to eq "/PREFIX/toplevel"
-    end
-
-    it "returns /PREFIX/foo/version if foo has a version" do
-      @helper.library = LibraryVersion.new('foo', 'bar')
-      @helper.adapter.router.request.version_supplied = true
-      expect(@helper.url_for(P('A'))).to eq '/PREFIX/foo/bar/A'
-    end
-
-    it "uses script name prefix if set" do
-      @helper.adapter.router.request.script_name = '/mount/point'
-      @helper.library = LibraryVersion.new('foo', 'bar')
-      @helper.adapter.router.request.version_supplied = true
-      expect(@helper.url_for(P('A'))).to eq '/mount/point/PREFIX/foo/bar/A'
-    end
-  end
-
-  describe "#url_for_file" do
-    it "properly links file objects using file/ prefix" do
-      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
-      expect(@helper.url_for_file(file)).to eq '/PREFIX/foo/file/a/b/FooBar.md'
-    end
-
-    it "properly links anchor portion" do
-      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
-      expect(@helper.url_for_file(file, 'anchor')).to eq '/PREFIX/foo/file/a/b/FooBar.md#anchor'
-    end
-
-    it "uses script name prefix if set" do
-      @helper.adapter.router.request.script_name = '/mount/point'
-      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
-      expect(@helper.url_for_file(file)).to eq '/mount/point/PREFIX/foo/file/a/b/FooBar.md'
-    end
-  end
-end