yard 0.9.5 → 0.9.6

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Parser
     module Ruby
@@ -5,7 +6,7 @@ module YARD
         # Legacy Ruby parser
         # @since 0.5.6
         class RubyParser < Parser::Base
-          def initialize(source, filename)
+          def initialize(source, _filename)
             @source = source
           end
 
@@ -28,4 +29,4 @@ module YARD
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Parser::Ruby::Legacy
     class Statement
@@ -56,10 +57,10 @@ module YARD
         last_tk = nil
         tokens.reject do |tk|
           tk.is_a?(RubyToken::TkNL) ||
-          (last_tk.is_a?(RubyToken::TkSPACE) &&
-          last_tk.class == tk.class) && last_tk = tk
+            (last_tk.is_a?(RubyToken::TkSPACE) &&
+            last_tk.class == tk.class) && last_tk = tk
         end
       end
     end
   end
-end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Parser::Ruby::Legacy
     class StatementList < Array
@@ -16,10 +17,11 @@ module YARD
       def initialize(content)
         @shebang_line = nil
         @encoding_line = nil
+        @comments_last_line = nil
         if content.is_a? TokenList
           @tokens = content.dup
         elsif content.is_a? String
-          @tokens = TokenList.new(content.gsub("\r", ""))
+          @tokens = TokenList.new(content.delete("\r"))
         else
           raise ArgumentError, "Invalid content for StatementList: #{content.inspect}:#{content.class}"
         end
@@ -30,7 +32,11 @@ module YARD
       private
 
       def parse_statements
-        while stmt = next_statement do self << stmt end
+        loop do
+          stmt = next_statement
+          break if stmt.nil?
+          self << stmt
+        end
       end
 
       # Returns the next statement in the token stream
@@ -45,11 +51,18 @@ module YARD
         @current_block = nil
         @comments_line = nil
         @comments_hash_flag = nil
-        @statement, @block, @comments = TokenList.new, nil, nil
-        @last_tk, @last_ns_tk, @before_last_tk, @before_last_ns_tk = nil, nil, nil, nil
+        @statement = TokenList.new
+        @block = nil
+        @comments = nil
+        @last_tk = nil
+        @last_ns_tk = nil
+        @before_last_tk = nil
+        @before_last_ns_tk = nil
         @first_line = nil
 
-        while !@done && tk = @tokens.shift
+        until @done
+          tk = @tokens.shift
+          break if tk.nil?
           process_token(tk)
 
           @before_last_tk = @last_tk
@@ -77,8 +90,6 @@ module YARD
           @statement << TkCOMMENT.new(@comments_line, 0)
           @statement.first.set_text("# " + @comments.join("\n# "))
           Statement.new(@statement, nil, @comments)
-        else
-          nil
         end
       end
 
@@ -86,14 +97,14 @@ module YARD
         extra = []
         (@statement.size - 1).downto(0) do |index|
           token = @statement[index]
-          if TkStatementEnd === token
-            while [TkNL, TkSPACE, TkSEMICOLON].include?(@statement[index - 1].class)
-              extra.unshift(@statement.delete_at(index - 1))
-              index -= 1
-            end
-            @statement.insert(index + 1, *extra)
-            return
+          next unless TkStatementEnd === token
+
+          while [TkNL, TkSPACE, TkSEMICOLON].include?(@statement[index - 1].class)
+            extra.unshift(@statement.delete_at(index - 1))
+            index -= 1
           end
+          @statement.insert(index + 1, *extra)
+          break
         end
       end
 
@@ -108,7 +119,7 @@ module YARD
         @statement.each_with_index do |token, index|
           if TkBlockContents === token
             @statement[index, 1] = [token, *extra]
-            return
+            break
           end
         end
       end
@@ -214,7 +225,7 @@ module YARD
           end
         when Parser::SourceParser::ENCODING_LINE
           if (@last_ns_tk.class == TkCOMMENT && @last_ns_tk.text == @shebang_line) ||
-              !@last_ns_tk
+             !@last_ns_tk
             @encoding_line = tk.text
             return
           end
@@ -236,13 +247,13 @@ module YARD
         # Since, of course, the convention is to have "# text"
         # and not "#text", which I deem ugly (you heard it here first)
         @comments ||= []
-        if tk.text =~ /\A=begin/
+        if tk.text.start_with?('=begin')
           lines = tk.text.count("\n")
           @comments += tk.text.gsub(/\A=begin.*\r?\n|\r?\n=end.*\r?\n?\Z/, '').split(/\r?\n/)
           @comments_last_line = tk.line_no + lines
         else
           @comments << tk.text.gsub(/^(#+)\s{0,1}/, '')
-          @comments_hash_flag = $1 == '##' if @comments_hash_flag == nil
+          @comments_hash_flag = $1 == '##' if @comments_hash_flag.nil?
           @comments_last_line = tk.line_no
         end
         @comments.pop if @comments.size == 1 && @comments.first =~ /^\s*$/
@@ -256,17 +267,17 @@ module YARD
       # @param [RubyToken::Token] tk the token to process
       def process_simple_block_opener(tk)
         return unless [TkLBRACE, TkDO, TkBEGIN, TkELSE].include?(tk.class) &&
-          # Make sure hashes are parsed as hashes, not as blocks
-          (@last_ns_tk.nil? || @last_ns_tk.lex_state != EXPR_BEG)
+                      # Make sure hashes are parsed as hashes, not as blocks
+                      (@last_ns_tk.nil? || @last_ns_tk.lex_state != EXPR_BEG)
 
         @level += 1
         @state = :block
         @block_num += 1
-        unless @block
+        if @block.nil?
           @block = TokenList.new
           tokens = [tk, TkStatementEnd.new(tk.line_no, tk.char_no)]
           tokens = tokens.reverse if TkBEGIN === tk.class
-          @statement.push(*tokens)
+          @statement.concat(tokens)
         else
           @statement << tk
         end
@@ -297,36 +308,35 @@ module YARD
 
         return unless
           # We might be coming after a statement-ending token...
-          ((@last_tk && [TkSEMICOLON, TkNL, TkEND_OF_SCRIPT].include?(tk.class)) ||
-           # Or we might be at the beginning of an argument list
-           (@current_block == TkDEF && tk.class == TkRPAREN))
+          (@last_tk && [TkSEMICOLON, TkNL, TkEND_OF_SCRIPT].include?(tk.class)) ||
+          # Or we might be at the beginning of an argument list
+          (@current_block == TkDEF && tk.class == TkRPAREN)
 
         # Continue line ending on . or ::
         return if @last_tk && [EXPR_DOT].include?(@last_tk.lex_state)
 
         # Continue a possible existing new statement unless we just finished an expression...
         return unless (@last_tk && [EXPR_END, EXPR_ARG].include?(@last_tk.lex_state)) ||
-          # Or we've opened a block and are ready to move into the body
-          (@current_block && [TkNL, TkSEMICOLON].include?(tk.class) &&
-           # Handle the case where the block statement's expression is on the next line
-           #
-           # while
-           #     foo
-           # end
-           @last_ns_tk.class != @current_block &&
-           # And the case where part of the expression is on the next line
-           #
-           # while foo ||
-           #     bar
-           # end
-           @last_tk.lex_state != EXPR_BEG)
+                      # Or we've opened a block and are ready to move into the body
+                      (@current_block && [TkNL, TkSEMICOLON].include?(tk.class) &&
+                       # Handle the case where the block statement's expression is on the next line
+                       #
+                       # while
+                       #     foo
+                       # end
+                       @last_ns_tk.class != @current_block &&
+                       # And the case where part of the expression is on the next line
+                       #
+                       # while foo ||
+                       #     bar
+                       # end
+                       @last_tk.lex_state != EXPR_BEG)
 
         # Continue with the statement if we've hit a comma in a def
         return if @current_block == TkDEF && peek_no_space.class == TkCOMMA
 
-
         if [TkEND_OF_SCRIPT, TkNL, TkSEMICOLON].include?(tk.class) && @state == :block_statement &&
-            [TkRBRACE, TkEND].include?(@last_ns_tk.class) && @level == 0
+           [TkRBRACE, TkEND].include?(@last_ns_tk.class) && @level == 0
           @current_block = nil
         end
 
@@ -377,7 +387,7 @@ module YARD
       # @return [RubyToken::Token] the next non-space token
       def peek_no_space
         return @tokens.first unless @tokens.first.class == TkSPACE
-        return @tokens[1]
+        @tokens[1]
       end
     end
   end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module YARD
   module Parser::Ruby::Legacy
     class TokenList < Array
@@ -10,12 +11,7 @@ module YARD
       def to_s(full_statement = false, show_block = true)
         inject([]) do |acc, token|
           break acc if !full_statement && TkStatementEnd === token
-          if !show_block && TkBlockContents === token
-            acc << ""
-          else
-            acc << token.text
-          end
-          acc
+          acc << (!show_block && TkBlockContents === token ? "" : token.text)
         end.join
       end
 
@@ -36,7 +32,7 @@ module YARD
         end
         self
       end
-      alias_method :<<, :push
+      alias << push
 
       def squeeze(type = TkSPACE)
         last = nil
@@ -47,7 +43,9 @@ module YARD
 
       def parse_content(content)
         lex = RubyLex.new(content)
-        while tk = lex.token do
+        loop do
+          tk = lex.token
+          break if tk.nil?
           self << convert_token(lex, tk)
         end
       end
@@ -58,14 +56,19 @@ module YARD
           sym = TkLABEL.new(tk.line_no, tk.char_no, nil)
           sym.lex_state = lex.lex_state
           sym.set_text(tk.text + next_tk.text)
-        elsif TkSYMBEG === tk && next_tk = lex.token
-          sym = TkSYMBOL.new(tk.line_no, tk.char_no, nil)
-          sym.lex_state = lex.lex_state
-          sym.set_text(tk.text + next_tk.text)
+        elsif TkSYMBEG === tk
+          next_tk = lex.token
+          if next_tk
+            sym = TkSYMBOL.new(tk.line_no, tk.char_no, nil)
+            sym.lex_state = lex.lex_state
+            sym.set_text(tk.text + next_tk.text)
+          else
+            tk
+          end
         else
           tk
         end
       end
     end
   end
-end
+end

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

@@ -1,4 +1,5 @@
-begin require 'ripper'; rescue LoadError; end
+# frozen_string_literal: true
+begin require 'ripper'; rescue LoadError; nil end
 
 module YARD
   module Parser
@@ -48,6 +49,7 @@ module YARD
           @frozen_string_line = nil
           @file_encoding = nil
           @newline = true
+          @percent_ary = nil
         end
 
         def parse
@@ -67,9 +69,8 @@ module YARD
           return nil unless defined?(::Encoding)
           return @file_encoding if @file_encoding
           return Encoding.default_internal unless @encoding_line
-          if match = @encoding_line.match(SourceParser::ENCODING_LINE)
-            @file_encoding = match.captures.last
-          end
+          match = @encoding_line.match(SourceParser::ENCODING_LINE)
+          @file_encoding = match.captures.last if match
         end
 
         private
@@ -101,6 +102,9 @@ module YARD
           :next => "next",
           :paren => :lparen,
           :qwords_literal => :qwords_beg,
+          :words_literal => :words_beg,
+          :qsymbols_literal => :qsymbols_beg,
+          :symbols_literal => :symbols_beg,
           :redo => "redo",
           :regexp_literal => :regexp_beg,
           :rescue => "rescue",
@@ -131,7 +135,7 @@ module YARD
 
         MAPPINGS.each do |k, v|
           if Array === v
-            v.each {|_v| (REV_MAPPINGS[_v] ||= []) << k }
+            v.each {|vv| (REV_MAPPINGS[vv] ||= []) << k }
           else
             (REV_MAPPINGS[v] ||= []) << k
           end
@@ -140,7 +144,7 @@ module YARD
         PARSER_EVENT_TABLE.each do |event, arity|
           node_class = AstNode.node_class_for(event)
 
-          if /_new\z/ =~ event.to_s and arity == 0
+          if /_new\z/ =~ event.to_s && arity == 0
             module_eval(<<-eof, __FILE__, __LINE__ + 1)
               def on_#{event}(*args)
                 #{node_class}.new(:list, args, :listchar => charno...charno, :listline => lineno..lineno)
@@ -154,7 +158,7 @@ module YARD
                 list
               end
             eof
-          elsif MAPPINGS.has_key?(event)
+          elsif MAPPINGS.key?(event)
             module_eval(<<-eof, __FILE__, __LINE__ + 1)
               begin; undef on_#{event}; rescue NameError; end
               def on_#{event}(*args)
@@ -181,8 +185,8 @@ module YARD
           eof
         end
 
-        REV_MAPPINGS.select {|k,v| k.is_a?(Symbol) }.each do |pair|
-          event, value = *pair
+        REV_MAPPINGS.select {|k, _v| k.is_a?(Symbol) }.each do |pair|
+          event = pair.first
           ast_token = AST_TOKENS.include?(event)
           module_eval(<<-eof, __FILE__, __LINE__ + 1)
             begin; undef on_#{event}; rescue NameError; end
@@ -218,6 +222,8 @@ module YARD
           eof
         end
 
+        undef on_sp
+
         def on_sp(tok)
           add_token(:sp, tok)
           @charno += tok.length
@@ -229,8 +235,9 @@ module YARD
           node.source_range = Range.new(sstart, @ns_charno - 1)
           node.line_range = Range.new(lstart, lineno)
           if node.respond_to?(:block)
-            sr, lr = node.block.source_range, node.block.line_range
-            node.block.source_range = Range.new(sr.first, @tokens.last[2][1]-1)
+            sr = node.block.source_range
+            lr = node.block.line_range
+            node.block.source_range = Range.new(sr.first, @tokens.last[2][1] - 1)
             node.block.line_range = Range.new(lr.first, @tokens.last[2][0])
           end
           node
@@ -252,12 +259,26 @@ module YARD
           @ns_charno = charno
           @newline = [:semicolon, :comment, :kw, :op, :lparen, :lbrace].include?(token)
           if ast_token
-            AstNode.new(token, [data], :line => lineno..lineno, :char => ch..charno-1, :token => true)
+            AstNode.new(token, [data], :line => lineno..lineno, :char => ch..charno - 1, :token => true)
           end
         end
 
         def add_token(token, data)
-          if @tokens.last && @tokens.last[0] == :symbeg
+          if @percent_ary
+            if token == :words_sep && data !~ /\s\z/
+              rng = @percent_ary.source_range
+              rng = Range.new(rng.first, rng.last + data.length)
+              @percent_ary.source_range = rng
+              @tokens << [token, data, [lineno, charno]]
+              @percent_ary = nil
+            elsif token == :tstring_end && data =~ /\A\s/
+              rng = @percent_ary.source_range
+              rng = Range.new(rng.first, rng.last + data.length)
+              @percent_ary.source_range = rng
+              @tokens << [token, data, [lineno, charno]]
+              @percent_ary = nil
+            end
+          elsif @tokens.last && @tokens.last[0] == :symbeg
             @tokens[-1] = [:symbol, ":" + data, @tokens.last[2]]
           elsif @heredoc_state == :started
             @heredoc_tokens << [token, data, [lineno, charno]]
@@ -291,8 +312,6 @@ module YARD
         undef on_aref_field
         undef on_lbracket
         undef on_rbracket
-        undef on_qwords_new
-        undef on_qwords_add
         undef on_string_literal
         undef on_lambda
         undef on_unary
@@ -336,7 +355,7 @@ module YARD
         end
 
         def on_unary(op, val)
-          map = @map[op.to_s[0,1]]
+          map = @map[op.to_s[0, 1]]
           lstart, sstart = *(map ? map.pop : [lineno, @ns_charno - 1])
           node = AstNode.node_class_for(:unary).new(:unary, [op, val])
           node.source_range = Range.new(sstart, @ns_charno - 1)
@@ -414,22 +433,29 @@ module YARD
           eof
         end
 
-        def on_qwords_new(*args)
-          node = LiteralNode.new(:qwords_literal, args)
-          if @map[:qwords_beg]
-            lstart, sstart = *@map[:qwords_beg].pop
-            node.source_range = Range.new(sstart, @ns_charno-1)
-            node.line_range = Range.new(lstart, lineno)
-          end
-          node
-        end
+        %w(symbols qsymbols words qwords).each do |kw|
+          module_eval(<<-eof, __FILE__, __LINE__ + 1)
+            begin; undef on_#{kw}_new; rescue NameError; end
+            def on_#{kw}_new(*args)
+              node = LiteralNode.new(:#{kw}_literal, args)
+              @percent_ary = node
+              if @map[:#{kw}_beg]
+                lstart, sstart = *@map[:#{kw}_beg].pop
+                node.source_range = Range.new(sstart, @ns_charno-1)
+                node.line_range = Range.new(lstart, lineno)
+              end
+              node
+            end
 
-        def on_qwords_add(list, item)
-          last = @source[@ns_charno,1] == "\n" ? @ns_charno - 1 : @ns_charno
-          list.source_range = (list.source_range.first..last)
-          list.line_range = (list.line_range.first..lineno)
-          list.push(item)
-          list
+            begin; undef on_#{kw}_add; rescue NameError; end
+            def on_#{kw}_add(list, item)
+              last = @source[@ns_charno,1] == "\n" ? @ns_charno - 1 : @ns_charno
+              list.source_range = (list.source_range.first..last)
+              list.line_range = (list.line_range.first..lineno)
+              list.push(item)
+              list
+            end
+          eof
         end
 
         def on_string_literal(*args)
@@ -469,11 +495,8 @@ module YARD
             if arg.first.class == Array
               arg.map! do |sub_arg|
                 next sub_arg unless sub_arg.class == Array
-                if sub_arg[0].type == :label
-                  type = :named_arg
-                else
-                  type = :unnamed_optional_arg
-                end
+                type = sub_arg[0].type == :label ?
+                  :named_arg : :unnamed_optional_arg
                 AstNode.new(type, sub_arg, :listline => lineno..lineno, :listchar => charno..charno)
               end
             end
@@ -489,12 +512,12 @@ module YARD
           ch = charno
           @charno += data.length
           @ns_charno = charno
-          AstNode.new(:label, [data[0...-1]], :line => lineno..lineno, :char => ch..charno-1, :token => true)
+          AstNode.new(:label, [data[0...-1]], :line => lineno..lineno, :char => ch..charno - 1, :token => true)
         end
 
         def on_comment(comment)
           not_comment = false
-          if @last_ns_token.nil? || @last_ns_token.size == 0
+          if @last_ns_token.nil? || @last_ns_token.empty?
             if comment =~ SourceParser::SHEBANG_LINE && !@encoding_line
               @shebang_line = comment
               not_comment = true
@@ -514,14 +537,14 @@ module YARD
             return
           end
 
-          source_range = ch..(charno-1)
+          source_range = ch..(charno - 1)
           comment = comment.gsub(/^(\#+)\s{0,1}/, '').chomp
           append_comment = @comments[lineno - 1]
 
           hash_flag = $1 == '##' ? true : false
 
           if append_comment && @comments_last_column &&
-              @comments_last_column == column && comment_starts_line?(ch)
+             @comments_last_column == column && comment_starts_line?(ch)
             @comments.delete(lineno - 1)
             @comments_flags[lineno] = @comments_flags[lineno - 1]
             @comments_flags.delete(lineno - 1)
@@ -532,14 +555,14 @@ module YARD
 
           @comments[lineno] = comment
           @comments_range[lineno] = source_range
-          @comments_flags[lineno] = hash_flag if !append_comment
+          @comments_flags[lineno] = hash_flag unless append_comment
           @comments_last_column = column
         end
 
         def on_embdoc_beg(text)
           visit_ns_token(:embdoc_beg, text)
-          @embdoc_start = charno-text.length
-          @embdoc = ""
+          @embdoc_start = charno - text.length
+          @embdoc = String.new("")
         end
 
         def on_embdoc(text)
@@ -559,9 +582,10 @@ module YARD
         def on_parse_error(msg)
           raise ParserSyntaxError, "syntax error in `#{file}`:(#{lineno},#{column}): #{msg}"
         end
+        alias compile_error on_parse_error
 
         def comment_starts_line?(charno)
-          (charno-1).downto(0) do |i|
+          (charno - 1).downto(0) do |i|
             ch = @source[i]
             break if ch == "\n"
             return false if ch != " " && ch != "\t"
@@ -579,7 +603,7 @@ module YARD
             end
 
             # check upwards from line before node; check node's line at the end
-            ((node.line-1).downto(node.line-2).to_a + [node.line]).each  do |line|
+            ((node.line - 1).downto(node.line - 2).to_a + [node.line]).each do |line|
               comment = @comments[line]
               if comment && !comment.empty?
                 add_comment(line, node)
@@ -588,9 +612,7 @@ module YARD
             end
 
             @comments.keys.each do |line|
-              if node.line > line
-                add_comment(line, nil, node)
-              end
+              add_comment(line, nil, node) if node.line > line
             end
           end
 
@@ -598,21 +620,20 @@ module YARD
           root.traverse do |node|
             next if node.type == :list || node.parent.type != :list
             @comments.keys.each do |line|
-              if node.line_range.include?(line)
-                pick = nil
-                node.traverse do |subnode|
-                  next unless subnode.type == :list
-                  pick ||= subnode
-                  next unless subnode.line_range.include?(line)
-                  pick = subnode
-                end
-                add_comment(line, nil, pick, true) if pick
+              next unless node.line_range.include?(line)
+              pick = nil
+              node.traverse do |subnode|
+                next unless subnode.type == :list
+                pick ||= subnode
+                next unless subnode.line_range.include?(line)
+                pick = subnode
               end
+              add_comment(line, nil, pick, true) if pick
             end
-          end if @comments.size > 0
+          end unless @comments.empty?
 
           # insert all remaining comments
-          @comments.each do |line, comment|
+          @comments.each do |line, _comment|
             add_comment(line, nil, root, true)
           end
 
@@ -646,10 +667,13 @@ module YARD
         end
 
         def freeze_tree(node = nil)
-          node ||= root
-          node.children.each do |child|
-            child.parent = node
-            freeze_tree(child)
+          nodes = [node || root]
+          until nodes.empty?
+            p_node = nodes.shift
+            p_node.children.each do |child|
+              child.parent = p_node
+              nodes << child
+            end
           end
         end
       end if defined?(::Ripper)