deg-yard 0.8.7.1

data/lib/yard/serializers/stdout_serializer.rb

@@ -0,0 +1,32 @@
+module YARD
+  module Serializers
+    # A serializer that writes data to standard output.
+    class StdoutSerializer < Base
+      # Creates a serializer to print text to stdout
+      #
+      # @param [Fixnum, nil] wrap if wrap is a number, wraps text to +wrap+
+      #   columns, otherwise no wrapping is done.
+      def initialize(wrap = nil)
+        @wrap = wrap
+      end
+
+      # Overrides serialize behaviour to write data to standard output
+      def serialize(object, data)
+        print(@wrap ? word_wrap(data, @wrap) : data)
+      end
+
+      private
+
+      # Wraps text to a specific column length
+      #
+      # @param [String] text the text to wrap
+      # @param [Fixnum] length the column length to wrap to
+      # @return [String] the wrapped text
+      def word_wrap(text, length = 80)
+        # See ruby-talk/10655 / Ernest Ellingson
+        text.gsub(/\t/,"     ").gsub(/.{1,50}(?:\s|\Z)/){($& +
+          5.chr).gsub(/\n\005/,"\n").gsub(/\005/,"\n")}
+      end
+    end
+  end
+end

data/lib/yard/serializers/yardoc_serializer.rb

@@ -0,0 +1,124 @@
+module YARD
+  # Stubs marshal dumps and acts a delegate class for an object by path
+  #
+  # @private
+  class StubProxy
+    instance_methods.each {|m| undef_method(m) unless m.to_s =~ /^__|^object_id$/ }
+
+    def _dump(depth) @path end
+    def self._load(str) new(str) end
+    def hash; @path.hash end
+
+    def initialize(path, transient = false)
+      @path = path
+      @transient = transient
+    end
+
+    def method_missing(meth, *args, &block)
+      return true if meth == :respond_to? && args.first == :_dump
+      @object = nil if @transient
+      @object ||= Registry.at(@path)
+      @object.send(meth, *args, &block)
+    rescue NoMethodError => e
+      e.backtrace.delete_if {|l| l[0, __FILE__.size] == __FILE__ }
+      raise
+    end
+  end
+
+  module Serializers
+    class YardocSerializer < FileSystemSerializer
+      def initialize(yfile)
+        super(:basepath => yfile, :extension => 'dat')
+      end
+
+      def objects_path; File.join(basepath, 'objects') end
+      # @deprecated The registry no longer tracks proxy types
+      def proxy_types_path; File.join(basepath, 'proxy_types') end
+      def checksums_path; File.join(basepath, 'checksums') end
+      def object_types_path; File.join(basepath, 'object_types') end
+
+      def serialized_path(object)
+        path = case object
+        when String, Symbol
+          object = object.to_s
+          if object =~ /#/
+            object += '_i'
+          elsif object =~ /\./
+            object += '_c'
+          end
+          object.split(/::|\.|#/).map do |p|
+            p.gsub(/[^\w\.-]/) do |x|
+              encoded = '_'
+
+              x.each_byte { |b| encoded << ("%X" % b) }
+              encoded
+            end
+          end.join('/') + '.' + extension
+        when YARD::CodeObjects::RootObject
+          'root.dat'
+        else
+          super(object)
+        end
+        File.join('objects', path)
+      end
+
+      def serialize(object)
+        if Hash === object
+          super(object[:root], dump(object)) if object[:root]
+        else
+          super(object, dump(object))
+        end
+      end
+
+      def deserialize(path, is_path = false)
+        path = File.join(basepath, serialized_path(path)) unless is_path
+        if File.file?(path)
+          log.debug "Deserializing #{path}..."
+          Marshal.load(File.read_binary(path))
+        else
+          log.debug "Could not find #{path}"
+          nil
+        end
+      end
+
+      private
+
+      def dump(object)
+        object = internal_dump(object, true) unless object.is_a?(Hash)
+        Marshal.dump(object)
+      end
+
+      def internal_dump(object, first_object = false)
+        if !first_object && object.is_a?(CodeObjects::Base) &&
+            !(Tags::OverloadTag === object)
+          return StubProxy.new(object.path)
+        end
+
+        if object.is_a?(Hash) || object.is_a?(Array) ||
+            object.is_a?(CodeObjects::Base) ||
+            object.instance_variables.size > 0
+          object = object.dup
+        end
+
+        object.instance_variables.each do |ivar|
+          ivar_obj = object.instance_variable_get(ivar)
+          ivar_obj_dump = internal_dump(ivar_obj)
+          object.instance_variable_set(ivar, ivar_obj_dump)
+        end
+
+        case object
+        when Hash
+          list = object.map do |k, v|
+            [k, v].map {|item| internal_dump(item) }
+          end
+          object.replace(Hash[list])
+        when Array
+          list = object.map {|item| internal_dump(item) }
+          object.replace(list)
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/yard/server/adapter.rb

@@ -0,0 +1,100 @@
+module YARD
+  module Server
+
+    # Short circuits a request by raising an error. This exception is caught
+    # by {Commands::Base#call} to immediately end a request and return a response.
+    class FinishRequest < RuntimeError; end
+
+    # Raises an error if a resource is not found. This exception is caught by
+    # {Commands::Base#call} to immediately end a request and return a 404 response
+    # code. If a message is provided, the body is set to the exception message.
+    class NotFoundError < RuntimeError; end
+
+    # This class implements the bridge between the {Router} and the server
+    # backend for a specific server type. YARD implements concrete adapters
+    # for WEBrick and Rack respectively, though other adapters can be made
+    # for other server architectures.
+    #
+    # == Subclassing Notes
+    # To create a concrete adapter class, implement the {#start} method to
+    # initiate the server backend.
+    #
+    # @abstract
+    class Adapter
+      # @return [String] the location where static files are located, if any.
+      #   To set this field on initialization, pass +:DocumentRoot+ to the
+      #   +server_opts+ argument in {#initialize}
+      attr_accessor :document_root
+
+      # @return [Hash{String=>Array<LibraryVersion>}] a map of libraries.
+      # @see LibraryVersion LibraryVersion for information on building a list of libraries
+      # @see #add_library
+      attr_accessor :libraries
+
+      # @return [Hash] options passed and processed by adapters. The actual
+      #   options mostly depend on the adapters themselves.
+      attr_accessor :options
+
+      # @return [Hash] a set of options to pass to the server backend. Note
+      #   that +:DocumentRoot+ also sets the {#document_root}.
+      attr_accessor :server_options
+
+      # @return [Router] the router object used to route URLs to commands
+      attr_accessor :router
+
+      # Performs any global initialization for the adapter.
+      # @note If you subclass this method, make sure to call +super+.
+      # @return [void]
+      def self.setup
+        Templates::Template.extra_includes |= [YARD::Server::DocServerHelper]
+        Templates::Engine.template_paths |= [File.dirname(__FILE__) + '/templates']
+      end
+
+      # Performs any global shutdown procedures for the adapter.
+      # @note If you subclass this method, make sure to call +super+.
+      # @return [void]
+      def self.shutdown
+        Templates::Template.extra_includes -= [YARD::Server::DocServerHelper]
+        Templates::Engine.template_paths -= [File.dirname(__FILE__) + '/templates']
+      end
+
+      # Creates a new adapter object
+      #
+      # @param [Hash{String=>Array<LibraryVersion>}] libs a list of libraries,
+      #   see {#libraries} for formulating this list.
+      # @param [Hash] opts extra options to pass to the adapter
+      # @option opts [Class] :router (Router) the router class to initialize as the
+      #   adapter's router.
+      # @option opts [Boolean] :caching (false) whether or not caching is enabled
+      # @option opts [Boolean] :single_library (false) whether to server documentation
+      #   for a single or multiple libraries (changes URL structure)
+      def initialize(libs, opts = {}, server_opts = {})
+        self.class.setup
+        self.libraries = libs
+        self.options = opts
+        self.server_options = server_opts
+        self.document_root = server_options[:DocumentRoot]
+        self.router = (options[:router] || Router).new(self)
+        options[:adapter] = self
+        log.debug "Serving libraries using #{self.class}: #{libraries.keys.join(', ')}"
+        log.debug "Caching on" if options[:caching]
+        log.debug "Document root: #{document_root}" if document_root
+      end
+
+      # Adds a library to the {#libraries} mapping for a given library object.
+      # @example Adding a new library to an adapter
+      #   adapter.add_library LibraryVersion.new('mylib', '1.0', '/path/to/.yardoc')
+      # @param [LibraryVersion] library a library to add
+      def add_library(library)
+        libraries[library.name] ||= []
+        libraries[library.name] |= [library]
+      end
+
+      # Implement this method to connect your adapter to your server.
+      # @abstract
+      def start
+        raise NotImplementedError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+require 'fileutils'
+
+module YARD
+  module Server
+    module Commands
+      # This is the base command class used to implement custom commands for
+      # a server. A command will be routed to by the {Router} class and return
+      # a Rack-style response.
+      #
+      # == Attribute Initializers
+      # All attributes can be initialized via options passed into the {#initialize}
+      # method. When creating a custom command, the {Adapter#options} will
+      # automatically be mapped to attributes by the same name on your class.
+      #
+      #   class MyCommand < Base
+      #     attr_accessor :myattr
+      #   end
+      #
+      #   Adapter.new(libs, {:myattr => 'foo'}).start
+      #
+      #   # when a request comes in, cmd.myattr == 'foo'
+      #
+      # == Subclassing Notes
+      # To implement a custom command, override the {#run} method, not {#call}.
+      # In your implementation, you should set the body and status for requests.
+      # See details in the +#run+ method documentation.
+      #
+      # Note that if your command deals directly with libraries, you should
+      # consider subclassing the more specific {LibraryCommand} class instead.
+      #
+      # @abstract
+      # @see #run
+      class Base
+        # @group Basic Command and Adapter Options
+
+        # @return [Hash] the options passed to the command's constructor
+        attr_accessor :command_options
+
+        # @return [Adapter] the server adapter
+        attr_accessor :adapter
+
+        # @return [Boolean] whether to cache
+        attr_accessor :caching
+
+        # @group Attributes Set Per Request
+
+        # @return [Request] request object
+        attr_accessor :request
+
+        # @return [String] the path after the command base URI
+        attr_accessor :path
+
+        # @return [Hash{String => String}] response headers
+        attr_accessor :headers
+
+        # @return [Numeric] status code. Defaults to 200 per request
+        attr_accessor :status
+
+        # @return [String] the response body. Defaults to empty string.
+        attr_accessor :body
+
+        # @group Instance Method Summary
+
+        # Creates a new command object, setting attributes named by keys
+        # in the options hash. After initialization, the options hash
+        # is saved in {#command_options} for further inspection.
+        #
+        # @example Creating a Command
+        #   cmd = DisplayObjectCommand.new(:caching => true, :library => mylib)
+        #   cmd.library # => mylib
+        #   cmd.command_options # => {:caching => true, :library => mylib}
+        # @param [Hash] opts the options hash, saved to {#command_options}
+        #   after initialization.
+        def initialize(opts = {})
+          opts.each do |key, value|
+            send("#{key}=", value) if respond_to?("#{key}=")
+          end
+          self.command_options = opts
+        end
+
+        # The main method called by a router with a request object.
+        #
+        # @note This command should not be overridden by subclasses. Implement
+        #   the callback method {#run} instead.
+        # @param [Adapter Dependent] request the request object
+        # @return [Array(Numeric,Hash,Array<String>)] a Rack-style response
+        #   of status, headers, and body wrapped in an array.
+        def call(request)
+          self.request = request
+          self.path ||= request.path[1..-1]
+          self.headers = {'Content-Type' => 'text/html'}
+          self.body = ''
+          self.status = 200
+          begin
+            run
+          rescue FinishRequest
+          rescue NotFoundError => e
+            self.body = e.message if e.message != e.class.to_s
+            self.status = 404
+          end
+          not_found if status == 404
+          [status, headers, body.is_a?(Array) ? body : [body]]
+        end
+
+        # @group Abstract Methods
+
+        # Subclass this method to implement a custom command. This method
+        # should set the {#status} and {#body}, and optionally modify the
+        # {#headers}. Note that +#status+ defaults to 200.
+        #
+        # @example A custom command
+        #   class ErrorCommand < Base
+        #     def run
+        #       self.body = 'ERROR! The System is down!'
+        #       self.status = 500
+        #       self.headers['Conten-Type'] = 'text/plain'
+        #     end
+        #   end
+        #
+        # @abstract
+        # @return [void]
+        def run
+          raise NotImplementedError
+        end
+
+        protected
+
+        # @group Helper Methods
+
+        # Renders a specific object if provided, or a regular template rendering
+        # if object is not provided.
+        #
+        # @todo This method is dependent on +#options+, it should be in {LibraryCommand}.
+        # @param [CodeObjects::Base, nil] object calls {CodeObjects::Base#format} if
+        #   an object is provided, or {Templates::Engine.render} if object is nil. Both
+        #   receive +#options+ as an argument.
+        # @return [String] the resulting output to display
+        def render(object = nil)
+          case object
+          when CodeObjects::Base
+            cache object.format(options)
+          when nil
+            cache Templates::Engine.render(options)
+          else
+            cache object
+          end
+        end
+
+        # Override this method to implement custom caching mechanisms for
+        #
+        # @example Caching to memory
+        #   $memory_cache = {}
+        #   def cache(data)
+        #     $memory_cache[path] = data
+        #   end
+        # @param [String] data the data to cache
+        # @return [String] the same cached data (for chaining)
+        # @see StaticCaching
+        def cache(data)
+          if caching && adapter.document_root
+            path = File.join(adapter.document_root, request.path.sub(/\.html$/, '') + '.html')
+            path = path.sub(%r{/\.html$}, '.html')
+            FileUtils.mkdir_p(File.dirname(path))
+            log.debug "Caching data to #{path}"
+            File.open(path, 'wb') {|f| f.write(data) }
+          end
+          self.body = data
+        end
+
+        # Sets the body and headers (but not status) for a 404 response. Does
+        # nothing if the body is already set.
+        #
+        # @return [void]
+        def not_found
+          return unless body.empty?
+          self.body = "Not found: #{request.path}"
+          self.headers['Content-Type'] = 'text/plain'
+          self.headers['X-Cascade'] = 'pass'
+        end
+
+        # Sets the headers and status code for a redirection to a given URL
+        # @param [String] url the URL to redirect to
+        # @raise [FinishRequest] causes the request to terminate.
+        def redirect(url)
+          headers['Location'] = url
+          self.status = 302
+          raise FinishRequest
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module YARD
+  module Server
+    module Commands
+      # Displays a README or extra file.
+      #
+      # @todo Implement better support for detecting binary (image) filetypes
+      class DisplayFileCommand < LibraryCommand
+        def run
+          ppath = library.source_path
+          filename = File.cleanpath(File.join(library.source_path, path))
+          raise NotFoundError if !File.file?(filename)
+          if filename =~ /\.(jpe?g|gif|png|bmp)$/i
+            headers['Content-Type'] = StaticFileCommand::DefaultMimeTypes[$1.downcase] || 'text/html'
+            render IO.read(filename)
+          else
+            file = CodeObjects::ExtraFileObject.new(filename)
+            options.update(:object => Registry.root, :type => :layout, :file => file)
+            render
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module YARD
+  module Server
+    module Commands
+      # Displays documentation for a specific object identified by the path
+      class DisplayObjectCommand < LibraryCommand
+        include DocServerHelper
+
+        def run
+          if path.empty?
+            if options.readme
+              url = url_for_file(options.readme)
+              self.status, self.headers, self.body = *router.send(:route, url)
+              cache(body.first)
+              return
+            else
+              self.path = 'index'
+            end
+          end
+          return index if path == 'index'
+
+          if object = Registry.at(object_path)
+            options.update(:type => :layout)
+            render(object)
+          else
+            self.status = 404
+          end
+        end
+
+        def index
+          Registry.load_all
+
+          options.update(
+            :object => '_index.html',
+            :objects => Registry.all(:module, :class),
+            :type => :layout
+          )
+          render
+        end
+
+        def not_found
+          super
+          self.body = "Could not find object: #{object_path}"
+        end
+
+        private
+
+        def object_path
+          return @object_path if @object_path
+          if path == "toplevel"
+            @object_path = :root
+          else
+            @object_path = path.sub(':', '#').gsub('/', '::').sub(/^toplevel\b/, '').sub(/\.html$/, '')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module YARD
+  module Server
+    module Commands
+      # Displays an object wrapped in frames
+      class FramesCommand < DisplayObjectCommand
+        def run
+          options.update(:frames => true, :type => :fulldoc)
+          tpl = fulldoc_template
+          tpl.generate_frameset
+          cache(tpl.contents)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+require 'thread'
+
+module YARD
+  module Server
+    module Commands
+      class LibraryOptions < CLI::YardocOptions
+        def adapter; @command.adapter end
+        def library; @command.library end
+        def single_library; @command.single_library end
+        def serializer; @command.serializer end
+        def serialize; false end
+
+        attr_accessor :command
+        attr_accessor :frames
+
+        def each(&block)
+          super(&block)
+          yield(:adapter, adapter)
+          yield(:library, library)
+          yield(:single_library, single_library)
+          yield(:serializer, serializer)
+        end
+      end
+
+      # This is the base command for all commands that deal directly with libraries.
+      # Some commands do not, but most (like {DisplayObjectCommand}) do. If your
+      # command deals with libraries directly, subclass this class instead.
+      # See {Base} for notes on how to subclass a command.
+      #
+      # @abstract
+      class LibraryCommand < Base
+        # @return [LibraryVersion] the object containing library information
+        attr_accessor :library
+
+        # @return [LibraryOptions] default options for the library
+        attr_accessor :options
+
+        # @return [Serializers::Base] the serializer used to perform file linking
+        attr_accessor :serializer
+
+        # @return [Boolean] whether router should route for multiple libraries
+        attr_accessor :single_library
+
+        # @return [Boolean] whether to reparse data
+        attr_accessor :incremental
+
+        # Needed to synchronize threads in {#setup_yardopts}
+        # @private
+        @@library_chdir_lock = Mutex.new
+
+        def initialize(opts = {})
+          super
+          self.serializer = DocServerSerializer.new
+        end
+
+        def call(request)
+          save_default_template_info
+          self.request = request
+          self.options = LibraryOptions.new
+          self.options.reset_defaults
+          self.options.command = self
+          setup_library
+          self.options.title = "Documentation for #{library.name} " +
+            (library.version ? '(' + library.version + ')' : '')
+          super
+        rescue LibraryNotPreparedError
+          not_prepared
+        ensure
+          restore_template_info
+        end
+
+        private
+
+        def save_default_template_info
+          @old_template_paths = Templates::Engine.template_paths.dup
+          @old_extra_includes = Templates::Template.extra_includes.dup
+        end
+
+        def restore_template_info
+          Templates::Engine.template_paths = @old_template_paths
+          Templates::Template.extra_includes = @old_extra_includes
+        end
+
+        def setup_library
+          library.prepare! if request.xhr? && request.query['process']
+          load_yardoc
+          setup_yardopts
+          true
+        end
+
+        def setup_yardopts
+          @@library_chdir_lock.synchronize do
+            Dir.chdir(library.source_path) do
+              yardoc = CLI::Yardoc.new
+              if incremental
+                yardoc.run('-c', '-n', '--no-stats')
+              else
+                yardoc.parse_arguments
+              end
+              yardoc.send(:verify_markup_options)
+              yardoc.options.delete(:serializer)
+              yardoc.options.delete(:serialize)
+              options.update(yardoc.options.to_hash)
+            end
+          end
+        end
+
+        def load_yardoc
+          raise LibraryNotPreparedError unless library.yardoc_file
+          if Thread.current[:__yard_last_yardoc__] == library.yardoc_file
+            log.debug "Reusing yardoc file: #{library.yardoc_file}"
+            return
+          end
+          Registry.clear
+          Templates::ErbCache.clear!
+          Registry.load_yardoc(library.yardoc_file)
+          Thread.current[:__yard_last_yardoc__] = library.yardoc_file
+        end
+
+        def not_prepared
+          self.caching = false
+          options.update(:template => :doc_server, :type => :processing)
+          [202, {'Content-Type' => 'text/html'}, [render]]
+        end
+
+        # Hack to load a custom fulldoc template object that does
+        # not do any rendering/generation. We need this to access the
+        # generate_*_list methods.
+        def fulldoc_template
+          tplopts = [options.template, :fulldoc, options.format]
+          tplclass = Templates::Engine.template(*tplopts)
+          obj = Object.new.extend(tplclass)
+          class << obj; def init; end end
+          obj.class = tplclass
+          obj.send(:initialize, options)
+          class << obj
+            attr_reader :contents
+            def asset(file, contents) @contents = contents end
+          end
+          obj
+        end
+
+        # @private
+        @@last_yardoc = nil
+      end
+    end
+  end
+end