yard 0.9.5 → 0.9.6

data/lib/yard/gem_index.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Backward compatability for gem specification lookup
+# @see Gem::SourceIndex
+module YARD
+  module GemIndex
+    module_function
+
+    def find_all_by_name(*args)
+      if defined?(Gem::Specification) && Gem::Specification.respond_to?(:find_all_by_name)
+        Gem::Specification.find_all_by_name(*args)
+      else
+        Gem.source_index.find_name(*args)
+      end
+    end
+  end
+end

data/lib/yard/globals.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
 # @group Global Convenience Methods
 
 # Shortcut for creating a YARD::CodeObjects::Proxy via a path
 #
 # @see YARD::CodeObjects::Proxy
 # @see YARD::Registry.resolve
-def P(namespace, name = nil, type = nil)
-  namespace, name = nil, namespace if name.nil?
+def P(namespace, name = nil, type = nil) # rubocop:disable Style/MethodName
+  if name.nil?
+    name = namespace
+    namespace = nil
+  end
   YARD::Registry.resolve(namespace, name, false, true, type)
 end
 

data/lib/yard/handlers/base.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Handlers
     # Raise this error when a handler should exit before completing.
@@ -189,7 +190,7 @@ module YARD
         #   statement.
         #
         def handles(*matches)
-          (@handlers ||= []).push(*matches)
+          (@handlers ||= []).concat(matches)
         end
 
         # This class is implemented by {Ruby::Base} and {Ruby::Legacy::Base}.
@@ -201,7 +202,7 @@ module YARD
         # @param statement a statement object or node (depends on language type)
         # @return [Boolean] whether or not this handler object should process
         #   the given statement
-        def handles?(statement)
+        def handles?(statement) # rubocop:disable Lint/UnusedMethodArgument
           raise NotImplementedError, "override #handles? in a subclass"
         end
 
@@ -222,7 +223,7 @@ module YARD
         # @return [Boolean] whether the handler should only be processed inside
         #   a namespace.
         def namespace_only?
-          (@namespace_only ||= false) ? true : false
+          @namespace_only ||= false
         end
 
         # Declares that a handler should only be called when inside a filename
@@ -300,7 +301,7 @@ module YARD
       # Parses the semantic "block" contained in the statement node.
       #
       # @abstract Subclasses should call {Processor#process parser.process}
-      def parse_block(*args)
+      def parse_block(*)
         raise NotImplementedError, "#{self} did not implement a #parse_block method for handling"
       end
 
@@ -336,13 +337,13 @@ module YARD
       undef globals, extra_state
 
       def owner; parser.owner end
-      def owner=(v) parser.owner=(v) end
+      def owner=(v) parser.owner = v end
       def namespace; parser.namespace end
-      def namespace=(v); parser.namespace=(v) end
+      def namespace=(v); parser.namespace = v end
       def visibility; parser.visibility end
-      def visibility=(v); parser.visibility=(v) end
+      def visibility=(v); parser.visibility = v end
       def scope; parser.scope end
-      def scope=(v); parser.scope=(v) end
+      def scope=(v); parser.scope = v end
       def globals; parser.globals end
       def extra_state; parser.extra_state end
 
@@ -358,7 +359,6 @@ module YARD
       # Executes a given block with specific state values for {#owner},
       # {#namespace} and {#scope}.
       #
-      # @param [Proc] block the block to execute with specific state
       # @option opts [CodeObjects::NamespaceObject] :namespace (value of #namespace)
       #   the namespace object that {#namespace} will be equal to for the
       #   duration of the block.
@@ -367,7 +367,7 @@ module YARD
       # @option opts [CodeObjects::Base] :owner (value of #owner)
       #   the owner object (method) for the duration of the block
       # @yield a block to execute with the given state values.
-      def push_state(opts = {}, &block)
+      def push_state(opts = {})
         opts = {
           :namespace => namespace,
           :scope => :instance,
@@ -375,7 +375,10 @@ module YARD
           :visibility => nil
         }.update(opts)
 
-        ns, vis, sc, oo = namespace, visibility, scope, owner
+        ns = namespace
+        vis = visibility
+        sc = scope
+        oo = owner
         self.namespace = opts[:namespace]
         self.visibility = opts[:visibility] || :public
         self.scope = opts[:scope]
@@ -424,11 +427,10 @@ module YARD
       # @return [void]
       # @since 0.8.0
       def register_ensure_loaded(object)
-        begin
-          ensure_loaded!(object.namespace)
-          object.namespace.children << object
-        rescue NamespaceMissingError
-        end
+        ensure_loaded!(object.namespace)
+        object.namespace.children << object
+      rescue NamespaceMissingError
+        nil # noop
       end
 
       # Registers the file/line of the declaration with the object
@@ -523,7 +525,7 @@ module YARD
         return unless object.module_function?
         modobj = MethodObject.new(object.namespace, object.name)
         object.copy_to(modobj)
-        modobj.visibility = :private
+        modobj.visibility = :private # rubocop:disable Lint/UselessSetterCall
       end
 
       # Registers the object as dynamic if the object is defined inside
@@ -562,12 +564,9 @@ module YARD
 
         retries = 0
         while object.is_a?(Proxy)
-          if retries <= max_retries
-            log.debug "Missing object #{object} in file `#{parser.file}', moving it to the back of the line."
-            parser.parse_remaining_files
-          else
-            raise NamespaceMissingError, object
-          end
+          raise NamespaceMissingError, object if retries > max_retries
+          log.debug "Missing object #{object} in file `#{parser.file}', moving it to the back of the line."
+          parser.parse_remaining_files
           retries += 1
         end
         object

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::AliasHandler < YARD::Handlers::C::Base
-  MATCH = %r{rb_define_alias
+  MATCH = /rb_define_alias
              \s*\(\s*([\w\.]+),
              \s*"([^"]+)",
-             \s*"([^"]+)"\s*\)}xm
+             \s*"([^"]+)"\s*\)/xm
   handles MATCH
   statement_class BodyStatement
 

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

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::AttributeHandler < YARD::Handlers::C::Base
-  MATCH = %r{rb_define_attr\s*\(\s*([\w\.]+),\s*"([^"]+)",\s*(0|1)\s*,\s*(0|1)\s*\)}
+  MATCH = /rb_define_attr\s*\(\s*([\w\.]+),\s*"([^"]+)",\s*(0|1)\s*,\s*(0|1)\s*\)/
   handles MATCH
 
   process do
@@ -9,5 +10,4 @@ class YARD::Handlers::C::AttributeHandler < YARD::Handlers::C::Base
       handle_attribute(var_name, name, read, write)
     end
   end
-
 end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Handlers
     module C
@@ -10,11 +11,8 @@ module YARD
           processor.globals.cruby_processed_files ||= {}
           processor.globals.cruby_processed_files[processor.file] = true
 
-          if statement.respond_to? :declaration
-            src = statement.declaration
-          else
-            src = statement.source
-          end
+          src = statement.respond_to?(:declaration) ?
+            statement.declaration : statement.source
 
           handlers.any? do |a_handler|
             statement_class >= statement.class &&
@@ -28,7 +26,11 @@ module YARD
         end
 
         def self.statement_class(type = nil)
-          type ? @statement_class = type : (@statement_class || Statement)
+          if type
+            @statement_class = type
+          else
+            (defined?(@statement_class) && @statement_class) || Statement
+          end
         end
 
         # @group Registering objects
@@ -66,18 +68,16 @@ module YARD
         end
 
         def ensure_variable_defined!(var, max_retries = 1)
-          retries, object = 0, nil
+          retries = 0
+          object = nil
 
           loop do
             object = namespace_for_variable(var)
             break unless object.is_a?(Proxy)
 
-            if retries <= max_retries
-              log.debug "Missing namespace variable #{var} in file `#{parser.file}', moving it to the back of the line."
-              parser.parse_remaining_files
-            else
-              raise NamespaceMissingError, object
-            end
+            raise NamespaceMissingError, object if retries > max_retries
+            log.debug "Missing namespace variable #{var} in file `#{parser.file}', moving it to the back of the line."
+            parser.parse_remaining_files
             retries += 1
           end
 

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::ClassHandler < YARD::Handlers::C::Base
   MATCH1 = /([\w\.]+)\s* = \s*(?:rb_define_class|boot_defclass)\s*
             \(

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::ConstantHandler < YARD::Handlers::C::Base
-  MATCH = %r{\brb_define_((?:readonly_)?variable|(?:global_)?const)
-                \s*\((?:\s*(\w+),)?\s*"(\w+)",\s*(.*?)\s*\)\s*;}xm
+  MATCH = /\brb_define_((?:readonly_)?variable|(?:global_)?const)
+                \s*\((?:\s*(\w+),)?\s*"(\w+)",\s*(.*?)\s*\)\s*;/xm
   handles MATCH
   statement_class BodyStatement
 

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Handlers
     module C
@@ -9,8 +10,8 @@ module YARD
           parent = nil if parent == "0"
           namespace = in_module ? ensure_variable_defined!(in_module) : Registry.root
           if namespace.nil?
-            raise Parser::UndocumentableError, "class #{class_name}. " +
-              "Cannot find definition for parent namespace."
+            raise Parser::UndocumentableError,
+              "class #{class_name}. Cannot find definition for parent namespace."
           end
 
           register ClassObject.new(namespace, class_name) do |obj|
@@ -31,8 +32,8 @@ module YARD
         def handle_module(var_name, module_name, in_module = nil)
           namespace = in_module ? ensure_variable_defined!(in_module) : Registry.root
           if namespace.nil?
-            raise Parser::UndocumentableError, "module #{module_name}. " +
-              "Cannot find definition for parent namespace."
+            raise Parser::UndocumentableError,
+              "module #{module_name}. Cannot find definition for parent namespace."
           end
 
           register ModuleObject.new(namespace, module_name) do |obj|
@@ -41,7 +42,7 @@ module YARD
           end
         end
 
-        def handle_method(scope, var_name, name, func_name, source_file = nil)
+        def handle_method(scope, var_name, name, func_name, _source_file = nil)
           visibility = :public
           case scope
           when "singleton_method"; scope = :class
@@ -84,7 +85,8 @@ module YARD
         def handle_alias(var_name, new_name, old_name)
           namespace = namespace_for_variable(var_name)
           return if namespace.nil?
-          new_meth, old_meth = new_name.to_sym, old_name.to_sym
+          new_meth = new_name.to_sym
+          old_meth = old_name.to_sym
           old_obj = namespace.child(:name => old_meth, :scope => :instance)
           new_obj = register MethodObject.new(namespace, new_meth, :instance) do |o|
             register_visibility(o, visibility)
@@ -105,11 +107,8 @@ module YARD
 
         def handle_constants(type, var_name, const_name, value)
           return unless type =~ /^const$|^global_const$/
-          if type == 'global_const'
-            namespace = :root
-          else
-            namespace = namespace_for_variable(var_name)
-          end
+          namespace = type == 'global_const' ?
+            :root : namespace_for_variable(var_name)
           register ConstantObject.new(namespace, const_name) do |obj|
             obj.source_type = :c
             obj.value = value
@@ -129,7 +128,6 @@ module YARD
             just_const_name = name.gsub(/\A.+::/, '')
             if object.path == name || object.name.to_s == just_const_name
               comment = override_comment.source
-              stmt = override_comment
               break
             end
           end
@@ -153,13 +151,16 @@ module YARD
         end
 
         def find_method_body(object, symbol)
-          file, in_file = statement.file, false
+          file = statement.file
+          in_file = false
           if statement.comments && statement.comments.source =~ /\A\s*in (\S+)\Z/
-            file, in_file = $1, true
+            file = $1
+            in_file = true
             process_file(file, object)
           end
 
-          if src_stmt = symbols[symbol]
+          src_stmt = symbols[symbol]
+          if src_stmt
             register_file_info(object, src_stmt.file, src_stmt.line, true)
             register_source(object, src_stmt)
             record_parameters(object, symbol, src_stmt)
@@ -171,19 +172,17 @@ module YARD
 
           # found source (possibly) but no docstring
           # so look in overrides
-          override_comments.each do |name, override_comment|
+          return if override_comments.any? do |name, override_comment|
             next unless override_comment.file == file
             name = name.gsub(/::([^:\.#]+?)\Z/, '.\1')
 
-            path = if name =~ /\.|#/ # explicit namespace in override comment
-              object.path
-            else
-              object.name.to_s
-            end
-
+            # explicit namespace in override comment
+            path = (name =~ /\.|#/ ? object.path : object.name.to_s)
             if path == name || path == name.sub(/new$/, 'initialize') || path == name.sub('.', '#')
               register_docstring(object, override_comment.source, override_comment)
-              return
+              true
+            else
+              false
             end
           end
 
@@ -196,13 +195,13 @@ module YARD
         def record_parameters(object, symbol, src)
           # use regex to extract comma-delimited list of parameters from cfunc definition
           if src.source =~ /VALUE\s+#{symbol}\(([^)]*)\)\s*\{/m
-            params = $~[1].split(/\s*,\s*/)
+            params = $~[1].split(/\s*,\s*/) # rubocop:disable Style/SpecialGlobalVars
             # cfunc for a "varargs" method has params "int argc, VALUE *argv"
             if params[0] =~ /int\s+argc/ && params[1] =~ /VALUE\s*\*\s*argv/
               object.parameters = [['*args', nil]]
             else
               # the first cfunc argument is the 'self' argument, we don't need that
-              object.parameters = params.drop(1).map { |s| [s[/VALUE\s+(\S+)/, 1], nil] }
+              object.parameters = params.drop(1).map {|s| [s[/VALUE\s+(\S+)/, 1], nil] }
             end
           end
         end

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

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
 # Handles the Init_Libname() method
 class YARD::Handlers::C::InitHandler < YARD::Handlers::C::Base
-  MATCH = %r{\A\s*(?:\S+\s+)*void\s+(?:[Ii]nit_)?(\w+)\s*}
+  MATCH = /\A\s*(?:\S+\s+)*void\s+(?:[Ii]nit_)?(\w+)\s*/
   handles MATCH
   statement_class ToplevelStatement
 
   process do
     parse_block
-    if decl = statement.declaration[MATCH, 1]
+    decl = statement.declaration[MATCH, 1]
+    if decl
       ns = namespace_for_variable(decl)
       if ns.is_a?(YARD::CodeObjects::NamespaceObject) && ns.docstring.blank?
         if statement.comments

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

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::MethodHandler < YARD::Handlers::C::Base
-  MATCH1 = %r{rb_define_
+  MATCH1 = /rb_define_
                  (
                     singleton_method |
                     method           |
@@ -9,17 +10,17 @@ class YARD::Handlers::C::MethodHandler < YARD::Handlers::C::Base
                  \s*\(\s*([\w\.]+)\s*,
                    \s*"([^"]+)"\s*,
                    \s*(?:RUBY_METHOD_FUNC\(|VALUEFUNC\(|\(\w+\))?(\w+)\)?\s*,
-                   \s*(-?\w+)\s*\)}xm
-  MATCH2 = %r{rb_define_global_function\s*\(
+                   \s*(-?\w+)\s*\)/xm
+  MATCH2 = /rb_define_global_function\s*\(
                 \s*"([^"]+)",
                 \s*(?:RUBY_METHOD_FUNC\(|VALUEFUNC\(|\(\w+\))?(\w+)\)?,
-                \s*(-?\w+)\s*\)}xm
+                \s*(-?\w+)\s*\)/xm
   handles MATCH1
   handles MATCH2
   statement_class BodyStatement
 
   process do
-    statement.source.scan(MATCH1) do |type, var_name, name, func_name, param_count|
+    statement.source.scan(MATCH1) do |type, var_name, name, func_name, _param_count|
       break if var_name == "ruby_top_self"
       break if var_name == "nstr"
       break if var_name == "envtbl"
@@ -28,7 +29,7 @@ class YARD::Handlers::C::MethodHandler < YARD::Handlers::C::Base
       handle_method(type, var_name, name, func_name)
     end
 
-    statement.source.scan(MATCH2) do |name, func_name, param_count|
+    statement.source.scan(MATCH2) do |name, func_name, _param_count|
       handle_method("method", "rb_mKernel", name, func_name)
     end
   end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class YARD::Handlers::C::MixinHandler < YARD::Handlers::C::Base
   MATCH = /rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/
   handles MATCH
@@ -8,7 +9,8 @@ class YARD::Handlers::C::MixinHandler < YARD::Handlers::C::Base
       namespace = namespace_for_variable(klass_var)
       ensure_loaded!(namespace)
 
-      if var = namespace_for_variable(mixin_var)
+      var = namespace_for_variable(mixin_var)
+      if var
         namespace.mixins(:instance) << var
       else
         raise YARD::Parser::UndocumentableError,