yard 0.5.8 → 0.6.0

data/lib/yard/server/commands/library_index_command.rb

@@ -0,0 +1,23 @@
+module YARD
+  module Server
+    module Commands
+      class LibraryIndexCommand < Base
+        attr_accessor :options
+        
+        def run
+          return unless path.empty?
+          
+          self.options = SymbolHash.new(false).update(
+            :markup => :rdoc,
+            :format => :html,
+            :libraries => adapter.libraries,
+            :adapter => adapter,
+            :template => :doc_server,
+            :type => :library_list
+          )
+          render
+        end
+      end
+    end
+  end
+end

data/lib/yard/server/commands/list_command.rb

@@ -0,0 +1,44 @@
+module YARD
+  module Server
+    module Commands
+      class ListCommand < LibraryCommand
+        include Templates::Helpers::BaseHelper
+        
+        def items; raise NotImplementedError end
+        def type; raise NotImplementedError end
+
+        def run
+          options.update(:items => items, :template => :doc_server, 
+                         :list_type => request.path.split('/').last, :type => :full_list)
+          render
+        end
+      end
+      
+      class ListClassesCommand < ListCommand
+        def type; :class end
+        
+        def items
+          Registry.load_all
+          run_verifier(Registry.all(:class, :module))
+        end
+      end
+      
+      class ListMethodsCommand < ListCommand
+        include Templates::Helpers::ModuleHelper
+        
+        def type; :methods end
+        
+        def items
+          Registry.load_all
+          items = Registry.all(:method).sort_by {|m| m.name.to_s }
+          prune_method_listing(items)
+        end
+      end
+      
+      class ListFilesCommand < ListCommand
+        def type; :files end
+        def items; options[:files] end
+      end
+    end
+  end
+end

data/lib/yard/server/commands/search_command.rb

@@ -0,0 +1,67 @@
+module YARD
+  module Server
+    module Commands
+      class SearchCommand < LibraryCommand
+        attr_accessor :results, :query
+        
+        def run
+          Registry.load_all
+          self.query = request.query['q']
+          redirect("/#{adapter.router.docs_prefix}/#{single_library ? library : ''}") if query =~ /\A\s*\Z/
+          if found = Registry.at(query)
+            redirect(serializer.serialized_path(found))
+          end
+          search_for_object
+          request.xhr? ? serve_xhr : serve_normal
+        end
+        
+        def visible_results
+          results[0, 10]
+        end
+        
+        private
+        
+        def serve_xhr
+          self.headers['Content-Type'] = 'text/plain'
+          self.body = visible_results.map {|o| 
+            [(o.type == :method ? o.name(true) : o.name).to_s,
+             o.path,
+             o.namespace.root? ? '' : o.namespace.path,
+             serializer.serialized_path(o)
+            ].join(",")
+          }.join("\n")
+        end
+        
+        def serve_normal
+          options.update(
+            :visible_results => visible_results,
+            :query => query,
+            :results => results,
+            :template => :doc_server,
+            :type => :search
+          )
+          self.body = Templates::Engine.render(options)
+        end
+        
+        def search_for_object
+          splitquery = query.split(/\s+/).map {|c| c.downcase }.reject {|m| m.empty? }
+          self.results = Registry.all.select {|o|
+              o.path.downcase.include?(query.downcase)
+            }.reject {|o|
+              name = (o.type == :method ? o.name(true) : o.name).to_s.downcase
+              !name.include?(query.downcase) ||
+              case o.type
+              when :method
+                !(query =~ /[#.]/) && query.include?("::")
+              when :class, :module, :constant, :class_variable
+                query =~ /[#.]/
+              end 
+            }.sort_by {|o|
+              name = (o.type == :method ? o.name(true) : o.name).to_s
+              name.length.to_f / query.length.to_f
+            }
+        end
+      end
+    end
+  end
+end

data/lib/yard/server/commands/static_file_command.rb

@@ -0,0 +1,45 @@
+require 'webrick/httputils'
+
+module YARD
+  module Server
+    module Commands
+      class StaticFileCommand < Base
+        include WEBrick::HTTPUtils
+
+        DefaultMimeTypes['js'] = 'text/javascript'
+
+        STATIC_PATHS = [
+          File.join(YARD::TEMPLATE_ROOT, 'default', 'fulldoc', 'html'),
+          File.join(File.dirname(__FILE__), '..', 'templates', 'default', 'fulldoc', 'html')
+        ]
+        
+        def run
+          path = File.cleanpath(request.path).gsub(%r{^(../)+}, '')
+          ([adapter.document_root] + STATIC_PATHS).compact.each do |path_prefix|
+            file = File.join(path_prefix, path)
+            if File.exist?(file)
+              ext = "." + (request.path[/\.(\w+)$/, 1] || "html")
+              headers['Content-Type'] = mime_type(ext, DefaultMimeTypes)
+              self.body = File.read(file)
+              return
+            end
+          end
+          favicon?
+          self.status = 404
+        end
+        
+        private
+        
+        # Return an empty favicon.ico if it does not exist so that
+        # browsers don't complain.
+        def favicon?
+          return unless request.path == '/favicon.ico'
+          self.headers['Content-Type'] = 'image/png'
+          self.status = 200
+          self.body = ''
+          raise FinishRequest
+        end
+      end
+    end
+  end
+end

data/lib/yard/server/doc_server_helper.rb

@@ -0,0 +1,22 @@
+module YARD
+  module Server
+    module DocServerHelper
+      def url_for(obj, anchor = nil, relative = false)
+        return '' if obj.nil?
+        return "/#{obj}" if String === obj
+        super(obj, anchor, false)
+      end
+
+      def url_for_file(filename, anchor = nil)
+        "/#{base_path(router.docs_prefix)}/file/" + filename.sub(%r{^#{@library.source_path.to_s}/}, '') + 
+          (anchor ? "##{anchor}" : "")
+      end
+      
+      def base_path(path)
+        path + (@single_library ? '' : "/#{@library}")
+      end
+      
+      def router; @adapter.router end
+    end
+  end
+end

data/lib/yard/server/doc_server_serializer.rb

@@ -0,0 +1,29 @@
+require 'webrick/httputils'
+
+module YARD
+  module Server
+    class DocServerSerializer < Serializers::FileSystemSerializer
+      include WEBrick::HTTPUtils
+      
+      def initialize(command)
+        super(:command => command, :extension => '')
+      end
+
+      def serialized_path(object)
+        path = case object
+        when CodeObjects::RootObject
+          "toplevel"
+        when CodeObjects::MethodObject
+          return escape_path(serialized_path(object.namespace) + (object.scope == :instance ? ":" : ".") + object.name.to_s)
+        when CodeObjects::ConstantObject, CodeObjects::ClassVariableObject
+          return escape_path(serialized_path(object.namespace)) + "##{object.name}-#{object.type}"
+        else
+          object.path.gsub('::', '/')
+        end
+        command = options[:command]
+        library_path = command.single_library ? '' : '/' + command.library.to_s
+        return escape_path(File.join('', command.adapter.router.docs_prefix, library_path, path))
+      end
+    end
+  end
+end

data/lib/yard/server/library_version.rb

@@ -0,0 +1,86 @@
+require 'fileutils'
+
+module YARD
+  module Server
+    class LibraryNotPreparedError < RuntimeError; end
+    
+    class LibraryVersion
+      attr_accessor :name
+      attr_accessor :version
+      attr_accessor :yardoc_file
+      attr_accessor :source
+      attr_accessor :source_path
+      
+      def initialize(name, version = nil, yardoc = nil, source = :disk)
+        self.name = name
+        self.yardoc_file = yardoc
+        self.version = version
+        self.source = source
+        self.source_path = load_source_path
+      end
+      
+      def to_s(url_format = true)
+        version ? "#{name}#{url_format ? '/' : '-'}#{version}" : "#{name}"
+      end
+      
+      def hash; to_s.hash end
+      
+      def eql?(other)
+        other.is_a?(LibraryVersion) && other.name == name && 
+          other.version == version && other.yardoc_file == yardoc_file
+      end
+      alias == eql?
+      alias equal? eql?
+      
+      def prepare!
+        return if yardoc_file
+        meth = "load_yardoc_from_#{source}"
+        send(meth) if respond_to?(meth)
+      end
+      
+      def gemspec
+        ver = version ? "= #{version}" : ">= 0"
+        Gem.source_index.find_name(name, ver).first
+      end
+      
+      protected
+
+      def load_yardoc_from_disk
+        nil
+      end
+      
+      def load_yardoc_from_gem
+        require 'rubygems'
+        ver = version ? "= #{version}" : ">= 0"
+        self.yardoc_file = Registry.yardoc_file_for_gem(name, ver)
+        unless yardoc_file && File.directory?(yardoc_file)
+          Thread.new do
+            # Build gem docs on demand
+            log.debug "Building gem docs for #{to_s(false)}"
+            CLI::Gems.run(name, ver)
+            self.yardoc_file = Registry.yardoc_file_for_gem(name, ver)
+            FileUtils.touch(File.join(yardoc_file, 'complete'))
+          end
+        end
+        unless yardoc_file && File.exist?(File.join(yardoc_file, 'complete'))
+          raise LibraryNotPreparedError
+        end
+      end
+      
+      def source_path_for_disk
+        File.dirname(yardoc_file) if yardoc_file
+      end
+      
+      def source_path_for_gem
+        gemspec.full_gem_path if gemspec
+      end
+      
+      private
+      
+      def load_source_path
+        meth = "source_path_for_#{source}"
+        send(meth) if respond_to?(meth)
+      end
+    end
+  end
+end

data/lib/yard/server/rack_adapter.rb

@@ -0,0 +1,38 @@
+require 'rack'
+require 'webrick/httputils'
+
+module YARD
+  module Server
+    class RackMiddleware
+      def initialize(app, opts = {})
+        args = [opts[:libraries] || {}, opts[:options] || {}, opts[:server_options] || {}]
+        @app = RackAdapter.new(*args)
+      end
+      
+      def call(env) @app.call(env) end
+    end
+    
+    class RackAdapter < Adapter
+      include WEBrick::HTTPUtils
+      
+      def call(env)
+        request = Rack::Request.new(env)
+        request.path_info = unescape(request.path_info) # unescape things like %3F
+        router.call(request)
+      end
+      
+      def start
+        server = Rack::Server.new(server_options)
+        server.instance_variable_set("@app", self)
+        trap("INT") { server.shutdown }
+        server.start
+      end
+    end
+  end
+end
+
+# @private
+class Rack::Request
+  alias query params
+  def xhr?; (env['HTTP_X_REQUESTED_WITH'] || "").downcase == "xmlhttprequest" end
+end

data/lib/yard/server/router.rb

@@ -0,0 +1,110 @@
+module YARD
+  module Server
+    class Router
+      include StaticCaching
+      include Commands
+      
+      attr_accessor :request
+      
+      attr_accessor :adapter
+      
+      def initialize(adapter)
+        self.adapter = adapter
+      end
+      
+      def call(request)
+        self.request = request
+        if result = (check_static_cache || route)
+          result
+        else
+          StaticFileCommand.new(adapter.options).call(request)
+        end
+      end
+
+      def docs_prefix; 'docs' end
+      def list_prefix; 'list' end
+      def search_prefix; 'search' end
+      
+      # @return [Array(LibraryVersion, Array<String>)] the library followed
+      #   by the rest of the path components in the request path. LibraryVersion
+      #   will be nil if no matching library was found.
+      def parse_library_from_path(paths)
+        return [adapter.libraries.values.first.first, paths] if adapter.options[:single_library]
+        library, paths = nil, paths.dup
+        if libs = adapter.libraries[paths.first]
+          paths.shift
+          if library = libs.find {|l| l.version == paths.first }
+            paths.shift
+          else # use the last lib in the list
+            library = libs.last
+          end
+        end
+        [library, paths]
+      end
+
+      private
+      
+      def route
+        path = request.path.gsub(%r{//+}, '/').gsub(%r{^/|/$}, '')
+        return route_index if path.empty? || path == docs_prefix
+        case path
+        when /^(#{docs_prefix}|#{list_prefix}|#{search_prefix})(\/.*|$)/
+          prefix = $1
+          paths = $2.gsub(%r{^/|/$}, '').split('/')
+          library, paths = *parse_library_from_path(paths)
+          return unless library
+          return case prefix
+          when docs_prefix;   route_docs(library, paths)
+          when list_prefix;   route_list(library, paths)
+          when search_prefix; route_search(library, paths)
+          end
+        end
+        nil
+      end
+      
+      def route_docs(library, paths)
+        return route_index if library.nil?
+        case paths.first
+        when "frames"
+          paths.shift
+          cmd = FramesCommand
+        when "file"
+          paths.shift
+          cmd = DisplayFileCommand
+        else
+          cmd = DisplayObjectCommand
+        end
+        cmd = cmd.new(final_options(library, paths))
+        cmd.call(request)
+      end
+      
+      def route_index
+        if adapter.options[:single_library]
+          route_docs(adapter.libraries.values.first.first, [])
+        else
+          LibraryIndexCommand.new(adapter.options.merge(:path => '')).call(request)
+        end
+      end
+      
+      def route_list(library, paths)
+        return if paths.empty?
+        case paths.shift
+        when "class";   cmd = ListClassesCommand
+        when "methods"; cmd = ListMethodsCommand
+        when "files";   cmd = ListFilesCommand
+        else; return
+        end
+        cmd.new(final_options(library, paths)).call(request)
+      end
+      
+      def route_search(library, paths)
+        return unless paths.empty?
+        SearchCommand.new(final_options(library, paths)).call(request)
+      end
+      
+      def final_options(library, paths)
+        adapter.options.merge(:library => library, :path => paths.join('/'))
+      end
+    end
+  end
+end