deg-yard 0.8.7.1

data/spec/server/commands/base_spec.rb

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

data/spec/server/commands/library_command_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'ostruct'
+
+describe YARD::Server::Commands::LibraryCommand do
+  before do
+    Templates::Engine.stub!(:render)
+    Templates::Engine.stub!(:generate)
+    YARD.stub!(:parse)
+    Registry.stub!(:load)
+    Registry.stub!(:save)
+
+    @cmd = LibraryCommand.new(:adapter => mock_adapter)
+    @request = OpenStruct.new(:xhr? => false, :path => "/foo")
+    @library = OpenStruct.new(:source_path => '.')
+    @cmd.library = @library
+    @cmd.stub!(:load_yardoc).and_return(nil)
+  end
+
+  def call
+    lambda { @cmd.call(@request) }.should raise_error(NotImplementedError)
+  end
+
+  describe "#call" do
+    it "should raise NotImplementedError" do
+      call
+    end
+
+    it "should set :rdoc as the default markup in incremental mode" do
+      @cmd.incremental = true
+      call
+      @cmd.options[:markup].should == :rdoc
+    end
+
+    it "should set :rdoc as the default markup in regular mode" do
+      call
+      @cmd.options[:markup].should == :rdoc
+    end
+  end
+end

data/spec/server/commands/static_file_command_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Server::Commands::StaticFileCommand do
+  before do
+    adapter = mock_adapter
+    adapter.document_root = '/c'
+    @cmd = StaticFileCommand.new(:adapter => adapter)
+  end
+
+  describe '#run' do
+    def run(path, status = nil, body = nil)
+      s, h, b = *@cmd.call(mock_request(path))
+      body.should == b.first if body
+      status.should == s if status
+      [s, h, b]
+    end
+
+    it "should search through document root before static paths" do
+      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+      StaticFileCommand::STATIC_PATHS.reverse.each do |path|
+        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+      end
+      run '/path/to/file.txt'
+    end
+
+    it "should return file contents if found" do
+      tpl = Templates::Engine.template(:default, :fulldoc, :html)
+      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(false)
+      tpl.should_receive(:find_file).with('/path/to/file.txt').and_return('/path/to/foo')
+      File.should_receive(:read).with('/path/to/foo').and_return('FOO')
+      run('/path/to/file.txt', 200, 'FOO')
+    end
+
+    it "should allow registering of new paths and use those before other static paths" do
+      Server.register_static_path '/foo'
+      path = '/foo/path/to/file.txt'
+      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(false)
+      File.should_receive(:exist?).with(path).and_return(true)
+      File.should_receive(:read).with(path).and_return('FOO')
+      run('/path/to/file.txt', 200, 'FOO')
+    end
+
+    it "should not use registered path before docroot" do
+      Server.register_static_path '/foo'
+      path = '/foo/path/to/file.txt'
+      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(true)
+      File.should_receive(:read).with('/c/path/to/file.txt').and_return('FOO')
+      run('/c/path/to/file.txt', 200, 'FOO')
+    end
+
+    it "should return 404 if not found" do
+      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+      StaticFileCommand::STATIC_PATHS.reverse.each do |path|
+        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+      end
+      run('/path/to/file.txt', 404)
+    end
+
+    it "should return text/html for file with no extension" do
+      File.should_receive(:exist?).with('/c/file').and_return(true)
+      File.should_receive(:read).with('/c/file')
+      s, h, b = *run('/file')
+      h['Content-Type'].should == 'text/html'
+    end
+
+    {
+      "js" => "text/javascript",
+      "css" => "text/css",
+      "png" => "image/png",
+      "gif" => "image/gif",
+      "htm" => "text/html",
+      "html" => "text/html",
+      "txt" => "text/plain",
+      "unknown" => "application/octet-stream"
+    }.each do |ext, mime|
+      it "should serve file.#{ext} as #{mime}" do
+        File.should_receive(:exist?).with('/c/file.' + ext).and_return(true)
+        File.should_receive(:read).with('/c/file.' + ext)
+        s, h, b = *run('/file.' + ext)
+        h['Content-Type'].should == mime
+      end
+    end
+  end
+end

data/spec/server/doc_server_helper_spec.rb

@@ -0,0 +1,53 @@
+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
+
+describe YARD::Server::DocServerHelper do
+  before do
+    @helper = MockDocServerHelper.new
+  end
+
+  describe '#url_for' do
+    it "should not link to /library/ if single_library = true" do
+      @helper.single_library = true
+      @helper.url_for(Registry.root).should == "/PREFIX/toplevel"
+    end
+
+    it "should return /PREFIX/foo/version if foo has a version" do
+      @helper.library = LibraryVersion.new('foo', 'bar')
+      @helper.adapter.router.request.version_supplied = true
+      @helper.url_for(P('A')).should == '/PREFIX/foo/bar/A'
+    end
+  end
+
+  describe '#url_for_file' do
+    it "should properly link file objects using file/ prefix" do
+      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
+      @helper.url_for_file(file).should == '/PREFIX/foo/file/a/b/FooBar.md'
+    end
+  end
+end

data/spec/server/doc_server_serializer_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Server::DocServerSerializer do
+  describe '#serialized_path' do
+    before do
+      Registry.clear
+      @serializer = Server::DocServerSerializer.new
+    end
+
+    after(:all) { Server::Adapter.shutdown }
+
+    it "should return '/PREFIX/library/toplevel' for root" do
+      @serializer.serialized_path(Registry.root).should == "toplevel"
+    end
+
+    it "should return /PREFIX/library/Object for Object in a library" do
+      @serializer.serialized_path(P('A::B::C')).should == 'A/B/C'
+    end
+
+    it "should link to instance method as Class:method" do
+      obj = CodeObjects::MethodObject.new(:root, :method)
+      @serializer.serialized_path(obj).should == 'toplevel:method'
+    end
+
+    it "should link to class method as Class.method" do
+      obj = CodeObjects::MethodObject.new(:root, :method, :class)
+      @serializer.serialized_path(obj).should == 'toplevel.method'
+    end
+
+    it "should link to anchor for constant" do
+      obj = CodeObjects::ConstantObject.new(:root, :FOO)
+      @serializer.serialized_path(obj).should == 'toplevel#FOO-constant'
+    end
+
+    it "should link to anchor for class variable" do
+      obj = CodeObjects::ClassVariableObject.new(:root, :@@foo)
+      @serializer.serialized_path(obj).should == 'toplevel#@@foo-classvariable'
+    end
+
+    it "should link files using file/ prefix" do
+      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
+      @serializer.serialized_path(file).should == 'file/FooBar'
+    end
+  end
+end

data/spec/server/rack_adapter_spec.rb

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

data/spec/server/router_spec.rb

@@ -0,0 +1,122 @@
+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
+
+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 = '/' + args.join('/')
+      @router = MyRouterSpecRouter.new(@adapter)
+      @router.request = @request
+      @router.parse_library_from_path(args.flatten)
+    end
+
+    it "should parse library and version name out of path" do
+      parse('project', '1.0.0').should == [@projects[0], []]
+      @request.version_supplied.should be_true
+    end
+
+    it "should parse library and use latest version if version is not supplied" do
+      parse('project').should == [@projects[1], []]
+      @request.version_supplied.should be_false
+    end
+
+    it "should parse library and use latest version if next component is not a version" do
+      parse('project', 'notaversion').should == [@projects[1], ['notaversion']]
+      @request.version_supplied.should be_false
+    end
+
+    it "should return nil library if no library is found" do
+      parse('notproject').should == [nil, ['notproject']]
+    end
+
+    it "should not parse library or version if single_library == true" do
+      @adapter.stub!(:options).and_return(:single_library => true)
+      parse('notproject').should == [@projects[0], ['notproject']]
+    end
+  end
+
+  describe '#route' do
+    def route_to(route, command, *args)
+      req = mock_request(route)
+      router = MyRouterSpecRouter.new(@adapter)
+      command.should_receive(:new).and_return do |*args|
+        @command = command.allocate
+        @command.send(:initialize, *args)
+        class << @command; def call(req); self end end
+        @command
+      end
+      router.call(req)
+    end
+
+    it "should route /docs/OBJECT to object if single_library = true" do
+      @adapter.stub!(:options).and_return(:single_library => true)
+      route_to('/mydocs/foo/FOO', DisplayObjectCommand)
+    end
+
+    it "should route /docs" do
+      route_to('/mydocs/foo', LibraryIndexCommand)
+    end
+
+    it "should route /docs as index for library if single_library == true" do
+      @adapter.stub!(:options).and_return(:single_library => true)
+      route_to('/mydocs/foo/', DisplayObjectCommand)
+    end
+
+    it "should route /docs/name/version" do
+      route_to('/mydocs/foo/project/1.0.0', DisplayObjectCommand)
+      @command.library.should == @projects[0]
+    end
+
+    it "should route /docs/name/ to latest version of library" do
+      route_to('/mydocs/foo/project', DisplayObjectCommand)
+      @command.library.should == @projects[1]
+    end
+
+    it "should route /list/name/version/class" do
+      route_to('/mylist/foo/project/1.0.0/class', ListCommand)
+      @command.library.should == @projects[0]
+    end
+
+    it "should route /list/name/version/methods" do
+      route_to('/mylist/foo/project/1.0.0/methods', ListCommand)
+      @command.library.should == @projects[0]
+    end
+
+    it "should route /list/name/version/files" do
+      route_to('/mylist/foo/project/1.0.0/files', ListCommand)
+      @command.library.should == @projects[0]
+    end
+
+    it "should route /list/name to latest version of library" do
+      route_to('/mylist/foo/project/class', ListCommand)
+      @command.library.should == @projects[1]
+    end
+
+    it "should route /search/name/version" do
+      route_to('/mysearch/foo/project/1.0.0', SearchCommand)
+      @command.library.should == @projects[0]
+    end
+
+    it "should route /search/name to latest version of library" do
+      route_to('/mysearch/foo/project', SearchCommand)
+      @command.library.should == @projects[1]
+    end
+
+    it "should search static files for non-existent library" do
+      route_to('/mydocs/foo/notproject', StaticFileCommand)
+    end
+  end
+end

data/spec/server/spec_helper.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+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
+
+def mock_request(path = '/')
+  OpenStruct.new(:path => path)
+end

data/spec/server/static_caching_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Server::StaticCaching do
+  include StaticCaching
+
+  describe '#check_static_cache' do
+    def adapter; @adapter ||= mock_adapter end
+    def request; @request ||= OpenStruct.new end
+
+    it "should return nil if document root is not set" do
+      adapter.document_root = nil
+      check_static_cache.should be_nil
+    end
+
+    it "should read a file from document root if path matches file on system" do
+      request.path = '/hello/world.html'
+      File.should_receive(:file?).with('/public/hello/world.html').and_return(true)
+      File.should_receive(:open).with('/public/hello/world.html', anything).and_return('body')
+      s, h, b = *check_static_cache
+      s.should == 200
+      b.should == ["body"]
+    end
+
+    it "should read a file if path matches file on system + .html" do
+      request.path = '/hello/world'
+      File.should_receive(:file?).with('/public/hello/world.html').and_return(true)
+      File.should_receive(:open).with('/public/hello/world.html', anything).and_return('body')
+      s, h, b = *check_static_cache
+      s.should == 200
+      b.should == ["body"]
+    end
+
+    it "should return nil if no matching file is found" do
+      request.path = '/hello/foo'
+      File.should_receive(:file?).with('/public/hello/foo.html').and_return(false)
+      check_static_cache.should == nil
+    end
+  end
+end

data/spec/server/webrick_servlet_spec.rb

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

data/spec/server_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe YARD::Server do
+  describe '.register_static_path' do
+    it "should register a static path" do
+      YARD::Server.register_static_path 'foo'
+      YARD::Server::Commands::StaticFileCommand::STATIC_PATHS.last.should == "foo"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,128 @@
+require "rubygems"
+begin
+  require "rspec"
+rescue LoadError
+  require "spec"
+end
+
+begin
+  require 'bundler'
+  Bundler.setup
+rescue LoadError
+end
+
+begin
+  require 'simplecov'
+  SimpleCov.start
+  # TODO: hide some rb files from cov report
+  # hide = '_spec\.rb$,spec_helper\.rb$,ruby_lex\.rb$,autoload\.rb$'
+  # if YARD::Parser::SourceParser.parser_type == :ruby
+  #   hide += ',legacy\/.+_handler'
+  # else
+  #   hide += ',ruby_parser\.rb$,ast_node\.rb$,handlers\/ruby\/[^\/]+\.rb$'
+  # end
+rescue LoadError
+end if ENV['COVERAGE']
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'yard'))
+
+unless defined?(HAVE_RIPPER)
+  begin require 'ripper'; rescue LoadError; end
+  HAVE_RIPPER = defined?(::Ripper) && !ENV['LEGACY'] ? true : false
+  LEGACY_PARSER = !HAVE_RIPPER
+
+  class YARD::Parser::SourceParser
+    def self.parser_type; :ruby18 end
+  end if ENV['LEGACY']
+end
+
+def parse_file(file, thisfile = __FILE__, log_level = log.level, ext = '.rb.txt')
+  Registry.clear
+  path = File.join(File.dirname(thisfile), 'examples', file.to_s + ext)
+  YARD::Parser::SourceParser.parse(path, [], log_level)
+end
+
+def described_in_docs(klass, meth, file = nil)
+  YARD::Tags::Library.define_tag "RSpec Specification", :it, :with_raw_title_and_text
+
+  # Parse the file (could be multiple files)
+  if file
+    filename = File.join(YARD::ROOT, file)
+    YARD::Parser::SourceParser.new.parse(filename)
+  else
+    underscore = klass.class_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.gsub('::', '/')
+    $".find_all {|p| p.include? underscore }.each do |filename|
+      next unless File.exist? filename
+      YARD::Parser::SourceParser.new.parse(filename)
+    end
+  end
+
+  # Get the object
+  objname = klass.name + (meth[0,1] == '#' ? meth : '::' + meth)
+  obj = Registry.at(objname)
+  raise "Cannot find object #{objname} described by spec." unless obj
+  raise "#{obj.path} has no @it tags to spec." unless obj.has_tag? :it
+
+  # Run examples
+  describe(klass, meth) do
+    obj.tags(:it).each do |it|
+      path = File.relative_path(YARD::ROOT, obj.file)
+      it(it.name + " (from #{path}:#{obj.line})") do
+        begin
+          eval(it.text)
+        rescue => e
+          e.set_backtrace(["#{path}:#{obj.line}:in @it tag specification"])
+          raise e
+        end
+      end
+    end
+  end
+end
+
+def docspec(objname = self.class.description, klass = self.class.described_type)
+  # Parse the file (could be multiple files)
+  underscore = klass.class_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.gsub('::', '/')
+  $".find_all {|p| p.include? underscore }.each do |filename|
+    filename = File.join(YARD::ROOT, filename)
+    next unless File.exist? filename
+    YARD::Parser::SourceParser.new.parse(filename)
+  end
+
+  # Get the object
+  objname = klass.name + objname if objname =~ /^[^A-Z]/
+  obj = Registry.at(objname)
+  raise "Cannot find object #{objname} described by spec." unless obj
+  raise "#{obj.path} has no @example tags to spec." unless obj.has_tag? :example
+
+  # Run examples
+  obj.tags(:example).each do |exs|
+    exs.text.split(/\n/).each do |ex|
+      begin
+        hash = eval("{ #{ex} }")
+        hash.keys.first.should == hash.values.first
+      rescue => e
+        raise e, "#{e.message}\nInvalid spec example in #{objname}:\n\n\t#{ex}\n"
+      end
+    end
+  end
+end
+
+module Kernel
+  require 'cgi'
+
+  def p(*args)
+    puts args.map {|arg| CGI.escapeHTML(arg.inspect) }.join("<br/>\n")
+    args.first
+  end
+
+  def puts(str = '')
+    STDOUT.puts str + "<br/>\n"
+    str
+  end
+end if ENV['TM_APP_PATH']
+
+RSpec.configure do |config|
+  config.before(:each) { log.io = StringIO.new }
+end
+
+include YARD