yard 0.6.8 → 0.7.0

data/lib/yard/rubygems/specification.rb

@@ -24,7 +24,7 @@ class Gem::Specification
   else
     attr_accessor :has_rdoc
   end
-  
+
   if defined?(Gem::VERSION) && Gem::VERSION =~ /^1\.7\./
     def _dump_with_rdoc(limit)
       dmp = _dump_without_rdoc(limit)
@@ -33,7 +33,7 @@ class Gem::Specification
     end
     alias _dump_without_rdoc _dump
     alias _dump _dump_with_rdoc
-  
+
     @@default_value[:has_rdoc] = true if defined?(@@default_value)
     @@attributes << 'has_rdoc' if defined?(@@attributes)
     @@nil_attributes << 'has_rdoc' if defined?(@@nil_attributes)

data/lib/yard/serializers/base.rb

@@ -3,57 +3,57 @@ module YARD
     # The abstract base serializer. Serializers allow templates to be
     # rendered to various endpoints. For instance, a {FileSystemSerializer}
     # would allow template contents to be written to the filesystem
-    # 
+    #
     # To implement a custom serializer, override the following methods:
     # * {#serialize}
     # * {#serialized_path}
-    # 
+    #
     # Optionally, a serializer can implement before and after filters:
     # * {#before_serialize}
     # * {#after_serialize}
-    # 
+    #
     # @abstract Override this class to implement a custom serializer.
     class Base
       # All serializer options are saved so they can be passed to other serializers.
-      # 
+      #
       # @return [SymbolHash] the serializer options
       attr_reader :options
-      
+
       # @group Creating a New Serializer
-      
+
       # Creates a new serializer with options
-      # 
+      #
       # @param [Hash] opts the options to assign to {#options}
       def initialize(opts = {})
         @options = SymbolHash.new(false).update(opts)
       end
-      
+
       # @group Serializing an Object
-      
+
       # Serializes an object.
-      # 
-      # @abstract This method should implement the logic that serializes 
+      #
+      # @abstract This method should implement the logic that serializes
       #   +data+ to the respective endpoint. This method should also call
       #   the before and after callbacks {#before_serialize} and {#after_serialize}
       # @param [CodeObjects::Base, String] object the object to serialize the
       #   data for. The object can also be a string (for non-object serialization)
       # @param [String] data the contents that should be serialized
       def serialize(object, data) end
-        
+
       # The serialized path of an object
-      # 
+      #
       # @abstract This method should return the path of the object on the
       #   endpoint. For instance, for a file serializer, this should return
       #   the filename that represents the object on disk.
       # @param [CodeObjects::Base] object the object to return a path for
       # @return [String] the serialized path of an object
       def serialized_path(object) end
-        
+
       # Returns whether an object has been serialized
-      # 
+      #
       # @abstract This method should return whether the endpoint already exists.
       #   For instance, a file system serializer would check if the file exists
-      #   on disk. You will most likely use +#basepath+ and {#serialized_path} to 
+      #   on disk. You will most likely use +#basepath+ and {#serialized_path} to
       #   get the endpoint's location.
       # @param [CodeObjects::Base] object the object to check existence of
       # @return [Boolean] whether the endpoint exists.
@@ -62,15 +62,15 @@ module YARD
 
       # @group Callbacks
 
-      # Called before serialization. 
-      # 
+      # Called before serialization.
+      #
       # @abstract Should run code before serialization. Should return false
       #   if serialization should not occur.
       # @return [Boolean] whether or not serialization should occur
       def before_serialize; end
 
-      # Called after serialization. 
-      # 
+      # Called after serialization.
+      #
       # @abstract Should run code after serialization.
       # @param [String] data the data that was serialized.
       # @return [void]

data/lib/yard/serializers/file_system_serializer.rb

@@ -5,22 +5,22 @@ module YARD
       # The base path to write data to.
       # @return [String] a base path
       attr_reader :basepath
-      
+
       def basepath=(value)
         @basepath = options[:basepath] = value
       end
-      
+
       # The extension of the filename (defaults to +html+)
-      # 
+      #
       # @return [String] the extension of the file. Empty string for no extension.
       attr_reader :extension
-      
+
       def extension=(value)
         @extension = options[:extension] = value
       end
-      
+
       # Creates a new FileSystemSerializer with options
-      # 
+      #
       # @option opts [String] :basepath ('doc') the base path to write data to
       # @option opts [String] :extension ('html') the extension of the serialized
       #   path filename. If this is set to the empty string, no extension is used.
@@ -29,38 +29,42 @@ module YARD
         @basepath = (options[:basepath] || 'doc').to_s
         @extension = (options.has_key?(:extension) ? options[:extension] : 'html').to_s
       end
-      
+
       # Serializes object with data to its serialized path (prefixed by the +#basepath+).
-      # 
+      #
       # @return [String] the written data (for chaining)
       def serialize(object, data)
         path = File.join(basepath, *serialized_path(object))
         log.debug "Serializing to #{path}"
         File.open!(path, "wb") {|f| f.write data }
       end
-      
+
       # Implements the serialized path of a code object.
-      # 
-      # @param [CodeObjects::Base, String] object the object to get a path for.
-      #   The path of a string is the string itself.
+      #
+      # @param [CodeObjects::Base, CodeObjects::ExtraFileObject, String] object
+      #   the object to get a path for. The path of a string is the string itself.
       # @return [String] if object is a String, returns
       #   object, otherwise the path on disk (without the basepath).
       def serialized_path(object)
         return object if object.is_a?(String)
 
-        objname = object != YARD::Registry.root ? object.name.to_s : "top-level-namespace"
-        objname += '_' + object.scope.to_s[0,1] if object.is_a?(CodeObjects::MethodObject)
-        fspath = [objname + (extension.empty? ? '' : ".#{extension}")]
-        if object.namespace && object.namespace.path != ""
-          fspath.unshift(*object.namespace.path.split(CodeObjects::NSEP))
+        if object.is_a?(CodeObjects::ExtraFileObject)
+          fspath = ['file.' + object.name + (extension.empty? ? '' : ".#{extension}")]
+        else
+          objname = object != YARD::Registry.root ? object.name.to_s : "top-level-namespace"
+          objname += '_' + object.scope.to_s[0,1] if object.is_a?(CodeObjects::MethodObject)
+          fspath = [objname + (extension.empty? ? '' : ".#{extension}")]
+          if object.namespace && object.namespace.path != ""
+            fspath.unshift(*object.namespace.path.split(CodeObjects::NSEP))
+          end
         end
-        
+
         # Don't change the filenames, it just makes it more complicated
         # to figure out the original name.
-        #fspath.map! do |p| 
-        #  p.gsub(/([a-z])([A-Z])/, '\1_\2').downcase 
+        #fspath.map! do |p|
+        #  p.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
         #end
-        
+
         # Remove special chars from filenames.
         # Windows disallows \ / : * ? " < > | but we will just remove any
         # non alphanumeric (plus period, underscore and dash).
@@ -72,12 +76,12 @@ module YARD
             encoded
           end
         end
-        
+
         File.join(fspath)
       end
-      
+
       # Checks the disk for an object and returns whether it was serialized.
-      # 
+      #
       # @param [CodeObjects::Base] object the object to check
       # @return [Boolean] whether an object has been serialized to disk
       def exists?(object)

data/lib/yard/serializers/process_serializer.rb

@@ -1,18 +1,18 @@
 module YARD
   module Serializers
     # Serializes an object to a process (like less)
-    # 
+    #
     # @example Serializing to a pager (less)
     #   serializer = ProcessSerializer.new('less')
     #   serializer.serialize(object, "data!")
     class ProcessSerializer < Base
       # Creates a new ProcessSerializer for the shell command +cmd+
-      # 
+      #
       # @param [String] cmd the command that will accept data on stdin
       def initialize(cmd)
         @cmd = cmd
       end
-      
+
       # Overrides serialize behaviour and writes data to standard input
       # of the associated command
       def serialize(object, data)

data/lib/yard/serializers/stdout_serializer.rb

@@ -3,28 +3,28 @@ module YARD
     # 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)/){($& + 
+        text.gsub(/\t/,"     ").gsub(/.{1,50}(?:\s|\Z)/){($& +
           5.chr).gsub(/\n\005/,"\n").gsub(/\005/,"\n")}
       end
     end

data/lib/yard/serializers/yardoc_serializer.rb

@@ -1,6 +1,6 @@
 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$/ }
@@ -8,12 +8,12 @@ module YARD
     def _dump(depth) @path end
     def self._load(str) new(str) end
     def hash; @path.hash end
-    
-    def initialize(path, transient = false) 
+
+    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
@@ -30,11 +30,11 @@ module YARD
       def initialize(yfile)
         super(:basepath => yfile, :extension => 'dat')
       end
-      
+
       def objects_path; File.join(basepath, 'objects') end
       def proxy_types_path; File.join(basepath, 'proxy_types') end
       def checksums_path; File.join(basepath, 'checksums') end
-      
+
       def serialized_path(object)
         path = case object
         when String, Symbol
@@ -59,7 +59,7 @@ module YARD
         end
         File.join('objects', path)
       end
-      
+
       def serialize(object)
         if Hash === object
           super(object[:root], dump(object)) if object[:root]
@@ -67,7 +67,7 @@ module YARD
           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)
@@ -78,32 +78,32 @@ module YARD
           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) && 
+        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) || 
+
+        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|
@@ -114,7 +114,7 @@ module YARD
           list = object.map {|item| internal_dump(item) }
           object.replace(list)
         end
-        
+
         object
       end
     end

data/lib/yard/server/adapter.rb

@@ -1,10 +1,10 @@
 module YARD
   module Server
-    
+
     # Short circuits a request by raising an error. This exception is caught
     # by {Commands::Base#call} to immedaitely 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.
@@ -14,31 +14,31 @@ module YARD
     # 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
 
@@ -57,9 +57,9 @@ module YARD
         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
@@ -80,7 +80,7 @@ module YARD
         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')
@@ -89,7 +89,7 @@ module YARD
         libraries[library.name] ||= []
         libraries[library.name] |= [library]
       end
-      
+
       # Implement this method to connect your adapter to your server.
       # @abstract
       def start