yard 0.9.5 → 0.9.6

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles 'raise' calls inside methods
 class YARD::Handlers::Ruby::ExceptionHandler < YARD::Handlers::Ruby::Base
   handles method_call(:raise)

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Handles 'extend' call to include modules into the class scope of another
 # @see MixinHandler
 class YARD::Handlers::Ruby::ExtendHandler < YARD::Handlers::Ruby::MixinHandler

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 # (see Ruby::AliasHandler)
 class YARD::Handlers::Ruby::Legacy::AliasHandler < YARD::Handlers::Ruby::Legacy::Base
-  handles /\Aalias(_method)?(\s|\()/
+  handles(/\Aalias(_method)?(\s|\()/)
   namespace_only
 
   process do
@@ -12,8 +13,9 @@ class YARD::Handlers::Ruby::Legacy::AliasHandler < YARD::Handlers::Ruby::Legacy:
     end
     raise YARD::Parser::UndocumentableError, statement.tokens.first.text if names.size != 2
 
-    names = names.map {|n| Symbol === n ? n.to_s.gsub('"', '') : n }
-    new_meth, old_meth = names[0].to_sym, names[1].to_sym
+    names = names.map {|n| Symbol === n ? n.to_s.delete('"') : n }
+    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.tokens.first.line_no, statement.comments)
@@ -32,4 +34,4 @@ class YARD::Handlers::Ruby::Legacy::AliasHandler < YARD::Handlers::Ruby::Legacy:
 
     namespace.aliases[new_obj] = old_meth
   end
-end
+end

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

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
 # (see Ruby::AttributeHandler)
 class YARD::Handlers::Ruby::Legacy::AttributeHandler < YARD::Handlers::Ruby::Legacy::Base
-  handles /\Aattr(?:_(?:reader|writer|accessor))?(?:\s|\()/
+  handles(/\Aattr(?:_(?:reader|writer|accessor))?(?:\s|\()/)
   namespace_only
 
   process do
     begin
       attr_type   = statement.tokens.first.text.to_sym
       symbols     = tokval_list statement.tokens[2..-1], :attr, TkTRUE, TkFALSE
-      read, write = true, false
+      read = true
+      write = false
     rescue SyntaxError
       raise YARD::Parser::UndocumentableError, attr_type
     end
@@ -22,7 +24,8 @@ class YARD::Handlers::Ruby::Legacy::AttributeHandler < YARD::Handlers::Ruby::Leg
     when :attr_reader
       # change nothing
     when :attr_writer
-      read, write = false, true
+      read = false
+      write = true
     end
 
     # Add all attributes
@@ -31,7 +34,7 @@ class YARD::Handlers::Ruby::Legacy::AttributeHandler < YARD::Handlers::Ruby::Leg
 
       # 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]]
@@ -50,11 +53,13 @@ class YARD::Handlers::Ruby::Legacy::AttributeHandler < YARD::Handlers::Ruby::Leg
 
           # 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
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Handlers
     module Ruby::Legacy
@@ -42,12 +43,10 @@ module YARD
 
         def call_params
           if statement.tokens.first.is_a?(TkDEF)
-            extract_method_details.last.map {|param| param.first }
+            extract_method_details.last.map(&:first)
           else
             tokens = statement.tokens[1..-1]
-            tokval_list(tokens, :attr, :identifier, TkId).map do |value|
-              value.to_s
-            end
+            tokval_list(tokens, :attr, :identifier, TkId).map(&:to_s)
           end
         end
 
@@ -56,8 +55,6 @@ module YARD
             statement.tokens.first.text
           elsif statement.tokens.first.is_a?(TkDEF)
             extract_method_details.first
-          else
-            nil
           end
         end
 
@@ -70,14 +67,13 @@ module YARD
         #   arguments (name and optional value)
         def extract_method_details
           if statement.tokens.to_s =~ /^def\s+(#{METHODMATCH})(?:(?:\s+|\s*\()(.*)(?:\)\s*$)?)?/m
-            meth, args = $1, $2
-            meth.gsub!(/\s+/,'')
+            meth = $1
+            args = $2
+            meth.gsub!(/\s+/, '')
             args = tokval_list(Parser::Ruby::Legacy::TokenList.new(args), :all)
             args.map! {|a| k, v = *a.split('=', 2); [k.strip, (v ? v.strip : nil)] } if args
-            if meth =~ /(?:#{NSEPQ}|#{CSEPQ})([^#{NSEP}#{CSEPQ}]+)$/
-              meth = $`
-            end
-            return meth, args
+            meth = $` if meth =~ /(?:#{NSEPQ}|#{CSEPQ})([^#{NSEP}#{CSEPQ}]+)$/
+            [meth, args]
           end
         end
 
@@ -145,7 +141,7 @@ module YARD
           when TkINTEGER
             token.text.to_i
           when TkREGEXP
-            token.text =~ /\A\/(.+)\/([^\/])\Z/
+            token.text =~ %r{\A/(.+)/([^/])\Z}
             Regexp.new($1, $2)
           when TkTRUE
             true
@@ -182,21 +178,22 @@ module YARD
         def tokval_list(tokenlist, *accepted_types)
           return [] unless tokenlist
           out = [[]]
-          parencount, beforeparen = 0, 0
+          parencount = 0
+          beforeparen = 0
           needcomma = false
           seen_comma = true
           tokenlist.each do |token|
             tokval = accepted_types == [:all] ? token.text : tokval(token, *accepted_types)
-            parencond = !out.last.empty? && tokval != nil
-            #puts "#{seen_comma.inspect} #{parencount} #{token.class.class_name} #{out.inspect}"
+            parencond = !out.last.empty? && !tokval.nil?
+            # puts "#{seen_comma.inspect} #{parencount} #{token.class.class_name} #{out.inspect}"
             case token
             when TkCOMMA
               if parencount == 0
                 out << [] unless out.last.empty?
                 needcomma = false
                 seen_comma = true
-              else
-                out.last << token.text if parencond
+              elsif parencond
+                out.last << token.text
               end
             when TkLPAREN
               if seen_comma
@@ -209,14 +206,14 @@ module YARD
               if beforeparen > 0
                 beforeparen -= 1
               else
-                out.last << token.text if parencount > 0 && tokval != nil
+                out.last << token.text if parencount > 0 && !tokval.nil?
                 parencount -= 1
               end
             when TkLBRACE, TkLBRACK, TkDO
               parencount += 1
-              out.last << token.text if tokval != nil
+              out.last << token.text unless tokval.nil?
             when TkRBRACE, TkRBRACK, TkEND
-              out.last << token.text if tokval != nil
+              out.last << token.text unless tokval.nil?
               parencount -= 1
             else
               break if TkKW === token && ![TkTRUE, TkFALSE, TkSUPER, TkSELF, TkNIL].include?(token.class)
@@ -225,7 +222,7 @@ module YARD
               if parencount == 0
                 next if needcomma
                 next if TkWhitespace === token
-                if tokval != nil
+                if !tokval.nil?
                   out.last << tokval
                 else
                   out.last.clear
@@ -237,9 +234,7 @@ module YARD
               end
             end
 
-            if beforeparen == 0 && parencount < 0
-              break
-            end
+            break if beforeparen == 0 && parencount < 0
           end
           # Flatten any single element lists
           out.map {|e| e.empty? ? nil : (e.size == 1 ? e.pop : e.flatten.join) }.compact
@@ -247,4 +242,4 @@ module YARD
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # (see Ruby::ClassConditionHandler)
 # @since 0.5.4
 class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby::Legacy::Base
@@ -6,7 +7,7 @@ class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby
 
   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
@@ -58,7 +59,7 @@ class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby
     end
 
     if TkUNLESS === statement.tokens.first
-      condition = !condition if condition != nil
+      condition = !condition unless condition.nil?
     end
     condition
   end
@@ -73,11 +74,10 @@ class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby
     return unless statement.block
     stmtlist = YARD::Parser::Ruby::Legacy::StatementList
     stmtlist.new(statement.block).each do |stmt|
-      if TkELSE === stmt.tokens.first
-        push_state(:visibility => visibility) do
-          parser.process(stmtlist.new(stmt.block))
-        end
+      next unless TkELSE === stmt.tokens.first
+      push_state(:visibility => visibility) do
+        parser.process(stmtlist.new(stmt.block))
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # (see Ruby::ClassHandler)
 class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy::Base
   include YARD::Handlers::Ruby::StructHandlerMethods
@@ -46,7 +47,7 @@ class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy:
 
       if classname == "self"
         parse_block(:namespace => namespace, :scope => :class)
-      elsif classname[0,1] =~ /[A-Z]/
+      elsif classname[0, 1] =~ /[A-Z]/
         register ClassObject.new(namespace, classname) if Proxy === proxy
         parse_block(:namespace => proxy, :scope => :class)
       else
@@ -67,7 +68,7 @@ class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy:
   # @return [Array<String>] a list of member names
   def extract_parameters(superstring)
     paramstring = superstring.match(/\A(O?Struct)\.new\((.*?)\)/)[2]
-    paramstring.split(",").select {|x| x.strip[0,1] == ":"}.map {|x| x.strip[1..-1] } # the 1..-1 chops the leading :
+    paramstring.split(",").select {|x| x.strip[0, 1] == ":" }.map {|x| x.strip[1..-1] } # the 1..-1 chops the leading :
   end
 
   def create_struct_superclass(superclass, superclass_def)
@@ -80,10 +81,11 @@ class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy:
   end
 
   def struct_superclass_name(superclass)
-    if match = superclass.match(/\A(Struct)\.new\((.*?)\)/)
+    match = superclass.match(/\A(Struct)\.new\((.*?)\)/)
+    if match
       paramstring = match[2].split(",")
       first = paramstring.first.strip
-      if first[0,1] =~ /['"]/ && first[-1,1] =~ /['"]/ && first !~ /\#\{/
+      if first[0, 1] =~ /['"]/ && first[-1, 1] =~ /['"]/ && first !~ /\#\{/
         return "Struct::#{first[1..-2]}"
       end
     end
@@ -108,4 +110,4 @@ class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy:
       namespace.path
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # (see Ruby::ClassVariableHandler)
 class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < YARD::Handlers::Ruby::Legacy::Base
   HANDLER_MATCH = /\A@@\w+\s*=\s*/m
@@ -11,4 +12,4 @@ class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < YARD::Handlers::Ruby:
       o.value = value.strip
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # (see Ruby::CommentHandler)
 class YARD::Handlers::Ruby::Legacy::CommentHandler < YARD::Handlers::Ruby::Legacy::Base
   handles TkCOMMENT

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # (see Ruby::ConstantHandler)
 class YARD::Handlers::Ruby::Legacy::ConstantHandler < YARD::Handlers::Ruby::Legacy::Base
   include YARD::Handlers::Ruby::StructHandlerMethods
@@ -23,6 +24,6 @@ class YARD::Handlers::Ruby::Legacy::ConstantHandler < YARD::Handlers::Ruby::Lega
 
   def extract_parameters(parameters)
     members = tokval_list(YARD::Parser::Ruby::Legacy::TokenList.new(parameters), TkSYMBOL)
-    members.map {|m| m.to_s }
+    members.map(&:to_s)
   end
 end

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

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

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 # (see Ruby::ExceptionHandler)
 class YARD::Handlers::Ruby::Legacy::ExceptionHandler < YARD::Handlers::Ruby::Legacy::Base
-  handles /\Araise(\s|\(|\Z)/
+  handles(/\Araise(\s|\(|\Z)/)
 
   process do
     return unless owner.is_a?(MethodObject) # Only methods yield

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 # (see Ruby::ExtendHandler)
 class YARD::Handlers::Ruby::Legacy::ExtendHandler < YARD::Handlers::Ruby::Legacy::MixinHandler
-  handles /\Aextend(\s|\()/
+  handles(/\Aextend(\s|\()/)
   namespace_only
 
   def scope; :class end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # (see Ruby::MethodHandler)
 class YARD::Handlers::Ruby::Legacy::MethodHandler < YARD::Handlers::Ruby::Legacy::Base
   handles TkDEF
@@ -7,8 +8,9 @@ class YARD::Handlers::Ruby::Legacy::MethodHandler < YARD::Handlers::Ruby::Legacy
     mscope = scope
 
     if statement.tokens.to_s =~ /^def\s+(#{METHODMATCH})(?:(?:\s+|\s*\()(.*)(?:\)\s*$)?)?/m
-      meth, args = $1, $2
-      meth.gsub!(/\s+/,'')
+      meth = $1
+      args = $2
+      meth.gsub!(/\s+/, '')
       args = tokval_list(YARD::Parser::Ruby::Legacy::TokenList.new(args), :all)
       args.map! do |a|
         k, v, r = *a.split(/(:)|=/, 2)
@@ -24,7 +26,9 @@ class YARD::Handlers::Ruby::Legacy::MethodHandler < YARD::Handlers::Ruby::Legacy
 
     # Class method if prefixed by self(::|.) or Module(::|.)
     if meth =~ /(?:#{NSEPQ}|#{CSEPQ})([^#{NSEP}#{CSEPQ}]+)$/
-      mscope, meth, prefix = :class, $1, $`
+      mscope = :class
+      meth = $1
+      prefix = $`
       if prefix =~ /^[a-z]/ && prefix != "self"
         raise YARD::Parser::UndocumentableError, 'method defined on object instance'
       end
@@ -72,11 +76,12 @@ class YARD::Handlers::Ruby::Legacy::MethodHandler < YARD::Handlers::Ruby::Legacy
       end
     end
 
-    if info = obj.attr_info
+    info = obj.attr_info
+    if info
       if meth.to_s =~ /=$/ # writer
         info[:write] = obj if info[:read]
-      else
-        info[:read] = obj if info[:write]
+      elsif info[:write]
+        info[:read] = obj
       end
     end
 

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 # (see Ruby::MixinHandler)
 class YARD::Handlers::Ruby::Legacy::MixinHandler < YARD::Handlers::Ruby::Legacy::Base
-  handles /\Ainclude(\s|\()/
+  handles(/\Ainclude(\s|\()/)
   namespace_only
 
   process do
@@ -14,7 +15,7 @@ class YARD::Handlers::Ruby::Legacy::MixinHandler < YARD::Handlers::Ruby::Legacy:
       end
     end
 
-    if errors.size > 0
+    unless errors.empty?
       msg = errors.size == 1 ? ": #{errors[0]}" : "s: #{errors.join(", ")}"
       raise YARD::Parser::UndocumentableError, "mixin#{msg} for class #{namespace.path}"
     end
@@ -23,9 +24,8 @@ class YARD::Handlers::Ruby::Legacy::MixinHandler < YARD::Handlers::Ruby::Legacy:
   private
 
   def process_mixin(mixin)
-    unless mixmatch = mixin[/\A(#{NAMESPACEMATCH})/, 1]
-      raise YARD::Parser::UndocumentableError
-    end
+    mixmatch = mixin[/\A(#{NAMESPACEMATCH})/, 1]
+    raise YARD::Parser::UndocumentableError unless mixmatch
 
     case obj = Proxy.new(namespace, mixmatch)
     when ConstantObject # If a constant is included, use its value as the real object

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 # (see Ruby::ModuleFunctionHandler)
 class YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler < YARD::Handlers::Ruby::Legacy::Base
-  handles /\A(module_function)(\s|\(|$)/
+  handles(/\A(module_function)(\s|\(|$)/)
   namespace_only
 
   process do

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # (see Ruby::ModuleHandler)
 class YARD::Handlers::Ruby::Legacy::ModuleHandler < YARD::Handlers::Ruby::Legacy::Base
   handles TkMODULE
@@ -8,4 +9,4 @@ class YARD::Handlers::Ruby::Legacy::ModuleHandler < YARD::Handlers::Ruby::Legacy
     mod = register ModuleObject.new(namespace, modname)
     parse_block(:namespace => mod)
   end
-end
+end