rdoc 6.7.0 → 6.8.1

data/lib/rdoc/parser/ripper_state_lex.rb

@@ -7,307 +7,12 @@ require 'ripper'
 class RDoc::Parser::RipperStateLex
   # :stopdoc:
 
-  # TODO: Remove this constants after Ruby 2.4 EOL
-  RIPPER_HAS_LEX_STATE = Ripper::Filter.method_defined?(:state)
-
   Token = Struct.new(:line_no, :char_no, :kind, :text, :state)
 
-  EXPR_NONE = 0
-  EXPR_BEG = 1
-  EXPR_END = 2
-  EXPR_ENDARG = 4
-  EXPR_ENDFN = 8
-  EXPR_ARG = 16
-  EXPR_CMDARG = 32
-  EXPR_MID = 64
-  EXPR_FNAME = 128
-  EXPR_DOT = 256
-  EXPR_CLASS = 512
-  EXPR_LABEL = 1024
-  EXPR_LABELED = 2048
-  EXPR_FITEM = 4096
-  EXPR_VALUE = EXPR_BEG
-  EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_MID | EXPR_CLASS)
-  EXPR_ARG_ANY  =  (EXPR_ARG | EXPR_CMDARG)
-  EXPR_END_ANY  =  (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
-
-  class InnerStateLex < Ripper::Filter
-    attr_accessor :lex_state
-
-    def initialize(code)
-      @lex_state = EXPR_BEG
-      @in_fname = false
-      @continue = false
-      reset
-      super(code)
-    end
-
-    def reset
-      @command_start = false
-      @cmd_state = @command_start
-    end
-
-    def on_nl(tok, data)
-      case @lex_state
-      when EXPR_FNAME, EXPR_DOT
-        @continue = true
-      else
-        @continue = false
-        @lex_state = EXPR_BEG unless (EXPR_LABEL & @lex_state) != 0
-      end
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_ignored_nl(tok, data)
-      case @lex_state
-      when EXPR_FNAME, EXPR_DOT
-        @continue = true
-      else
-        @continue = false
-        @lex_state = EXPR_BEG unless (EXPR_LABEL & @lex_state) != 0
-      end
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_op(tok, data)
-      case tok
-      when '&', '|', '!', '!=', '!~'
-        case @lex_state
-        when EXPR_FNAME, EXPR_DOT
-          @lex_state = EXPR_ARG
-        else
-          @lex_state = EXPR_BEG
-        end
-      when '<<'
-        # TODO next token?
-        case @lex_state
-        when EXPR_FNAME, EXPR_DOT
-          @lex_state = EXPR_ARG
-        else
-          @lex_state = EXPR_BEG
-        end
-      when '?'
-        @lex_state = EXPR_BEG
-      when '&&', '||', '+=', '-=', '*=', '**=',
-           '&=', '|=', '^=', '<<=', '>>=', '||=', '&&='
-        @lex_state = EXPR_BEG
-      when '::'
-        case @lex_state
-        when EXPR_ARG, EXPR_CMDARG
-          @lex_state = EXPR_DOT
-        when EXPR_FNAME, EXPR_DOT
-          @lex_state = EXPR_ARG
-        else
-          @lex_state = EXPR_BEG
-        end
-      else
-        case @lex_state
-        when EXPR_FNAME, EXPR_DOT
-          @lex_state = EXPR_ARG
-        else
-          @lex_state = EXPR_BEG
-        end
-      end
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_kw(tok, data)
-      case tok
-      when 'class'
-        @lex_state = EXPR_CLASS
-        @in_fname = true
-      when 'def'
-        @lex_state = EXPR_FNAME
-        @continue = true
-        @in_fname = true
-      when 'if', 'unless', 'while', 'until'
-        if ((EXPR_MID | EXPR_END | EXPR_ENDARG | EXPR_ENDFN | EXPR_ARG | EXPR_CMDARG) & @lex_state) != 0 # postfix if
-          @lex_state = EXPR_BEG | EXPR_LABEL
-        else
-          @lex_state = EXPR_BEG
-        end
-      when 'begin', 'case', 'when'
-        @lex_state = EXPR_BEG
-      when 'return', 'break'
-        @lex_state = EXPR_MID
-      else
-        if @lex_state == EXPR_FNAME
-          @lex_state = EXPR_END
-        else
-          @lex_state = EXPR_END
-        end
-      end
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_tstring_beg(tok, data)
-      @lex_state = EXPR_BEG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_tstring_end(tok, data)
-      @lex_state = EXPR_END | EXPR_ENDARG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_CHAR(tok, data)
-      @lex_state = EXPR_END
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_period(tok, data)
-      @lex_state = EXPR_DOT
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_int(tok, data)
-      @lex_state = EXPR_END | EXPR_ENDARG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_float(tok, data)
-      @lex_state = EXPR_END | EXPR_ENDARG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_rational(tok, data)
-      @lex_state = EXPR_END | EXPR_ENDARG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_imaginary(tok, data)
-      @lex_state = EXPR_END | EXPR_ENDARG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_symbeg(tok, data)
-      @lex_state = EXPR_FNAME
-      @continue = true
-      @in_fname = true
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    private def on_variables(event, tok, data)
-      if @in_fname
-        @lex_state = EXPR_ENDFN
-        @in_fname = false
-        @continue = false
-      elsif @continue
-        case @lex_state
-        when EXPR_DOT
-          @lex_state = EXPR_ARG
-        else
-          @lex_state = EXPR_ENDFN
-          @continue = false
-        end
-      else
-        @lex_state = EXPR_CMDARG
-      end
-      data << Token.new(lineno, column, event, tok, @lex_state)
-    end
-
-    def on_ident(tok, data)
-      on_variables(__method__, tok, data)
-    end
-
-    def on_ivar(tok, data)
-      @lex_state = EXPR_END
-      on_variables(__method__, tok, data)
-    end
-
-    def on_cvar(tok, data)
-      @lex_state = EXPR_END
-      on_variables(__method__, tok, data)
-    end
-
-    def on_gvar(tok, data)
-      @lex_state = EXPR_END
-      on_variables(__method__, tok, data)
-    end
-
-    def on_backref(tok, data)
-      @lex_state = EXPR_END
-      on_variables(__method__, tok, data)
-    end
-
-    def on_lparen(tok, data)
-      @lex_state = EXPR_LABEL | EXPR_BEG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_rparen(tok, data)
-      @lex_state = EXPR_ENDFN
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_lbrace(tok, data)
-      @lex_state = EXPR_LABEL | EXPR_BEG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_rbrace(tok, data)
-      @lex_state = EXPR_ENDARG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_lbracket(tok, data)
-      @lex_state = EXPR_LABEL | EXPR_BEG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_rbracket(tok, data)
-      @lex_state = EXPR_ENDARG
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_const(tok, data)
-      case @lex_state
-      when EXPR_FNAME
-        @lex_state = EXPR_ENDFN
-      when EXPR_CLASS, EXPR_CMDARG, EXPR_MID
-        @lex_state = EXPR_ARG
-      else
-        @lex_state = EXPR_CMDARG
-      end
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_sp(tok, data)
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_comma(tok, data)
-      @lex_state = EXPR_BEG | EXPR_LABEL if (EXPR_ARG_ANY & @lex_state) != 0
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_comment(tok, data)
-      @lex_state = EXPR_BEG unless (EXPR_LABEL & @lex_state) != 0
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_ignored_sp(tok, data)
-      @lex_state = EXPR_BEG unless (EXPR_LABEL & @lex_state) != 0
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-    end
-
-    def on_heredoc_beg(tok, data)
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-      @lex_state = EXPR_END
-      data
-    end
-
-    def on_heredoc_end(tok, data)
-      data << Token.new(lineno, column, __method__, tok, @lex_state)
-      @lex_state = EXPR_BEG
-      data
-    end
-
-    def on_default(event, tok, data)
-      reset
-      data << Token.new(lineno, column, event, tok, @lex_state)
-    end
-  end unless RIPPER_HAS_LEX_STATE
+  EXPR_END   = Ripper::EXPR_END
+  EXPR_ENDFN = Ripper::EXPR_ENDFN
+  EXPR_ARG   = Ripper::EXPR_ARG
+  EXPR_FNAME = Ripper::EXPR_FNAME
 
   class InnerStateLex < Ripper::Filter
     def initialize(code)
@@ -317,7 +22,7 @@ class RDoc::Parser::RipperStateLex
     def on_default(event, tok, data)
       data << Token.new(lineno, column, event, tok, state)
     end
-  end if RIPPER_HAS_LEX_STATE
+  end
 
   def get_squashed_tk
     if @buf.empty?
@@ -333,9 +38,8 @@ class RDoc::Parser::RipperStateLex
       tk = get_string_tk(tk)
     when :on_backtick then
       if (tk[:state] & (EXPR_FNAME | EXPR_ENDFN)) != 0
-        @inner_lex.lex_state = EXPR_ARG unless RIPPER_HAS_LEX_STATE
         tk[:kind] = :on_ident
-        tk[:state] = Ripper::Lexer.const_defined?(:State) ? Ripper::Lexer::State.new(EXPR_ARG) : EXPR_ARG
+        tk[:state] = Ripper::Lexer::State.new(EXPR_ARG)
       else
         tk = get_string_tk(tk)
       end
@@ -345,7 +49,6 @@ class RDoc::Parser::RipperStateLex
       tk = get_embdoc_tk(tk)
     when :on_heredoc_beg then
       @heredoc_queue << retrieve_heredoc_info(tk)
-      @inner_lex.lex_state = EXPR_END unless RIPPER_HAS_LEX_STATE
     when :on_nl, :on_ignored_nl, :on_comment, :on_heredoc_end then
       if !@heredoc_queue.empty?
         get_heredoc_tk(*@heredoc_queue.shift)
@@ -549,8 +252,7 @@ class RDoc::Parser::RipperStateLex
   private def get_op_tk(tk)
     redefinable_operators = %w[! != !~ % & * ** + +@ - -@ / < << <= <=> == === =~ > >= >> [] []= ^ ` | ~]
     if redefinable_operators.include?(tk[:text]) and tk[:state] == EXPR_ARG then
-      @inner_lex.lex_state = EXPR_ARG unless RIPPER_HAS_LEX_STATE
-      tk[:state] = Ripper::Lexer.const_defined?(:State) ? Ripper::Lexer::State.new(EXPR_ARG) : EXPR_ARG
+      tk[:state] = Ripper::Lexer::State.new(EXPR_ARG)
       tk[:kind] = :on_ident
     elsif tk[:text] =~ /^[-+]$/ then
       tk_ahead = get_squashed_tk

data/lib/rdoc/parser/ruby.rb

@@ -8,6 +8,15 @@
 #       by Keiju ISHITSUKA (Nippon Rational Inc.)
 #
 
+if ENV['RDOC_USE_PRISM_PARSER']
+  require 'rdoc/parser/prism_ruby'
+  RDoc::Parser.const_set(:Ruby, RDoc::Parser::PrismRuby)
+  puts "========================================================================="
+  puts "RDoc is using the experimental Prism parser to generate the documentation"
+  puts "========================================================================="
+  return
+end
+
 require 'ripper'
 require_relative 'ripper_state_lex'
 
@@ -513,7 +522,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
       when :on_comment, :on_embdoc then
         @read.pop
         if :on_nl == end_token[:kind] and "\n" == tk[:text][-1] and
-          (!continue or (tk[:state] & RDoc::Parser::RipperStateLex::EXPR_LABEL) != 0) then
+          (!continue or (tk[:state] & Ripper::EXPR_LABEL) != 0) then
           break if !continue and nest <= 0
         end
       when :on_comma then
@@ -526,7 +535,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
           nest += 1
         when 'if', 'unless', 'while', 'until', 'rescue'
           # postfix if/unless/while/until/rescue must be EXPR_LABEL
-          nest += 1 unless (tk[:state] & RDoc::Parser::RipperStateLex::EXPR_LABEL) != 0
+          nest += 1 unless (tk[:state] & Ripper::EXPR_LABEL) != 0
         when 'end'
           nest -= 1
           break if nest == 0
@@ -1041,7 +1050,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
       elsif (:on_kw == tk[:kind] && 'def' == tk[:text]) then
         nest += 1
       elsif (:on_kw == tk[:kind] && %w{do if unless case begin}.include?(tk[:text])) then
-        if (tk[:state] & RDoc::Parser::RipperStateLex::EXPR_LABEL) == 0
+        if (tk[:state] & Ripper::EXPR_LABEL) == 0
           nest += 1
         end
       elsif [:on_rparen, :on_rbrace, :on_rbracket].include?(tk[:kind]) ||
@@ -1662,7 +1671,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
       when :on_comment, :on_embdoc then
         @read.pop
         if :on_nl == end_token[:kind] and "\n" == tk[:text][-1] and
-          (!continue or (tk[:state] & RDoc::Parser::RipperStateLex::EXPR_LABEL) != 0) then
+          (!continue or (tk[:state] & Ripper::EXPR_LABEL) != 0) then
           if method && method.block_params.nil? then
             unget_tk tk
             read_documentation_modifiers method, modifiers
@@ -1882,7 +1891,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
           end
 
         when 'until', 'while' then
-          if (tk[:state] & RDoc::Parser::RipperStateLex::EXPR_LABEL) == 0
+          if (tk[:state] & Ripper::EXPR_LABEL) == 0
             nest += 1
             skip_optional_do_after_expression
           end
@@ -1898,7 +1907,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
           skip_optional_do_after_expression
 
         when 'case', 'do', 'if', 'unless', 'begin' then
-          if (tk[:state] & RDoc::Parser::RipperStateLex::EXPR_LABEL) == 0
+          if (tk[:state] & Ripper::EXPR_LABEL) == 0
             nest += 1
           end
 

data/lib/rdoc/parser.rb

@@ -166,7 +166,8 @@ class RDoc::Parser
   # Finds and instantiates the correct parser for the given +file_name+ and
   # +content+.
 
-  def self.for top_level, file_name, content, options, stats
+  def self.for top_level, content, options, stats
+    file_name = top_level.absolute_name
     return if binary? file_name
 
     parser = use_markup content

data/lib/rdoc/rdoc.rb

@@ -356,7 +356,7 @@ option)
 
     top_level = @store.add_file filename, relative_name: relative_path.to_s
 
-    parser = RDoc::Parser.for top_level, filename, content, @options, @stats
+    parser = RDoc::Parser.for top_level, content, @options, @stats
 
     return unless parser
 
@@ -520,6 +520,7 @@ The internal error was:
       Dir.chdir @options.op_dir do
         unless @options.quiet then
           $stderr.puts "\nGenerating #{@generator.class.name.sub(/^.*::/, '')} format into #{Dir.pwd}..."
+          $stderr.puts "\nYou can visit the home page at: \e]8;;file://#{Dir.pwd}/index.html\e\\file://#{Dir.pwd}/index.html\e]8;;\e\\"
         end
 
         @generator.generate
@@ -544,7 +545,7 @@ end
 begin
   require 'rubygems'
 
-  rdoc_extensions = Gem.find_files 'rdoc/discover'
+  rdoc_extensions = Gem.find_latest_files 'rdoc/discover'
 
   rdoc_extensions.each do |extension|
     begin

data/lib/rdoc/ri/driver.rb

@@ -110,10 +110,6 @@ class RDoc::RI::Driver
     options = default_options
 
     opts = OptionParser.new do |opt|
-      opt.accept File do |file,|
-        File.readable?(file) and not File.directory?(file) and file
-      end
-
       opt.program_name = File.basename $0
       opt.version = RDoc::VERSION
       opt.release = nil
@@ -345,9 +341,17 @@ or the PAGER environment variable.
 
       opt.separator nil
 
-      opt.on("--dump=CACHE", File,
+      opt.on("--dump=CACHE",
              "Dump data from an ri cache or data file.") do |value|
-        options[:dump_path] = value
+        unless File.readable?(value)
+          abort "#{value.inspect} is not readable"
+        end
+
+        if File.directory?(value)
+          abort "#{value.inspect} is a directory"
+        end
+
+        options[:dump_path] = File.new(value)
       end
     end
 

data/lib/rdoc/task.rb

@@ -104,9 +104,8 @@ class RDoc::Task < Rake::TaskLib
   attr_accessor :name
 
   ##
-  # Comment markup format.  rdoc, rd and tomdoc are supported.  (default is
-  # 'rdoc')
-
+  # The markup format; one of: +rdoc+ (the default), +markdown+, +rd+, +tomdoc+.
+  # See {Markup Formats}[rdoc-ref:RDoc::Markup@Markup+Formats].
   attr_accessor :markup
 
   ##

data/lib/rdoc/tom_doc.rb

@@ -3,13 +3,7 @@
 
 # A parser for TomDoc based on TomDoc 1.0.0-rc1 (02adef9b5a)
 #
-# The TomDoc specification can be found at:
-#
-# http://tomdoc.org
-#
-# The latest version of the TomDoc specification can be found at:
-#
-# https://github.com/mojombo/tomdoc/blob/master/tomdoc.md
+# The TomDoc specification can be found at http://tomdoc.org.
 #
 # To choose TomDoc as your only default format see RDoc::Options@Saved+Options
 # for instructions on setting up a <code>.rdoc_options</code> file to store

data/lib/rdoc/version.rb

@@ -5,6 +5,6 @@ module RDoc
   ##
   # RDoc version you are using
 
-  VERSION = '6.7.0'
+  VERSION = '6.8.1'
 
 end

data/lib/rdoc.rb

@@ -21,7 +21,7 @@ $DEBUG_RDOC = nil
 # see RDoc::Markup and refer to <tt>rdoc --help</tt> for command line usage.
 #
 # If you want to set the default markup format see
-# RDoc::Markup@Supported+Formats
+# RDoc::Markup@Markup+Formats
 #
 # If you want to store rdoc configuration in your gem (such as the default
 # markup format) see RDoc::Options@Saved+Options
@@ -188,26 +188,26 @@ module RDoc
   # programs: classes, modules, methods, and so on.
   autoload :CodeObject,     "#{__dir__}/rdoc/code_object"
 
-  autoload :Context,        "#{__dir__}/rdoc/context"
-  autoload :TopLevel,       "#{__dir__}/rdoc/top_level"
-
-  autoload :AnonClass,      "#{__dir__}/rdoc/anon_class"
-  autoload :ClassModule,    "#{__dir__}/rdoc/class_module"
-  autoload :NormalClass,    "#{__dir__}/rdoc/normal_class"
-  autoload :NormalModule,   "#{__dir__}/rdoc/normal_module"
-  autoload :SingleClass,    "#{__dir__}/rdoc/single_class"
-
-  autoload :Alias,          "#{__dir__}/rdoc/alias"
-  autoload :AnyMethod,      "#{__dir__}/rdoc/any_method"
-  autoload :MethodAttr,     "#{__dir__}/rdoc/method_attr"
-  autoload :GhostMethod,    "#{__dir__}/rdoc/ghost_method"
-  autoload :MetaMethod,     "#{__dir__}/rdoc/meta_method"
-  autoload :Attr,           "#{__dir__}/rdoc/attr"
-
-  autoload :Constant,       "#{__dir__}/rdoc/constant"
-  autoload :Mixin,          "#{__dir__}/rdoc/mixin"
-  autoload :Include,        "#{__dir__}/rdoc/include"
-  autoload :Extend,         "#{__dir__}/rdoc/extend"
-  autoload :Require,        "#{__dir__}/rdoc/require"
+  autoload :Context,        "#{__dir__}/rdoc/code_object/context"
+  autoload :TopLevel,       "#{__dir__}/rdoc/code_object/top_level"
+
+  autoload :AnonClass,      "#{__dir__}/rdoc/code_object/anon_class"
+  autoload :ClassModule,    "#{__dir__}/rdoc/code_object/class_module"
+  autoload :NormalClass,    "#{__dir__}/rdoc/code_object/normal_class"
+  autoload :NormalModule,   "#{__dir__}/rdoc/code_object/normal_module"
+  autoload :SingleClass,    "#{__dir__}/rdoc/code_object/single_class"
+
+  autoload :Alias,          "#{__dir__}/rdoc/code_object/alias"
+  autoload :AnyMethod,      "#{__dir__}/rdoc/code_object/any_method"
+  autoload :MethodAttr,     "#{__dir__}/rdoc/code_object/method_attr"
+  autoload :GhostMethod,    "#{__dir__}/rdoc/code_object/ghost_method"
+  autoload :MetaMethod,     "#{__dir__}/rdoc/code_object/meta_method"
+  autoload :Attr,           "#{__dir__}/rdoc/code_object/attr"
+
+  autoload :Constant,       "#{__dir__}/rdoc/code_object/constant"
+  autoload :Mixin,          "#{__dir__}/rdoc/code_object/mixin"
+  autoload :Include,        "#{__dir__}/rdoc/code_object/include"
+  autoload :Extend,         "#{__dir__}/rdoc/code_object/extend"
+  autoload :Require,        "#{__dir__}/rdoc/code_object/require"
 
 end