yard 0.9.16 → 0.9.21

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

@@ -7,8 +7,9 @@ module YARD
         include Parser
 
         IGNORE_METHODS = Hash[*%w(alias alias_method autoload attr attr_accessor
-          attr_reader attr_writer extend include public private protected
-          private_constant).map {|n| [n, true] }.flatten]
+          attr_reader attr_writer extend include module_function public private
+          protected private_constant private_class_method public_class_method).
+          map {|n| [n, true] }.flatten]
 
         def handle_comments
           return if IGNORE_METHODS[caller_method]
@@ -39,9 +40,9 @@ module YARD
             return register_docstring(nil)
           end
 
-          object = MethodObject.new(namespace, method_name, scope)
-          object.signature = method_signature
-          register(object)
+          register MethodObject.new(namespace, method_name, scope) do |o|
+            o.signature = method_signature
+          end
         end
 
         def register_docstring(object, docstring = @docstring, stmt = statement)

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # Handles a method definition
 class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
+  include YARD::Handlers::Common::MethodHandler
+
   handles :def, :defs
 
   process do
@@ -19,7 +21,6 @@ class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
 
     nobj = P(namespace, nobj.value) while nobj.type == :constant
     obj = register MethodObject.new(nobj, meth, mscope) do |o|
-      o.signature = method_signature
       o.explicit = true
       o.parameters = args
     end
@@ -39,13 +40,7 @@ class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
         extended method_added method_removed method_undefined).include?(meth)
       obj.add_tag(YARD::Tags::Tag.new(:private, nil))
     elsif meth.to_s =~ /\?$/
-      if obj.tag(:return) && (obj.tag(:return).types || []).empty?
-        obj.tag(:return).types = ['Boolean']
-      elsif obj.tag(:return).nil?
-        unless obj.tags(:overload).any? {|overload| overload.tag(:return) }
-          obj.add_tag(YARD::Tags::Tag.new(:return, "", "Boolean"))
-        end
-      end
+      add_predicate_return_tag(obj)
     end
 
     if obj.has_tag?(:option)
@@ -106,13 +101,4 @@ class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
 
     params
   end
-
-  def method_signature
-    method_name = statement.method_name(true)
-    if statement.parameters.any? {|e| e }
-      "def #{method_name}(#{statement.parameters.source})"
-    else
-      "def #{method_name}"
-    end
-  end
 end

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

@@ -32,6 +32,18 @@ class YARD::Handlers::Ruby::MixinHandler < YARD::Handlers::Ruby::Base
       obj = Proxy.new(namespace, mixin.source, :module)
     end
 
-    namespace.mixins(scope).unshift(obj) unless namespace.mixins(scope).include?(obj)
+    rec = recipient(mixin)
+    return if rec.nil? || rec.mixins(scope).include?(obj)
+    rec.mixins(scope).unshift(obj)
+  end
+
+  def recipient(mixin)
+    if statement[0].type == :var_ref && statement[0][0] != s(:kw, "self")
+      statement[0][0].type == :const ?
+        Proxy.new(namespace, statement.namespace.source) :
+        nil
+    else
+      namespace
+    end
   end
 end

data/lib/yard/parser/c/statement.rb

@@ -31,6 +31,8 @@ module YARD
           source.split(/\n/).first
         end
 
+        alias signature first_line
+
         def show
           "\t#{line}: #{first_line}"
         end

data/lib/yard/parser/ruby/ast_node.rb

@@ -485,6 +485,17 @@ module YARD
           include_block_param ? params : params[0...-1]
         end
 
+        def signature
+          params_src = ''
+          params = self[1 + index_adjust]
+          if params.first
+            params_src = params.type == :paren ? '' : ' '
+            params_src += params.source.gsub(/\s+(\s|\))/m, '\1')
+          end
+
+          "def #{method_name(true)}#{params_src}"
+        end
+
         alias block last
 
         private

data/lib/yard/parser/ruby/legacy/irb/slex.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: false
+#
+#   irb/slex.rb - simple lex analyzer
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "irb/notifier"
+
+# :stopdoc:
+module IRB
+  class SLex
+    DOUT = Notifier::def_notifier("SLex::")
+    D_WARN = DOUT::def_notifier(1, "Warn: ")
+    D_DEBUG = DOUT::def_notifier(2, "Debug: ")
+    D_DETAIL = DOUT::def_notifier(4, "Detail: ")
+
+    DOUT.level = Notifier::D_NOMSG
+
+    def initialize
+      @head = Node.new("")
+    end
+
+    def def_rule(token, preproc = nil, postproc = nil, &block)
+      D_DETAIL.pp token
+
+      postproc = block if block_given?
+      create(token, preproc, postproc)
+    end
+
+    def def_rules(*tokens, &block)
+      if block_given?
+        p = block
+      end
+      for token in tokens
+        def_rule(token, nil, p)
+      end
+    end
+
+    def preproc(token, proc)
+      node = search(token)
+      node.preproc=proc
+    end
+
+    # need a check?
+    def postproc(token)
+      node = search(token, proc)
+      node.postproc=proc
+    end
+
+    def search(token)
+      @head.search(token.split(//))
+    end
+
+    def create(token, preproc = nil, postproc = nil)
+      @head.create_subnode(token.split(//), preproc, postproc)
+    end
+
+    def match(token)
+      case token
+      when Array
+      when String
+        return match(token.split(//))
+      else
+        return @head.match_io(token)
+      end
+      ret = @head.match(token)
+      D_DETAIL.exec_if{D_DETAIL.printf "match end: %s:%s\n", ret, token.inspect}
+      ret
+    end
+
+    def inspect
+      format("<SLex: @head = %s>", @head.inspect)
+    end
+
+    #----------------------------------------------------------------------
+    #
+    #   class Node -
+    #
+    #----------------------------------------------------------------------
+    class Node
+      # if postproc is nil, this node is an abstract node.
+      # if postproc is non-nil, this node is a real node.
+      def initialize(preproc = nil, postproc = nil)
+        @Tree = {}
+        @preproc = preproc
+        @postproc = postproc
+      end
+
+      attr_accessor :preproc
+      attr_accessor :postproc
+
+      def search(chrs, opt = nil)
+        return self if chrs.empty?
+        ch = chrs.shift
+        if node = @Tree[ch]
+          node.search(chrs, opt)
+        else
+          if opt
+            chrs.unshift ch
+            self.create_subnode(chrs)
+          else
+            raise "node nothing"
+          end
+        end
+      end
+
+      def create_subnode(chrs, preproc = nil, postproc = nil)
+        if chrs.empty?
+          if @postproc
+            D_DETAIL.pp node
+            raise "node already exists"
+          else
+            D_DEBUG.puts "change abstract node to real node."
+            @preproc = preproc
+            @postproc = postproc
+          end
+          return self
+        end
+
+        ch = chrs.shift
+        if node = @Tree[ch]
+          if chrs.empty?
+            if node.postproc
+              DebugLogger.pp node
+              DebugLogger.pp self
+              DebugLogger.pp ch
+              DebugLogger.pp chrs
+              raise "node already exists"
+            else
+              D_WARN.puts "change abstract node to real node"
+              node.preproc = preproc
+              node.postproc = postproc
+            end
+          else
+            node.create_subnode(chrs, preproc, postproc)
+          end
+        else
+          if chrs.empty?
+            node = Node.new(preproc, postproc)
+          else
+            node = Node.new
+            node.create_subnode(chrs, preproc, postproc)
+          end
+          @Tree[ch] = node
+        end
+        node
+      end
+
+      #
+      # chrs: String
+      #       character array
+      #       io must have getc()/ungetc(); and ungetc() must be
+      #       able to be called arbitrary number of times.
+      #
+      def match(chrs, op = "")
+        D_DETAIL.print "match>: ", chrs, "op:", op, "\n"
+        if chrs.empty?
+          if @preproc.nil? || @preproc.call(op, chrs)
+            DOUT.printf(D_DETAIL, "op1: %s\n", op)
+            @postproc.call(op, chrs)
+          else
+            nil
+          end
+        else
+          ch = chrs.shift
+          if node = @Tree[ch]
+            if ret = node.match(chrs, op+ch)
+              return ret
+            else
+              chrs.unshift ch
+              if @postproc and @preproc.nil? || @preproc.call(op, chrs)
+                DOUT.printf(D_DETAIL, "op2: %s\n", op.inspect)
+                ret = @postproc.call(op, chrs)
+                return ret
+              else
+                return nil
+              end
+            end
+          else
+            chrs.unshift ch
+            if @postproc and @preproc.nil? || @preproc.call(op, chrs)
+              DOUT.printf(D_DETAIL, "op3: %s\n", op)
+              @postproc.call(op, chrs)
+              return ""
+            else
+              return nil
+            end
+          end
+        end
+      end
+
+      def match_io(io, op = "")
+        if op == ""
+          ch = io.getc
+          if ch == nil
+            return nil
+          end
+        else
+          ch = io.getc_of_rests
+        end
+        if ch.nil?
+          if @preproc.nil? || @preproc.call(op, io)
+            D_DETAIL.printf("op1: %s\n", op)
+            @postproc.call(op, io)
+          else
+            nil
+          end
+        else
+          if node = @Tree[ch]
+            if ret = node.match_io(io, op+ch)
+              ret
+            else
+              io.ungetc ch
+              if @postproc and @preproc.nil? || @preproc.call(op, io)
+                DOUT.exec_if{D_DETAIL.printf "op2: %s\n", op.inspect}
+                @postproc.call(op, io)
+              else
+                nil
+              end
+            end
+          else
+            io.ungetc ch
+            if @postproc and @preproc.nil? || @preproc.call(op, io)
+              D_DETAIL.printf("op3: %s\n", op)
+              @postproc.call(op, io)
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# :startdoc:
+
+if $0 == __FILE__
+  case $1
+  when "1"
+    tr = SLex.new
+    print "0: ", tr.inspect, "\n"
+    tr.def_rule("=") {print "=\n"}
+    print "1: ", tr.inspect, "\n"
+    tr.def_rule("==") {print "==\n"}
+    print "2: ", tr.inspect, "\n"
+
+    print "case 1:\n"
+    print tr.match("="), "\n"
+    print "case 2:\n"
+    print tr.match("=="), "\n"
+    print "case 3:\n"
+    print tr.match("=>"), "\n"
+
+  when "2"
+    tr = SLex.new
+    print "0: ", tr.inspect, "\n"
+    tr.def_rule("=") {print "=\n"}
+    print "1: ", tr.inspect, "\n"
+    tr.def_rule("==", proc{false}) {print "==\n"}
+    print "2: ", tr.inspect, "\n"
+
+    print "case 1:\n"
+    print tr.match("="), "\n"
+    print "case 2:\n"
+    print tr.match("=="), "\n"
+    print "case 3:\n"
+    print tr.match("=>"), "\n"
+  end
+  exit
+end

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

@@ -1,5 +1,4 @@
-require "e2mmap"
-require "irb/slex"
+require_relative 'irb/slex'
 
 module YARD
   module Parser::Ruby::Legacy
@@ -129,7 +128,7 @@ module YARD
         when String, Symbol
           source = token.is_a?(String) ? TkReading2Token : TkSymbol2Token
           if (tk = source[token]).nil?
-            IRB.fail TkReading2TokenNoKey, token
+            raise "no key #{token}"
           end
           tk = Token(tk[0], value)
         else
@@ -285,7 +284,7 @@ module YARD
 
         if reading
           if TkReading2Token[reading]
-            IRB.fail TkReading2TokenDuplicateError, token_n, reading
+            raise "duplicate #{token_n} #{reading}"
           end
           if opts.empty?
             TkReading2Token[reading] = [token_c]
@@ -425,14 +424,6 @@ module YARD
 
       # end of nested class BufferedReader
 
-      extend Exception2MessageMapper
-      def_exception(:AlreadyDefinedToken, "Already defined token(%s)")
-      def_exception(:TkReading2TokenNoKey, "key nothing(key='%s')")
-      def_exception(:TkSymbol2TokenNoKey, "key nothing(key='%s')")
-      def_exception(:TkReading2TokenDuplicateError,
-        "key duplicate(token_n='%s', key='%s')")
-      def_exception(:SyntaxError, "%s")
-
       include RubyToken
       include IRB
 

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

@@ -22,6 +22,8 @@ module YARD
         to_s.split(/\n/)[0]
       end
 
+      alias signature first_line
+
       def to_s(include_block = true)
         tokens.map do |token|
           RubyToken::TkBlockContents === token ? (include_block ? block.to_s : '') : token.text

data/lib/yard/parser/ruby/ruby_parser.rb

@@ -333,6 +333,7 @@ module YARD
         undef on_bodystmt
         undef on_top_const_ref
         undef on_const_path_ref
+        undef on_dyna_symbol
 
         def on_program(*args)
           args.first
@@ -410,6 +411,16 @@ module YARD
           visit_ns_token(:rbracket, tok, false)
         end
 
+        def on_dyna_symbol(sym)
+          rng = if sym.source_range.size == 0 # rubocop:disable Style/ZeroLengthPredicate
+                  (sym.source_range.begin - 3)...sym.source_range.end
+                else
+                  (sym.source_range.begin - 2)..(sym.source_range.end + 1)
+                end
+          AstNode.new(:dyna_symbol, [sym], :line => lineno..lineno,
+            :listline => lineno..lineno, :listchar => rng, :char => rng)
+        end
+
         def on_top_const_ref(*args)
           type = :top_const_ref
           node = AstNode.node_class_for(type).new(type, args)
@@ -481,7 +492,8 @@ module YARD
         end
 
         def on_string_content(*args)
-          AstNode.new(:string_content, args, :listline => lineno..lineno, :listchar => charno..charno)
+          chr_rng = args.empty? ? charno...charno : charno..charno
+          AstNode.new(:string_content, args, :listline => lineno..lineno, :listchar => chr_rng)
         end
 
         def on_rescue(exc, *args)
@@ -600,7 +612,7 @@ module YARD
 
         def insert_comments
           root.traverse do |node|
-            next if node.type == :comment || node.type == :list || node.parent.type != :list
+            next if %i{comment void_stmt list}.include?(node.type) || node.parent.type != :list
 
             # never attach comments to if/unless mod nodes
             if node.type == :if_mod || node.type == :unless_mod