yard 0.9.23 → 0.9.27

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

data/spec/server/doc_server_serializer_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Server::DocServerSerializer do
-  describe "#serialized_path" do
-    before do
-      Registry.clear
-      @serializer = Server::DocServerSerializer.new
-    end
-
-    after(:all) { Server::Adapter.shutdown }
-
-    it "returns '/PREFIX/library/toplevel' for root" do
-      expect(@serializer.serialized_path(Registry.root)).to eq "toplevel"
-    end
-
-    it "returns /PREFIX/library/Object for Object in a library" do
-      expect(@serializer.serialized_path(P('A::B::C'))).to eq 'A/B/C'
-    end
-
-    it "links to instance method as Class:method" do
-      obj = CodeObjects::MethodObject.new(:root, :method)
-      expect(@serializer.serialized_path(obj)).to eq 'toplevel:method'
-    end
-
-    it "links to class method as Class.method" do
-      obj = CodeObjects::MethodObject.new(:root, :method, :class)
-      expect(@serializer.serialized_path(obj)).to eq 'toplevel.method'
-    end
-
-    it "links to anchor for constant" do
-      obj = CodeObjects::ConstantObject.new(:root, :FOO)
-      expect(@serializer.serialized_path(obj)).to eq 'toplevel#FOO-constant'
-    end
-
-    it "links to anchor for class variable" do
-      obj = CodeObjects::ClassVariableObject.new(:root, :@@foo)
-      expect(@serializer.serialized_path(obj)).to eq 'toplevel#@@foo-classvariable'
-    end
-
-    it "links files using file/ prefix" do
-      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
-      expect(@serializer.serialized_path(file)).to eq 'file/FooBar'
-    end
-
-    it "escapes special characters" do
-      obj = CodeObjects::MethodObject.new(:root, :method?)
-      expect(@serializer.serialized_path(obj)).to eq 'toplevel:method%3F'
-    end
-
-    it "handles unicode data" do
-      file = CodeObjects::ExtraFileObject.new("test\u0160", '')
-      if file.name.encoding == Encoding.find("Windows-1252")
-        expect(@serializer.serialized_path(file)).to eq 'file/test_8A'
-      else
-        expect(@serializer.serialized_path(file)).to eq 'file/test_C5A0'
-      end
-    end if defined?(::Encoding)
-  end
-end

data/spec/server/rack_adapter_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe "YARD::Server::RackMiddleware" do
-  before do
-    begin; require 'rack'; rescue LoadError; pending "rack required for these tests" end
-    @superapp = double(:superapp)
-    @app = YARD::Server::RackMiddleware.new(@superapp, :libraries => {'foo' => [LibraryVersion.new('foo', nil)]})
-  end
-
-  after(:all) { YARD::Server::Adapter.shutdown }
-
-  it "handles requests" do
-    expect(@app.call(Rack::MockRequest.env_for('/'))[0]).to eq 200
-  end
-
-  it "passes up to the next middleware on 404" do
-    expect(@superapp).to receive(:call).and_return([200, {}, ['OK']])
-    expect(@app.call(Rack::MockRequest.env_for('/INVALID'))).to eq [200, {}, ['OK']]
-  end
-end

data/spec/server/router_spec.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-class MyRouterSpecRouter < Router
-  def docs_prefix; 'mydocs/foo' end
-  def list_prefix; 'mylist/foo' end
-  def search_prefix; 'mysearch/foo' end
-
-  def check_static_cache; nil end
-end
-
-RSpec.describe YARD::Server::Router do
-  before do
-    @adapter = mock_adapter
-    @projects = @adapter.libraries['project']
-    @request = mock_request
-  end
-
-  describe "#parse_library_from_path" do
-    def parse(*args)
-      @request.path_info = '/' + args.join('/')
-      @router = MyRouterSpecRouter.new(@adapter)
-      @router.request = @request
-      @router.parse_library_from_path(args.flatten)
-    end
-
-    it "parses library and version name out of path" do
-      expect(parse('project', '1.0.0')).to eq [@projects[0], []]
-      expect(@request.version_supplied).to be true
-    end
-
-    it "parses library and use latest version if version is not supplied" do
-      expect(parse('project')).to eq [@projects[1], []]
-      expect(@request.version_supplied).to be false
-    end
-
-    it "parses library and use latest version if next component is not a version" do
-      expect(parse('project', 'notaversion')).to eq [@projects[1], ['notaversion']]
-      expect(@request.version_supplied).to be false
-    end
-
-    it "returns nil library if no library is found" do
-      expect(parse('notproject')).to eq [nil, ['notproject']]
-    end
-
-    it "does not parse library or version if single_library == true" do
-      allow(@adapter).to receive(:options).and_return(:single_library => true)
-      expect(parse('notproject')).to eq [@projects[0], ['notproject']]
-    end
-  end
-
-  describe "#route" do
-    def route_to(route, command, script_name = '')
-      req = mock_request(route, script_name)
-      router = MyRouterSpecRouter.new(@adapter)
-      expect(command).to receive(:new) do |*args|
-        @command = command.allocate
-        @command.send(:initialize, *args)
-        class << @command; define_method(:call) {|*| self } end
-        @command
-      end
-      router.call(req)
-    end
-
-    it "routes /docs/OBJECT to object if single_library = true" do
-      allow(@adapter).to receive(:options).and_return(:single_library => true)
-      route_to('/mydocs/foo/FOO', DisplayObjectCommand)
-    end
-
-    it "routes /docs" do
-      route_to('/mydocs/foo', LibraryIndexCommand)
-    end
-
-    it "routes /docs as index for library if single_library == true" do
-      allow(@adapter).to receive(:options).and_return(:single_library => true)
-      route_to('/mydocs/foo/', DisplayObjectCommand)
-    end
-
-    it "routes /docs/name/version" do
-      route_to('/mydocs/foo/project/1.0.0', DisplayObjectCommand)
-      expect(@command.library).to eq @projects[0]
-    end
-
-    it "routes /docs/name/ to latest version of library" do
-      route_to('/mydocs/foo/project', DisplayObjectCommand)
-      expect(@command.library).to eq @projects[1]
-    end
-
-    it "routes /list/name/version/class" do
-      route_to('/mylist/foo/project/1.0.0/class', ListCommand)
-      expect(@command.library).to eq @projects[0]
-    end
-
-    it "routes /list/name/version/methods" do
-      route_to('/mylist/foo/project/1.0.0/methods', ListCommand)
-      expect(@command.library).to eq @projects[0]
-    end
-
-    it "routes /list/name/version/files" do
-      route_to('/mylist/foo/project/1.0.0/files', ListCommand)
-      expect(@command.library).to eq @projects[0]
-    end
-
-    it "routes /list/name to latest version of library" do
-      route_to('/mylist/foo/project/class', ListCommand)
-      expect(@command.library).to eq @projects[1]
-    end
-
-    it "routes /search/name/version" do
-      route_to('/mysearch/foo/project/1.0.0', SearchCommand)
-      expect(@command.library).to eq @projects[0]
-    end
-
-    it "routes /search/name to latest version of library" do
-      route_to('/mysearch/foo/project', SearchCommand)
-      expect(@command.library).to eq @projects[1]
-    end
-
-    it "searches static files for non-existent library" do
-      route_to('/mydocs/foo/notproject', RootRequestCommand)
-    end
-  end
-end

data/spec/server/spec_helper.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-
-include Server
-include Commands
-
-def mock_adapter(opts = {})
-  opts[:libraries] ||= {'project' => [LibraryVersion.new('project', '1.0.0'), LibraryVersion.new('project', '1.0.1')]}
-  opts[:document_root] ||= '/public'
-  opts[:options] ||= {:single_library => false, :caching => false}
-  opts[:server_options] ||= {}
-  OpenStruct.new(opts)
-end
-
-class MockRequest < OpenStruct
-  def path; "#{script_name}#{path_info}" end
-end
-
-def mock_request(path_info = '/', script_name = '', extra_env = {})
-  opts = {:path_info => path_info, :script_name => script_name}
-  MockRequest.new(extra_env.merge(opts))
-end

data/spec/server/static_caching_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Server::StaticCaching do
-  include StaticCaching
-
-  describe "#check_static_cache" do
-    def adapter; @adapter ||= mock_adapter end
-    def request; @request ||= MockRequest.new end
-
-    it "returns nil if document root is not set" do
-      adapter.document_root = nil
-      expect(check_static_cache).to be nil
-    end
-
-    it "reads a file from document root if path matches file on system" do
-      request.path_info = '/hello/world.html'
-      expect(File).to receive(:file?).with('/public/hello/world.html').and_return(true)
-      expect(File).to receive(:open).with('/public/hello/world.html', anything).and_return('body')
-      s, _, b = *check_static_cache
-      expect(s).to eq 200
-      expect(b).to eq ["body"]
-    end
-
-    it "reads a file if path matches file on system + .html" do
-      request.path_info = '/hello/world'
-      expect(File).to receive(:file?).with('/public/hello/world.html').and_return(true)
-      expect(File).to receive(:open).with('/public/hello/world.html', anything).and_return('body')
-      s, _, b = *check_static_cache
-      expect(s).to eq 200
-      expect(b).to eq ["body"]
-    end
-
-    it "returns nil if no matching file is found" do
-      request.path_info = '/hello/foo'
-      expect(File).to receive(:file?).with('/public/hello/foo.html').and_return(false)
-      expect(check_static_cache).to eq nil
-    end
-
-    it "adds mount point to cache location" do
-      request.path_info = '/hello/world.html'
-      request.script_name = '/mount/point'
-      expect(File).to receive(:file?).with('/public/mount/point/hello/world.html').and_return(false)
-      expect(check_static_cache).to eq nil
-    end
-  end
-end

data/spec/server/webrick_servlet_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Server::WebrickServlet do
-  describe "#do_GET" do
-    it "performs a GET" do
-      resp = OpenStruct.new
-      class << resp
-        def []=(name, value) (self.headers ||= {})[name] = value end
-      end
-      server = double(:server, :[] => nil)
-      adapter = mock_adapter
-      adapter.router = proc { [200, {'Header' => 'foo'}, ['body']] }
-      WebrickServlet.new(server, adapter).do_GET(mock_request('/foo'), resp)
-      expect(resp.status).to eq 200
-      expect(resp.headers).to eq('Header' => 'foo')
-      expect(resp.body).to eq 'body'
-    end
-  end
-end

data/spec/server_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Server do
-  describe ".register_static_path" do
-    it "registers a static path" do
-      YARD::Server.register_static_path 'foo'
-      expect(YARD::Server::Commands::StaticFileCommand::STATIC_PATHS.last).to eq "foo"
-    end
-
-    it "does not duplicate paths" do
-      paths = YARD::Server::Commands::StaticFileCommand::STATIC_PATHS
-      count = paths.size
-      YARD::Server.register_static_path 'foo2'
-      YARD::Server.register_static_path 'foo2'
-      expect(paths.size).to eq(count + 1)
-      expect(paths.last).to eq 'foo2'
-    end
-  end
-end