yard 0.9.5 → 0.9.6

data/lib/yard/handlers/c/module_handler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::ModuleHandler < YARD::Handlers::C::Base
   MATCH1 = /([\w\.]+)\s* = \s*rb_define_module\s*\(\s*"([\w:]+)"\s*\)/mx
   MATCH2 = /([\w\.]+)\s* = \s*rb_define_module_under\s*\(\s*(\w+),\s*"(\w+)"\s*\)/mx

data/lib/yard/handlers/c/override_comment_handler.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 # Parses comments
 class YARD::Handlers::C::OverrideCommentHandler < YARD::Handlers::C::Base
-  handles %r{.}
+  handles(/./)
   statement_class Comment
 
   process do

data/lib/yard/handlers/c/path_handler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::PathHandler < YARD::Handlers::C::Base
   MATCH = /([\w\.]+)\s* = \s*rb_path2class\s*\(\s*"([\w:]+)"\)/mx
   handles MATCH

data/lib/yard/handlers/c/struct_handler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::StructHandler < YARD::Handlers::C::Base
   MATCH = /([\w\.]+)\s*=\s*(?:rb_struct_define_without_accessor)\s*
            \(\s*"([\w:]+)"\s*,\s*(\w+)\s*/mx

data/lib/yard/handlers/c/symbol_handler.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 # Keeps track of function bodies for symbol lookup during Ruby method declarations
 class YARD::Handlers::C::SymbolHandler < YARD::Handlers::C::Base
-  MATCH = %r{\A\s*(?:(?:\w+)\s+)?(?:intern\s+)?VALUE\s+(\w+)\s*\(}
+  MATCH = /\A\s*(?:(?:\w+)\s+)?(?:intern\s+)?VALUE\s+(\w+)\s*\(/
   handles MATCH
   statement_class ToplevelStatement
   process { symbols[statement.source[MATCH, 1]] = statement }

data/lib/yard/handlers/processor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'ostruct'
 
 module YARD
@@ -17,7 +18,6 @@ module YARD
     #
     # @see Handlers::Base
     class Processor
-
       class << self
         # Registers a new namespace for handlers of the given type.
         # @since 0.6.0
@@ -108,24 +108,23 @@ module YARD
       # @param [Array] statements a list of statements
       # @return [void]
       def process(statements)
-        statements.each_with_index do |stmt, index|
+        statements.each_with_index do |stmt, _index|
           find_handlers(stmt).each do |handler|
             begin
               handler.new(self, stmt).process
-            rescue HandlerAborted => abort
-              log.debug "#{handler.to_s} cancelled from #{caller.last}"
+            rescue HandlerAborted
+              log.debug "#{handler} cancelled from #{caller.last}"
               log.debug "\tin file '#{file}':#{stmt.line}:\n\n" + stmt.show + "\n"
             rescue NamespaceMissingError => missingerr
-              log.warn "The #{missingerr.object.type} #{missingerr.object.path} has not yet been recognized."
-              log.warn "If this class/method is part of your source tree, this will affect your documentation results."
-              log.warn "You can correct this issue by loading the source file for this object before `#{file}'"
-              log.warn
+              log.warn "The #{missingerr.object.type} #{missingerr.object.path} has not yet been recognized.\n" \
+                       "If this class/method is part of your source tree, this will affect your documentation results.\n" \
+                       "You can correct this issue by loading the source file for this object before `#{file}'\n"
             rescue Parser::UndocumentableError => undocerr
-              log.warn "in #{handler.to_s}: Undocumentable #{undocerr.message}"
-              log.warn "\tin file '#{file}':#{stmt.line}:\n\n" + stmt.show + "\n"
+              log.warn "in #{handler}: Undocumentable #{undocerr.message}\n" \
+                       "\tin file '#{file}':#{stmt.line}:\n\n" + stmt.show + "\n"
             rescue => e
-              log.error "Unhandled exception in #{handler.to_s}:"
-              log.error "  in `#{file}`:#{stmt.line}:\n\n#{stmt.show}\n"
+              log.error "Unhandled exception in #{handler}:\n" \
+                        "  in `#{file}`:#{stmt.line}:\n\n#{stmt.show}\n"
               log.backtrace(e)
             end
           end
@@ -152,8 +151,8 @@ module YARD
       def find_handlers(statement)
         Base.subclasses.find_all do |handler|
           handler_base_class > handler &&
-          (handler.namespace_only? ? owner.is_a?(CodeObjects::NamespaceObject) : true) &&
-          handles?(handler, statement)
+            (handler.namespace_only? ? owner.is_a?(CodeObjects::NamespaceObject) : true) &&
+            handles?(handler, statement)
         end
       end
 
@@ -198,4 +197,4 @@ module YARD
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles alias and alias_method calls
 class YARD::Handlers::Ruby::AliasHandler < YARD::Handlers::Ruby::Base
   handles :alias, method_call(:alias_method)
@@ -19,7 +20,8 @@ class YARD::Handlers::Ruby::AliasHandler < YARD::Handlers::Ruby::Base
     end
     raise YARD::Parser::UndocumentableError, "alias/alias_method" if names.size != 2
 
-    new_meth, old_meth = names[0].to_sym, names[1].to_sym
+    new_meth = names[0].to_sym
+    old_meth = names[1].to_sym
     old_obj = namespace.child(:name => old_meth, :scope => scope)
     new_obj = register MethodObject.new(namespace, new_meth, scope) do |o|
       o.add_file(parser.file, statement.line)
@@ -39,4 +41,4 @@ class YARD::Handlers::Ruby::AliasHandler < YARD::Handlers::Ruby::Base
       new_obj.signature = "def #{new_meth}" # this is all we know.
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles +attr_*+ statements in modules/classes
 class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
   handles method_call(:attr)
@@ -8,7 +9,8 @@ class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
 
   process do
     return if statement.type == :var_ref || statement.type == :vcall
-    read, write = true, false
+    read = true
+    write = false
     params = statement.parameters(false).dup
 
     # Change read/write based on attr_reader/writer/accessor
@@ -23,7 +25,8 @@ class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
     when :attr_reader
       # change nothing
     when :attr_writer
-      read, write = false, true
+      read = false
+      write = true
     end
 
     # Add all attributes
@@ -32,7 +35,7 @@ class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
 
       # Show their methods as well
       {:read => name, :write => "#{name}="}.each do |type, meth|
-        if (type == :read ? read : write)
+        if type == :read ? read : write
           o = MethodObject.new(namespace, meth, scope)
           if type == :write
             o.parameters = [['value', nil]]
@@ -51,9 +54,11 @@ class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
 
           # Regsiter the object explicitly
           namespace.attributes[scope][name][type] = o
-        elsif obj = namespace.children.find {|o| o.name == meth.to_sym && o.scope == scope }
+        else
+          obj = namespace.children.find {|other| other.name == meth.to_sym && other.scope == scope }
+
           # register an existing method as attribute
-          namespace.attributes[scope][name][type] = obj
+          namespace.attributes[scope][name][type] = obj if obj
         end
       end
     end
@@ -79,4 +84,4 @@ class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Handlers
     module Ruby
@@ -23,7 +24,9 @@ module YARD
         # Tests if the node matches the handler
         # @param [Parser::Ruby::AstNode] node a Ruby node
         # @return [Boolean] whether the +node+ matches the handler
-        def matches?(node) raise NotImplementedError end
+        def matches?(node) # rubocop:disable Lint/UnusedMethodArgument
+          raise NotImplementedError
+        end
 
         protected
 
@@ -154,11 +157,9 @@ module YARD
             statement.method_name(true).to_s
           elsif statement.type == :var_ref || statement.type == :vcall
             statement[0].jump(:ident, :kw).source
-          else
-            nil
           end
         end
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Matches if/unless conditions inside classes and attempts to process only
 # one branch (by evaluating the condition if possible).
 #
@@ -14,7 +15,7 @@ class YARD::Handlers::Ruby::ClassConditionHandler < YARD::Handlers::Ruby::Base
 
   process do
     condition = parse_condition
-    if condition == nil
+    if condition.nil?
       # Parse both blocks if we're unsure of the condition
       parse_then_block
       parse_else_block
@@ -69,7 +70,7 @@ class YARD::Handlers::Ruby::ClassConditionHandler < YARD::Handlers::Ruby::Base
 
     # Invert an unless condition
     if statement.type == :unless || statement.type == :unless_mod
-      condition = !condition if condition != nil
+      condition = !condition unless condition.nil?
     end
     condition
   end
@@ -83,4 +84,4 @@ class YARD::Handlers::Ruby::ClassConditionHandler < YARD::Handlers::Ruby::Base
       parse_block(statement.else_block, :visibility => visibility)
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles class declarations
 class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
   include YARD::Handlers::Ruby::StructHandlerMethods
@@ -43,7 +44,7 @@ class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
           end
         end
 
-        if classname[0,1] =~ /[A-Z]/
+        if classname[0, 1] =~ /[A-Z]/
           register ClassObject.new(namespace, classname) if Proxy === proxy
           parse_block(statement[1], :namespace => proxy, :scope => :class)
         else
@@ -64,8 +65,8 @@ class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
   # @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)
-    members = superclass.parameters.select {|x| x && x.type == :symbol_literal}
-    members.map! {|x| x.source.strip[1..-1]}
+    members = superclass.parameters.select {|x| x && x.type == :symbol_literal }
+    members.map! {|x| x.source.strip[1..-1] }
     members
   end
 
@@ -105,11 +106,8 @@ class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
       return superclass.source
     when :fcall, :command
       methname = superclass.method_name.source
-      if methname == "DelegateClass"
-        return superclass.parameters.first.source
-      elsif superclass.method_name.type == :const
-        return methname
-      end
+      return superclass.parameters.first.source if methname == "DelegateClass"
+      return methname if superclass.method_name.type == :const
     when :call, :command_call
       cname = superclass.namespace.source
       if cname =~ /^O?Struct$/ && superclass.method_name(true) == :new
@@ -118,4 +116,4 @@ class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
     end
     nil
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles a class variable (@@variable)
 class YARD::Handlers::Ruby::ClassVariableHandler < YARD::Handlers::Ruby::Base
   handles :assign
@@ -13,4 +14,4 @@ class YARD::Handlers::Ruby::ClassVariableHandler < YARD::Handlers::Ruby::Base
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles any lone comment statement in a Ruby file
 class YARD::Handlers::Ruby::CommentHandler < YARD::Handlers::Ruby::Base
   handles :comment, :void_stmt

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles any constant assignment
 class YARD::Handlers::Ruby::ConstantHandler < YARD::Handlers::Ruby::Base
   include YARD::Handlers::Ruby::StructHandlerMethods
@@ -6,22 +7,25 @@ class YARD::Handlers::Ruby::ConstantHandler < YARD::Handlers::Ruby::Base
 
   process do
     if statement[1].call? && statement[1][0][0] == s(:const, "Struct") &&
-        statement[1][2] == s(:ident, "new")
+       statement[1][2] == s(:ident, "new")
       process_structclass(statement)
     elsif statement[0].type == :var_field && statement[0][0].type == :const
       process_constant(statement)
+    elsif statement[0].type == :const_path_field
+      process_constant(statement)
     end
   end
 
   private
 
   def process_constant(statement)
-    name = statement[0][0][0]
+    name = statement[0].source
     value = statement[1].source
     obj = P(namespace, name)
-    if obj.is_a?(NamespaceObject)
+    if obj.is_a?(NamespaceObject) && obj.namespace == namespace
       raise YARD::Parser::UndocumentableError, "constant for existing #{obj.type} #{obj}"
     else
+      ensure_loaded! obj.parent
       register ConstantObject.new(namespace, name) {|o| o.source = statement; o.value = value.strip }
     end
   end
@@ -43,8 +47,8 @@ class YARD::Handlers::Ruby::ConstantHandler < YARD::Handlers::Ruby::Base
   # @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 = 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/decorator_handler_methods.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 # Helper methods to assist with processing decorators.
 module YARD::Handlers::Ruby::DecoratorHandlerMethods
-
   # @overload process_decorator(*nodes, opts = {}, &block)
   #   Takes care of parsing method definitions passed to decorators
   #   as parameters, as well as parsing chained decorators.
@@ -49,25 +49,25 @@ module YARD::Handlers::Ruby::DecoratorHandlerMethods
 
     # Parse decorator parameters (decorator chain).
     all_nodes.each do |param|
-      parse_block param if param.call? or param.def?
+      parse_block param if param.call? || param.def?
     end
 
     selected_nodes =
       if nodes.empty?
         all_nodes
-      elsif (nodes.count == 1 and nodes.first == nil)
+      elsif nodes.count == 1 && nodes.first.nil?
         []
       else
         nodes
       end
 
-    decorated_methods = selected_nodes.map { |param|
+    decorated_methods = selected_nodes.map do |param|
       process_decorator_parameter param, opts, &block
-    }.flatten
+    end.flatten
 
     # Store method nodes in decorator node.
     statement.define_singleton_method :decorators do
-      decorated_methods.map { |h| h[:node] }
+      decorated_methods.map {|h| h[:node] }
     end
 
     decorated_methods
@@ -75,7 +75,7 @@ module YARD::Handlers::Ruby::DecoratorHandlerMethods
 
   private
 
-  def process_decorator_parameter(node, opts={}, &block)
+  def process_decorator_parameter(node, opts = {}, &block)
     scope              = opts.fetch :scope, :instance
     transfer_docstring = opts.fetch :transfer_docstring, true
     transfer_source    = opts.fetch :transfer_source, true
@@ -105,32 +105,19 @@ module YARD::Handlers::Ruby::DecoratorHandlerMethods
     )
 
     # Transfer source to methods passed to the helper as parameters.
-    method.source = statement.source if transfer_source and node.def?
-
-    # Tag decorator on decorated method.
-    if method.respond_to? :add_tag
-      method.add_tag YARD::Tags::Tag.new(
-        :decorator,
-        statement.jump(:command).jump(:ident).source
-      )
-    end
+    method.source = statement.source if transfer_source && node.def?
 
     # Transfer decorator docstring to methods passed to the helper as parameters.
-    if transfer_docstring \
-      and node.def? \
-      and statement.docstring \
-      and method.docstring.empty?
-        tags = method.tags if method.respond_to? :tags
-        tags ||= []
-
-        method.docstring = statement.docstring
-
-        tags.each { |t| method.add_tag t }
+    if transfer_docstring && node.def? &&
+       statement.docstring && method.docstring.empty?
+      tags = method.tags if method.respond_to? :tags
+      tags ||= []
+      method.docstring = statement.docstring
+      tags.each {|t| method.add_tag t }
     end
 
-    block.call method, node, name.to_sym if block_given?
+    yield method, node, name.to_sym if block_given?
 
     [{:method => method, :node => node, :name => name.to_sym}]
   end
-
 end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Handlers
     module Ruby

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Handlers
     module Ruby
@@ -22,13 +23,13 @@ module YARD
             attaching = true
           end
 
-          if macro = find_attached_macro
+          macro = find_attached_macro
+          if macro
             txt = macro.expand([caller_method, *call_params], statement.source)
             @docstring += "\n" + txt
 
-            if !attaching && txt.match(/^\s*@!/) # macro has a directive
-              return register_docstring(nil)
-            end
+            # macro may have a directive
+            return register_docstring(nil) if !attaching && txt.match(/^\s*@!/)
           elsif !statement.comments_hash_flag && !implicit_docstring?
             return register_docstring(nil)
           end
@@ -83,7 +84,7 @@ module YARD
         def macro_name_matches(macro)
           objs = [macro.method_object]
           if objs.first.type != :proxy && objs.first.respond_to?(:aliases)
-            objs.push(*objs.first.aliases)
+            objs.concat(objs.first.aliases)
           end
 
           objs.any? {|obj| obj.name.to_s == caller_method.to_s }
@@ -91,4 +92,4 @@ module YARD
       end
     end
   end
-end
+end