yard 0.6.8 → 0.7.0

data/lib/yard/code_objects/method_object.rb

@@ -2,31 +2,31 @@ module YARD::CodeObjects
   # Represents a Ruby method in source
   class MethodObject < Base
     # The scope of the method (+:class+ or +:instance+)
-    # 
+    #
     # @return [Symbol] the scope
     attr_reader :scope
-    
+
     # Whether the object is explicitly defined in source or whether it was
     # inferred by a handler. For instance, attribute methods are generally
-    # inferred and therefore not explicitly defined in source. 
-    # 
+    # inferred and therefore not explicitly defined in source.
+    #
     # @return [Boolean] whether the object is explicitly defined in source.
     attr_accessor :explicit
-    
+
     # Returns the list of parameters parsed out of the method signature
     # with their default values.
-    # 
+    #
     # @return [Array<Array(String, String)>] a list of parameter names followed
     #   by their default values (or nil)
     attr_accessor :parameters
-    
+
     # Creates a new method object in +namespace+ with +name+ and an instance
     # or class +scope+
-    # 
+    #
     # @param [NamespaceObject] namespace the namespace
     # @param [String, Symbol] name the method name
     # @param [Symbol] scope +:instance+ or +:class+
-    def initialize(namespace, name, scope = :instance) 
+    def initialize(namespace, name, scope = :instance)
       @scope = nil
       self.visibility = :public
       self.scope = scope
@@ -34,22 +34,22 @@ module YARD::CodeObjects
 
       super
     end
-    
+
     # Changes the scope of an object from :instance or :class
     # @param [Symbol] v the new scope
-    def scope=(v) 
+    def scope=(v)
       reregister = @scope ? true : false
       YARD::Registry.delete(self) if reregister
       @path = nil
-      @scope = v.to_sym 
+      @scope = v.to_sym
       YARD::Registry.register(self) if reregister
     end
-      
+
     # @return whether or not the method is the #initialize constructor method
     def constructor?
       name == :initialize && scope == :instance && namespace.is_a?(ClassObject)
     end
-    
+
     # Returns the read/writer info for the attribute if it is one
     # @return [SymbolHash] if there is information about the attribute
     # @return [nil] if the method is not an attribute
@@ -58,7 +58,7 @@ module YARD::CodeObjects
       return nil unless namespace.is_a?(NamespaceObject)
       namespace.attributes[scope][name.to_s.gsub(/=$/, '')]
     end
-    
+
     # @return [Boolean] whether the method is a writer attribute
     # @since 0.5.3
     def writer?
@@ -70,28 +70,28 @@ module YARD::CodeObjects
     def reader?
       !!((info = attr_info) && info[:read] == self)
     end
-      
+
     # Tests if the object is defined as an attribute in the namespace
     # @return [Boolean] whether the object is an attribute
     def is_attribute?
       return false unless info = attr_info
       info[name.to_s =~ /=$/ ? :write : :read] ? true : false
     end
-      
+
     # Tests if the object is defined as an alias of another method
     # @return [Boolean] whether the object is an alias
     def is_alias?
       return false unless namespace.is_a?(NamespaceObject)
       namespace.aliases.has_key? self
     end
-    
+
     # Tests boolean {#explicit} value.
-    # 
+    #
     # @return [Boolean] whether the method is explicitly defined in source
     def is_explicit?
       explicit ? true : false
     end
-    
+
     # @return [MethodObject] the object that this method overrides
     # @return [nil] if it does not override a method
     # @since 0.6.0
@@ -100,45 +100,45 @@ module YARD::CodeObjects
       meths = namespace.meths(:all => true)
       meths.find {|m| m.path != path && m.name == name && m.scope == scope }
     end
-    
+
     # Returns all alias names of the object
     # @return [Array<Symbol>] the alias names
     def aliases
       list = []
       return list unless namespace.is_a?(NamespaceObject)
-      namespace.aliases.each do |o, aname| 
-        list << o if aname == name && o.scope == scope 
+      namespace.aliases.each do |o, aname|
+        list << o if aname == name && o.scope == scope
       end
       list
     end
-    
+
     # Override path handling for instance methods in the root namespace
     # (they should still have a separator as a prefix).
     # @return [String] the path of a method
     def path
-      @path ||= if !namespace || namespace.path == "" 
+      @path ||= if !namespace || namespace.path == ""
         sep + super
       else
         super
       end
     end
-    
+
     # Returns the name of the object.
-    # 
+    #
     # @example The name of an instance method (with prefix)
     #   an_instance_method.name(true) # => "#mymethod"
     # @example The name of a class method (with prefix)
     #   a_class_method.name(true) # => "mymethod"
     # @param [Boolean] prefix whether or not to show the prefix
-    # @return [String] returns {#sep} + +name+ for an instance method if 
+    # @return [String] returns {#sep} + +name+ for an instance method if
     #   prefix is true
     # @return [Symbol] the name without {#sep} if prefix is set to false
     def name(prefix = false)
       prefix ? (sep == ISEP ? "#{sep}#{super}" : super.to_s) : super
     end
-    
+
     protected
-    
+
     # Override separator to differentiate between class and instance
     # methods.
     # @return [String] "#" for an instance method, "." for class

data/lib/yard/code_objects/module_object.rb

@@ -2,7 +2,7 @@ module YARD::CodeObjects
   # Represents a Ruby module.
   class ModuleObject < NamespaceObject
     # Returns the inheritance tree of mixins.
-    # 
+    #
     # @param [Boolean] include_mods if true, will include mixed in
     #   modules (which is likely what is wanted).
     # @return [Array<NamespaceObject>] a list of namespace objects

data/lib/yard/code_objects/namespace_object.rb

@@ -1,12 +1,12 @@
 module YARD::CodeObjects
   # A "namespace" is any object that can store other objects within itself.
-  # The two main Ruby objects that can act as namespaces are modules 
+  # The two main Ruby objects that can act as namespaces are modules
   # ({ModuleObject}) and classes ({ClassObject}).
   class NamespaceObject < Base
     attr_writer :constants, :cvars, :mixins, :child, :meths
     attr_writer :class_attributes, :instance_attributes
     attr_writer :included_constants, :included_meths
-    
+
     # @return [Array<String>] a list of ordered group names inside the namespace
     # @since 0.6.0
     attr_accessor :groups
@@ -18,19 +18,19 @@ module YARD::CodeObjects
     # A hash containing two keys, class and instance, each containing
     # the attribute name with a { :read, :write } hash for the read and
     # write objects respectively.
-    # 
+    #
     # @example The attributes of an object
     #   >> Registry.at('YARD::Docstring').attributes
     #   => {
-    #         :class => { }, 
+    #         :class => { },
     #         :instance => {
     #           :ref_tags => {
-    #             :read => #<yardoc method YARD::Docstring#ref_tags>, 
-    #             :write => nil 
-    #           }, 
+    #             :read => #<yardoc method YARD::Docstring#ref_tags>,
+    #             :write => nil
+    #           },
     #           :object => {
     #             :read => #<yardoc method YARD::Docstring#object>,
-    #             :write => #<yardoc method YARD::Docstring#object=> 
+    #             :write => #<yardoc method YARD::Docstring#object=>
     #            },
     #            ...
     #         }
@@ -42,15 +42,15 @@ module YARD::CodeObjects
     # a hash of objects and their alias names.
     # @return [Hash] a list of methods
     attr_reader :aliases
-    
+
     # Class mixins
     # @return [Array<ModuleObject>] a list of mixins
     attr_reader :class_mixins
-    
+
     # Instance mixins
     # @return [Array<ModuleObject>] a list of mixins
     attr_reader :instance_mixins
-    
+
     # Creates a new namespace object inside +namespace+ with +name+.
     # @see Base#initialize
     def initialize(namespace, name, *args, &block)
@@ -62,23 +62,23 @@ module YARD::CodeObjects
       @groups = []
       super
     end
-    
+
     # Only the class attributes
     # @return [Hash] a list of method names and their read/write objects
     # @see #attributes
     def class_attributes
       attributes[:class]
     end
-    
+
     # Only the instance attributes
     # @return [Hash] a list of method names and their read/write objects
     # @see #attributes
-    def instance_attributes 
+    def instance_attributes
       attributes[:instance]
     end
-    
+
     # Looks for a child that matches the attributes specified by +opts+.
-    # 
+    #
     # @example Finds a child by name and scope
     #   namespace.child(:name => :to_s, :scope => :instance)
     #   # => #<yardoc method MyClass#to_s>
@@ -88,26 +88,26 @@ module YARD::CodeObjects
         children.find {|o| o.name == opts.to_sym }
       else
         opts = SymbolHash[opts]
-        children.find do |obj| 
+        children.find do |obj|
           opts.each do |meth, value|
             break false if !(value.is_a?(Array) ? value.include?(obj[meth]) : obj[meth] == value)
           end
         end
       end
     end
-    
+
     # Returns all methods that match the attributes specified by +opts+. If
     # no options are provided, returns all methods.
-    # 
+    #
     # @example Finds all private and protected class methods
     #   namespace.meths(:visibility => [:private, :protected], :scope => :class)
     #   # => [#<yardoc method MyClass.privmeth>, #<yardoc method MyClass.protmeth>]
-    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private, 
-    #   :protected]) the visibility of the methods to list. Can be an array or 
+    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,
+    #   :protected]) the visibility of the methods to list. Can be an array or
     #   single value.
-    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the 
+    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the
     #   scope of the methods to list. Can be an array or single value.
-    # @option opts [Boolean] :included (true) whether to include mixed in 
+    # @option opts [Boolean] :included (true) whether to include mixed in
     #   methods in the list.
     # @return [Array<MethodObject>] a list of method objects
     def meths(opts = {})
@@ -116,29 +116,29 @@ module YARD::CodeObjects
         :scope => [:class, :instance],
         :included => true
       ].update(opts)
-      
+
       opts[:visibility] = [opts[:visibility]].flatten
       opts[:scope] = [opts[:scope]].flatten
 
-      ourmeths = children.select do |o| 
-        o.is_a?(MethodObject) && 
+      ourmeths = children.select do |o|
+        o.is_a?(MethodObject) &&
           opts[:visibility].include?(o.visibility) &&
           opts[:scope].include?(o.scope)
       end
-      
+
       ourmeths + (opts[:included] ? included_meths(opts) : [])
     end
-    
+
     # Returns methods included from any mixins that match the attributes
     # specified by +opts+. If no options are specified, returns all included
     # methods.
-    # 
-    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private, 
-    #   :protected]) the visibility of the methods to list. Can be an array or 
+    #
+    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,
+    #   :protected]) the visibility of the methods to list. Can be an array or
     #   single value.
-    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the 
+    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the
     #   scope of the methods to list. Can be an array or single value.
-    # @option opts [Boolean] :included (true) whether to include mixed in 
+    # @option opts [Boolean] :included (true) whether to include mixed in
     #   methods in the list.
     # @see #meths
     def included_meths(opts = {})
@@ -155,9 +155,9 @@ module YARD::CodeObjects
         end
       end.flatten
     end
-    
+
     # Returns all constants in the namespace
-    # 
+    #
     # @option opts [Boolean] :included (true) whether or not to include
     #   mixed in constants in list
     # @return [Array<ConstantObject>] a list of constant objects
@@ -166,13 +166,13 @@ module YARD::CodeObjects
       consts = children.select {|o| o.is_a? ConstantObject }
       consts + (opts[:included] ? included_constants : [])
     end
-    
+
     # Returns constants included from any mixins
     # @return [Array<ConstantObject>] a list of constant objects
     def included_constants
       instance_mixins.inject([]) do |list, mixin|
         if mixin.respond_to? :constants
-          list += mixin.constants.reject do |o| 
+          list += mixin.constants.reject do |o|
             child(:name => o.name) || list.find {|o2| o2.name == o.name }
           end
         else
@@ -180,10 +180,10 @@ module YARD::CodeObjects
         end
       end
     end
-    
+
     # Returns class variables defined in this namespace.
     # @return [Array<ClassVariableObject>] a list of class variable objects
-    def cvars 
+    def cvars
       children.select {|o| o.is_a? ClassVariableObject }
     end
 

data/lib/yard/code_objects/proxy.rb

@@ -8,7 +8,7 @@ module YARD
     # an unresolved path until a method is called on the object, at which
     # point it does a lookup using {Registry.resolve}. If the object is
     # not found, a warning is raised and {ProxyMethodError} might be raised.
-    # 
+    #
     # @example Creates a Proxy to the String class from a module
     #   # When the String class is parsed this method will
     #   # begin to act like the String ClassObject.
@@ -22,17 +22,17 @@ module YARD
       alias_method :parent, :namespace
 
       # Creates a new Proxy
-      # 
+      #
       # @raise [ArgumentError] if namespace is not a NamespaceObject
       # @return [Proxy] self
       def initialize(namespace, name)
         namespace = Registry.root if !namespace || namespace == :root
-        
+
         if name =~ /^#{NSEPQ}/
           namespace = Registry.root
           name = name[2..-1]
         end
-        
+
         if name =~ /(?:#{NSEPQ}|#{ISEPQ}|#{CSEPQ})([^#{NSEPQ}#{ISEPQ}#{CSEPQ}]+)$/
           @orignamespace, @origname = namespace, name
           @imethod = true if name.include? ISEP
@@ -40,23 +40,23 @@ module YARD
           name = $1
         else
           @orignamespace, @origname, @imethod = nil, nil, nil
-        end 
-        
+        end
+
         @name = name.to_sym
         @namespace = namespace
         @obj = nil
         @imethod ||= nil
-        
+
         if @namespace.is_a?(ConstantObject)
           @origname = nil # forget these for a constant
           @orignamespace = nil
           @namespace = Proxy.new(@namespace.namespace, @namespace.value)
         end
-        
+
         unless @namespace.is_a?(NamespaceObject) or @namespace.is_a?(Proxy)
           raise ArgumentError, "Invalid namespace object: #{namespace}"
         end
-        
+
         # If the name begins with "::" (like "::String")
         # this is definitely a root level object, so
         # remove the namespace and attach it to the root
@@ -65,7 +65,7 @@ module YARD
           @namespace = Registry.root
         end
       end
-      
+
       # (see Base#name)
       def name(prefix = false)
         prefix ? (@imethod ? ISEP : '') + @name.to_s : @name
@@ -80,10 +80,10 @@ module YARD
           "P(#{path})"
         end
       end
-      
+
       # If the proxy resolves to an object, returns its path, otherwise
       # guesses at the correct path using the original namespace and name.
-      # 
+      #
       # @return [String] the assumed path of the proxy (or the real path
       #   of the resolved object)
       def path
@@ -107,8 +107,8 @@ module YARD
       end
       alias to_s path
       alias to_str path
-    
-      # @return [Boolean] 
+
+      # @return [Boolean]
       def is_a?(klass)
         if obj = to_obj
           obj.is_a?(klass)
@@ -116,8 +116,8 @@ module YARD
           self.class <= klass
         end
       end
-      
-      # @return [Boolean] 
+
+      # @return [Boolean]
       def ===(other)
         if obj = to_obj
           obj === other
@@ -125,8 +125,8 @@ module YARD
           self.class <= other.class
         end
       end
-      
-      # @return [Boolean] 
+
+      # @return [Boolean]
       def <=>(other)
         if other.respond_to? :path
           path <=> other.path
@@ -134,8 +134,8 @@ module YARD
           false
         end
       end
-      
-      # @return [Boolean] 
+
+      # @return [Boolean]
       def equal?(other)
         if other.respond_to? :path
           path == other.path
@@ -144,12 +144,12 @@ module YARD
         end
       end
       alias == equal?
-      
+
       # @return [Integer] the object's hash value (for equality checking)
       def hash; path.hash end
 
       # Returns the class name of the object the proxy is mimicking, if
-      # resolved. Otherwise returns +Proxy+. 
+      # resolved. Otherwise returns +Proxy+.
       # @return [Class] the resolved object's class or +Proxy+
       def class
         if obj = to_obj
@@ -158,7 +158,7 @@ module YARD
           Proxy
         end
       end
-      
+
       # Returns the type of the proxy. If it cannot be resolved at the
       # time of the call, it will either return the inferred proxy type
       # (see {#type=}) or +:proxy+
@@ -171,23 +171,23 @@ module YARD
           Registry.proxy_types[path] || :proxy
         end
       end
-      
+
       # Allows a parser to infer the type of the proxy by its path.
       # @param [#to_sym] type the proxy's inferred type
-      # @return [void] 
+      # @return [void]
       def type=(type) Registry.proxy_types[path] = type.to_sym end
-      
-      # @return [Boolean] 
+
+      # @return [Boolean]
       def instance_of?(klass)
         self.class == klass
       end
-      
-      # @return [Boolean] 
+
+      # @return [Boolean]
       def kind_of?(klass)
         self.class <= klass
       end
-      
-      # @return [Boolean] 
+
+      # @return [Boolean]
       def respond_to?(meth, include_private = false)
         if obj = to_obj
           obj.respond_to?(meth, include_private)
@@ -195,9 +195,9 @@ module YARD
           super
         end
       end
-      
+
       # Dispatches the method to the resolved object.
-      # 
+      #
       # @raise [ProxyMethodError] if the proxy cannot find the real object
       def method_missing(meth, *args, &block)
         if obj = to_obj
@@ -212,26 +212,26 @@ module YARD
           log.warn "YARD will recover from this error and continue to parse but you *may* have problems"
           log.warn "with your generated documentation. You should probably fix this."
           log.warn "-"
-          begin 
+          begin
             super
           rescue NoMethodError
             raise ProxyMethodError, "Proxy cannot call method ##{meth} on object '#{path}'"
           end
         end
       end
-      
+
       # This class is never a root object
       def root?; false end
-    
+
       private
 
       # @note this method fixes a bug in 1.9.2: http://gist.github.com/437136
       def to_ary; nil end
-    
+
       # Attempts to find the object that this unresolved object
       # references by checking if any objects by this name are
       # registered all the way up the namespace tree.
-      # 
+      #
       # @return [Base, nil] the registered code object or nil
       def to_obj
         return @obj if @obj