yard 0.6.1 → 0.6.2

data/lib/yard/handlers/processor.rb

@@ -115,7 +115,7 @@ module YARD
         Base.subclasses.find_all do |handler|
           handler_base_class > handler &&
           (handler.namespace_only? ? owner.is_a?(CodeObjects::NamespaceObject) : true) &&
-          handler.handles?(statement)
+          handler.matches_file?(file) && handler.handles?(statement)
         end
       end
       

data/lib/yard/handlers/ruby/class_handler.rb

@@ -18,7 +18,11 @@ class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
         o.superclass = superclass if superclass
         o.superclass.type = :class if o.superclass.is_a?(Proxy)
       end
-      parse_struct_superclass(klass, statement[1]) if is_a_struct
+      if is_a_struct
+        parse_struct_superclass(klass, statement[1])
+      elsif klass
+        create_attributes(klass, members_from_tags(klass))
+      end
       parse_block(statement[2], namespace: klass)
        
       if undocsuper
@@ -96,6 +100,7 @@ class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
     
     case superclass.type
     when :var_ref
+      return namespace.path if superclass.first == s(:kw, "self")
       return superclass.source if superclass.first.type == :const
     when :const, :const_ref, :const_path_ref, :top_const_ref
       return superclass.source

data/lib/yard/handlers/ruby/constant_handler.rb

@@ -1,5 +1,6 @@
 # Handles any constant assignment
 class YARD::Handlers::Ruby::ConstantHandler < YARD::Handlers::Ruby::Base
+  include YARD::Handlers::Ruby::StructHandlerMethods
   namespace_only
   handles :assign
   
@@ -23,25 +24,22 @@ class YARD::Handlers::Ruby::ConstantHandler < YARD::Handlers::Ruby::Base
   def process_structclass(statement)
     lhs = statement[0][0]
     if lhs.type == :const
-      klass = register ClassObject.new(namespace, lhs[0])
-      klass.superclass = P(:Struct)
-      parse_attributes(klass, statement[1].parameters)
+      klass = create_class(lhs[0], P(:Struct))
+      create_attributes(klass, extract_parameters(statement[1]))
     else
       raise YARD::Parser::UndocumentableError, "Struct assignment to #{statement[0].source}"
     end
   end
   
-  def parse_attributes(klass, attributes)
-    return unless attributes
-    
-    scope = :instance
-    attributes.each do |node|
-      next if !node.respond_to?(:type) || node.type != :symbol_literal
-      name = node.jump(:ident).source
-      klass.attributes[scope][name] = SymbolHash[:read => nil, :write => nil]
-      {read: name, write: "#{name}="}.each do |type, meth|
-        klass.attributes[scope][name][type] = register MethodObject.new(klass, meth, scope)
-      end
-    end
+  # Extract the parameters from the Struct.new AST node, returning them as a list
+  # of strings
+  #
+  # @param [MethodCallNode] superclass the AST node for the Struct.new call
+  # @return [Array<String>] the member names to generate methods for
+  def extract_parameters(superclass)
+    return [] unless superclass.parameters
+    members = superclass.parameters.select {|x| x && x.type == :symbol_literal}
+    members.map! {|x| x.source.strip[1..-1]}
+    members
   end
 end

data/lib/yard/handlers/ruby/exception_handler.rb

@@ -15,7 +15,7 @@ class YARD::Handlers::Ruby::ExceptionHandler < YARD::Handlers::Ruby::Base
       elsif params.first.call? && params.first.method_name(true) == :new
         klass = params.first.namespace.source
       end
-    else
+    elsif params.size > 1
       klass = params.first.source
     end
 

data/lib/yard/handlers/ruby/extend_handler.rb

@@ -10,6 +10,9 @@ class YARD::Handlers::Ruby::ExtendHandler < YARD::Handlers::Ruby::MixinHandler
 
   def process_mixin(mixin)
     if mixin == s(:var_ref, s(:kw, "self"))
+      if namespace.is_a?(ClassObject)
+        raise UndocumentableError, "extend(self) statement on class"
+      end
       namespace.mixins(scope) << namespace
     else
       super

data/lib/yard/handlers/ruby/legacy/class_condition_handler.rb

@@ -70,6 +70,7 @@ class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby
   
   # @since 0.5.5
   def parse_else_block
+    return unless statement.block
     stmtlist = YARD::Parser::Ruby::Legacy::StatementList
     stmtlist.new(statement.block).each do |stmt|
       if TkELSE === stmt.tokens.first

data/lib/yard/handlers/ruby/legacy/class_handler.rb

@@ -19,7 +19,11 @@ class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy:
         o.superclass = superclass if superclass
         o.superclass.type = :class if o.superclass.is_a?(Proxy)
       end
-      parse_struct_subclass(klass, superclass_def) if is_a_struct
+      if is_a_struct
+        parse_struct_subclass(klass, superclass_def)
+      elsif klass
+        create_attributes(klass, members_from_tags(klass))
+      end
       parse_block(:namespace => klass)
        
       if undocsuper
@@ -98,6 +102,8 @@ class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy:
          /\ADelegateClass\((.+?)\)\s*\Z/,
          /\A(#{NAMESPACEMATCH})\(/
       $1
+    when "self"
+      namespace.path
     end
   end
 end

data/lib/yard/handlers/ruby/legacy/constant_handler.rb

@@ -1,5 +1,6 @@
 # (see Ruby::ConstantHandler)
 class YARD::Handlers::Ruby::Legacy::ConstantHandler < YARD::Handlers::Ruby::Legacy::Base
+  include YARD::Handlers::Ruby::StructHandlerMethods
   HANDLER_MATCH = /\A[A-Z]\w*\s*=[^=]\s*/m
   handles HANDLER_MATCH
   
@@ -19,15 +20,12 @@ class YARD::Handlers::Ruby::Legacy::ConstantHandler < YARD::Handlers::Ruby::Lega
   private
   
   def process_structclass(classname, parameters)
-    scope = :instance
-    klass = register ClassObject.new(namespace, classname)
-    klass.superclass = P(:Struct)
-
-    tokval_list(YARD::Parser::Ruby::Legacy::TokenList.new(parameters), TkSYMBOL).each do |name|
-      klass.attributes[scope][name] = SymbolHash[:read => nil, :write => nil]
-      {:read => name, :write => "#{name}="}.each do |type, meth|
-        klass.attributes[scope][name][type] = register MethodObject.new(klass, meth, scope)
-      end
-    end
+    klass = create_class(classname, P(:Struct))
+    create_attributes(klass, extract_parameters(parameters))
+  end
+  
+  def extract_parameters(parameters)
+    members = tokval_list(YARD::Parser::Ruby::Legacy::TokenList.new(parameters), TkSYMBOL)
+    members.map {|m| m.to_s }
   end
 end

data/lib/yard/handlers/ruby/legacy/exception_handler.rb

@@ -6,7 +6,7 @@ class YARD::Handlers::Ruby::Legacy::ExceptionHandler < YARD::Handlers::Ruby::Leg
     return unless owner.is_a?(MethodObject) # Only methods yield
     return if owner.has_tag?(:raise)
 
-    if klass = statement.tokens.to_s[/^raise[\(\s]*(#{NAMESPACEMATCH})(?:\)|,|\s|(?:\s*(?:\.|\:\:)\s*)?new|$)/, 1]
+    if klass = statement.tokens.to_s[/^raise[\(\s]*(#{NAMESPACEMATCH})\s*(?:\)|,|\s(?:if|unless|until)|;|(?:(?:\.|\:\:)\s*)?new|$)/, 1]
       owner.docstring.add_tag YARD::Tags::Tag.new(:raise, '', klass)
     end
   end

data/lib/yard/handlers/ruby/legacy/extend_handler.rb

@@ -8,6 +8,9 @@ class YARD::Handlers::Ruby::Legacy::ExtendHandler < YARD::Handlers::Ruby::Legacy
 
   def process_mixin(mixin)
     if mixin == "self"
+      if namespace.is_a?(ClassObject)
+        raise UndocumentableError, "extend(self) statement on class"
+      end
       namespace.mixins(scope) << namespace
     else
       super

data/lib/yard/handlers/ruby/legacy/method_handler.rb

@@ -24,6 +24,7 @@ class YARD::Handlers::Ruby::Legacy::MethodHandler < YARD::Handlers::Ruby::Legacy
       nobj = P(namespace, prefix) unless prefix == "self"
     end
     
+    nobj = P(namespace, nobj.value) while nobj.type == :constant
     obj = register MethodObject.new(nobj, meth, mscope) do |o| 
       o.visibility = visibility 
       o.source = statement

data/lib/yard/handlers/ruby/legacy/mixin_handler.rb

@@ -3,8 +3,19 @@ class YARD::Handlers::Ruby::Legacy::MixinHandler < YARD::Handlers::Ruby::Legacy:
   handles /\Ainclude(\s|\()/
   
   process do
+    errors = []
     statement.tokens[1..-1].to_s.split(/\s*,\s*/).each do |mixin|
-      process_mixin(mixin.strip)
+      mixin = mixin.strip
+      begin
+        process_mixin(mixin)
+      rescue YARD::Parser::UndocumentableError => err
+        errors << err.message
+      end
+    end
+    
+    if errors.size > 0
+      msg = errors.size == 1 ? ": #{errors[0]}" : "s: #{errors.join(", ")}"
+      raise YARD::Parser::UndocumentableError, "mixin#{msg} for class #{namespace.path}"
     end
   end
 
@@ -12,7 +23,7 @@ class YARD::Handlers::Ruby::Legacy::MixinHandler < YARD::Handlers::Ruby::Legacy:
 
   def process_mixin(mixin)
     unless mixmatch = mixin[/\A(#{NAMESPACEMATCH})/, 1]
-      raise YARD::Parser::UndocumentableError, "mixin #{mixin} for class #{namespace.path}"
+      raise YARD::Parser::UndocumentableError
     end
 
     obj = Proxy.new(namespace, mixmatch)

data/lib/yard/handlers/ruby/method_handler.rb

@@ -20,6 +20,7 @@ class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
       blk = statement[2]
     end
     
+    nobj = P(namespace, nobj.value) while nobj.type == :constant
     obj = register MethodObject.new(nobj, meth, mscope) do |o| 
       o.visibility = visibility 
       o.source = statement.source

data/lib/yard/handlers/ruby/mixin_handler.rb

@@ -4,15 +4,25 @@ class YARD::Handlers::Ruby::MixinHandler < YARD::Handlers::Ruby::Base
   handles method_call(:include)
   
   process do
-    statement.parameters(false).each {|mixin| process_mixin(mixin) }
+    errors = []
+    statement.parameters(false).each do |mixin|
+      begin
+        process_mixin(mixin)
+      rescue YARD::Parser::UndocumentableError => err
+        errors << err.message
+      end
+    end
+    if errors.size > 0
+      msg = errors.size == 1 ? ": #{errors[0]}" : "s: #{errors.join(", ")}"
+      raise YARD::Parser::UndocumentableError, "mixin#{msg} for class #{namespace.path}"
+    end
   end
 
   protected
 
   def process_mixin(mixin)
-    unless mixin.ref?
-      raise YARD::Parser::UndocumentableError, "mixin #{mixin.source} for class #{namespace.path}"
-    end
+    raise YARD::Parser::UndocumentableError unless mixin.ref?
+    raise YARD::Parser::UndocumentableError if mixin.first.type == :ident
     
     case obj = Proxy.new(namespace, mixin.source)
     when Proxy

data/lib/yard/handlers/ruby/struct_handler_methods.rb

@@ -1,4 +1,4 @@
-# Helper methods to parse @attr_* tags on a Struct class.
+# Helper methods to parse @attr_* tags on a class.
 # 
 # @since 0.5.6
 module YARD::Handlers::Ruby::StructHandlerMethods
@@ -15,6 +15,15 @@ module YARD::Handlers::Ruby::StructHandlerMethods
     specific_tag = type == :read ? :attr_reader : :attr_writer
     (klass.tags(specific_tag) + klass.tags(:attr)).find {|tag| tag.name == member}
   end
+
+  # Retrieves all members defined in @attr* tags
+  # 
+  # @param [ClassObject] klass the class with the attributes
+  # @return [Array<String>] the list of members defined as attributes on the class
+  def members_from_tags(klass)
+    tags = klass.tags(:attr) + klass.tags(:attr_reader) + klass.tags(:attr_writer)
+    tags.map {|t| t.name }.uniq
+  end
   
   # Determines whether to create an attribute method based on the class's
   # tags.

data/lib/yard/handlers/ruby/visibility_handler.rb

@@ -13,7 +13,7 @@ class YARD::Handlers::Ruby::VisibilityHandler < YARD::Handlers::Ruby::Base
     when :fcall, :command
       statement[1].traverse do |node|
         case node.type
-        when :symbol; source = node.jump(:ident).last
+        when :symbol; source = node.first.source
         when :string_content; source = node.source
         else next
         end

data/lib/yard/parser/c_parser.rb

@@ -15,6 +15,7 @@ module YARD
         parse_modules
         parse_classes
         parse_methods
+        parse_constants
         parse_includes
       end
       
@@ -32,10 +33,10 @@ module YARD
       
       def ensure_loaded!(object, max_retries = 1)
         return if object.is_a?(CodeObjects::RootObject)
-        if RUBY_PLATFORM =~ /java/ || defined?(::Rubinius)
+        unless CONTINUATIONS_SUPPORTED
           unless $NO_CONTINUATION_WARNING
             $NO_CONTINUATION_WARNING = true
-            log.warn "JRuby/Rubinius do not implement Kernel#callcc and cannot " +
+            log.warn "JRuby/MacRuby/Rubinius do not implement Kernel#callcc and cannot " +
               "load files in order. You must specify the correct order manually."
           end
           raise NamespaceMissingError, object
@@ -94,7 +95,10 @@ module YARD
       def handle_constants(type, var_name, const_name, definition)
         namespace = @namespaces[var_name]
         obj = CodeObjects::ConstantObject.new(namespace, const_name)
-        comment = find_constant_docstring(type, const_name)
+        obj.value = definition
+        obj.add_file(@file)
+        obj.source_type = :c
+        comment = find_constant_docstring(obj, type, const_name)
 
         # In the case of rb_define_const, the definition and comment are in
         # "/* definition: comment */" form.  The literal ':' and '\' characters
@@ -126,8 +130,8 @@ module YARD
         object.docstring = parse_comments(object, comment) if comment
       end
       
-      def find_constant_docstring(type, const_name)
-        comments = if @content =~ %r{((?>^\s*/\*.*?\*/\s+))
+      def find_constant_docstring(object, type, const_name)
+        comment = if @content =~ %r{((?>^\s*/\*.*?\*/\s+))
                        rb_define_#{type}\((?:\s*(\w+),)?\s*"#{const_name}"\s*,.*?\)\s*;}xmi
           $1
         elsif @content =~ %r{Document-(?:const|global|variable):\s#{const_name}\s*?\n((?>.*?\*/))}m
@@ -135,7 +139,7 @@ module YARD
         else
           ''
         end
-        parse_comments(object, comments)
+        object.docstring = parse_comments(object, comment) if comment
       end
       
       def find_method_body(object, func_name, content = @content)
@@ -158,8 +162,8 @@ module YARD
           # distinct (for example Kernel.hash and Kernel.object_id share the same
           # implementation
 
-          # override_comment = find_override_comment(object)
-          # comment = override_comment if override_comment
+          override_comment = find_override_comment(object)
+          comment = override_comment if override_comment
 
           object.docstring = parse_comments(object, comment) if comment
           object.source = body_text
@@ -168,11 +172,22 @@ module YARD
           find_method_body(object, $2, content)
         else
           # No body, but might still have an override comment
-          # comment = find_override_comment(object)
-          comment = nil
+          comment = find_override_comment(object)
           object.docstring = parse_comments(object, comment) if comment
         end
       end
+
+      def find_override_comment(object, content = @content)
+        name = Regexp.escape(object.name.to_s)
+        class_name = object.parent.path
+        if content =~ %r{Document-method:\s+#{class_name}(?:\.|::|#)#{name}\s*?\n((?>.*?\*/))}m then
+          $1
+        elsif content =~ %r{Document-method:\s#{name}\s*?\n((?>.*?\*/))}m then
+          $1
+        else
+          nil
+        end
+      end
       
       def parse_comments(object, comments)
         spaces = nil
@@ -406,4 +421,4 @@ module YARD
       end
     end
   end
-end
+end

data/lib/yard/parser/ruby/legacy/statement_list.rb

@@ -42,7 +42,7 @@ module YARD
         @current_block = nil
         @comments_line = nil
         @statement, @block, @comments = TokenList.new, nil, nil
-        @last_tk, @last_ns_tk, @before_last_tk = nil, nil, nil
+        @last_tk, @last_ns_tk, @before_last_tk, @before_last_ns_tk = nil, nil, nil, nil
         @first_line = nil
 
         while !@done && tk = @tokens.shift
@@ -50,6 +50,7 @@ module YARD
 
           @before_last_tk = @last_tk
           @last_tk = tk # Save last token
+          @before_last_ns_tk = @last_ns_tk
           @last_ns_tk = tk unless [TkSPACE, TkNL, TkEND_OF_SCRIPT].include? tk.class
         end
 
@@ -130,6 +131,12 @@ module YARD
           return if process_initial_comment(tk)
           return if @statement.empty? && [TkSPACE, TkNL, TkCOMMENT].include?(tk.class)
           @comments_last_line = nil
+          if @statement.empty? && tk.class == TkALIAS
+            @state = :alias_statement
+            @alias_values = []
+            push_token(tk)
+            return
+          end
           return if process_simple_block_opener(tk)
           push_token(tk)
           return if process_complex_block_opener(tk)
@@ -139,6 +146,15 @@ module YARD
           else
             @state = :balance
           end
+        when :alias_statement
+          push_token(tk)
+          @alias_values << tk unless [TkSPACE, TkNL, TkCOMMENT].include?(tk.class)
+          if @alias_values.size == 2
+            @state = :first_statement
+            if [NilClass, TkNL, TkEND_OF_SCRIPT, TkSEMICOLON].include?(peek_no_space.class)
+              @done = true
+            end
+          end
         when :balance
           @statement << tk
           return unless balances?(tk)
@@ -251,7 +267,6 @@ module YARD
       # @param [RubyToken::Token] tk the token to process
       def process_complex_block_opener(tk)
         return unless OPEN_BLOCK_TOKENS.include?(tk.class)
-        return if @last_ns_tk.class == TkALIAS
 
         @current_block = tk.class
         @state = :block_statement
@@ -265,7 +280,7 @@ module YARD
       def process_statement_end(tk)
         # Whitespace means that we keep the same value of @new_statement as last token
         return if tk.class == TkSPACE
-
+        
         return unless 
           # We might be coming after a statement-ending token...
           ((@last_tk && [TkSEMICOLON, TkNL, TkEND_OF_SCRIPT].include?(tk.class)) ||
@@ -318,12 +333,14 @@ module YARD
       # @return [Boolean] whether or not the current statement's parentheses and blocks
       #   are balanced after +tk+
       def balances?(tk)
-        if [TkLPAREN, TkLBRACK, TkLBRACE, TkDO, TkBEGIN].include?(tk.class)
-          @level += 1
-        elsif OPEN_BLOCK_TOKENS.include?(tk.class)
-          @level += 1 unless @last_ns_tk.class == TkALIAS || tk.class == TkELSIF
-        elsif [TkRPAREN, TkRBRACK, TkRBRACE, TkEND].include?(tk.class) && @level > 0
-          @level -= 1
+        unless @last_ns_tk.class == TkALIAS || @before_last_ns_tk.class == TkALIAS
+          if [TkLPAREN, TkLBRACK, TkLBRACE, TkDO, TkBEGIN].include?(tk.class)
+            @level += 1
+          elsif OPEN_BLOCK_TOKENS.include?(tk.class)
+            @level += 1 unless tk.class == TkELSIF
+          elsif [TkRPAREN, TkRBRACK, TkRBRACE, TkEND].include?(tk.class) && @level > 0
+            @level -= 1
+          end
         end
         
         @level == 0