rdoc 6.6.3.1 → 6.8.0

data/lib/rdoc/options.rb

@@ -105,6 +105,7 @@ class RDoc::Options
     generator_name
     generator_options
     generators
+    locale
     op_dir
     page_dir
     option_parser
@@ -232,9 +233,9 @@ class RDoc::Options
   attr_accessor :main_page
 
   ##
-  # The default markup format.  The default is 'rdoc'.  'markdown', 'tomdoc'
-  # and 'rd' are also built-in.
-
+  # The markup format.
+  # One of: +rdoc+ (the default), +markdown+, +rd+, +tomdoc+.
+  # See {Markup Formats}[rdoc-ref:RDoc::Markup@Markup+Formats].
   attr_accessor :markup
 
   ##
@@ -343,6 +344,11 @@ class RDoc::Options
   # Indicates if files of test suites should be skipped
   attr_accessor :skip_tests
 
+  ##
+  # Embed mixin methods, attributes, and constants into class documentation. Set via
+  # +--[no-]embed-mixins+ (Default is +false+.)
+  attr_accessor :embed_mixins
+
   def initialize loaded_options = nil # :nodoc:
     init_ivars
     override loaded_options if loaded_options
@@ -350,6 +356,7 @@ class RDoc::Options
 
   def init_ivars # :nodoc:
     @dry_run = false
+    @embed_mixins = false
     @exclude = %w[
       ~\z \.orig\z \.rej\z \.bak\z
       \.gemspec\z
@@ -400,6 +407,7 @@ class RDoc::Options
     @encoding = encoding ? Encoding.find(encoding) : encoding
 
     @charset        = map['charset']
+    @embed_mixins   = map['embed_mixins']
     @exclude        = map['exclude']
     @generator_name = map['generator_name']
     @hyperlink_all  = map['hyperlink_all']
@@ -431,6 +439,7 @@ class RDoc::Options
     end
 
     @charset        = map['charset']        if map.has_key?('charset')
+    @embed_mixins   = map['embed_mixins']   if map.has_key?('embed_mixins')
     @exclude        = map['exclude']        if map.has_key?('exclude')
     @generator_name = map['generator_name'] if map.has_key?('generator_name')
     @hyperlink_all  = map['hyperlink_all']  if map.has_key?('hyperlink_all')
@@ -459,11 +468,12 @@ class RDoc::Options
   def == other # :nodoc:
     self.class === other and
       @encoding       == other.encoding       and
+      @embed_mixins   == other.embed_mixins   and
       @generator_name == other.generator_name and
       @hyperlink_all  == other.hyperlink_all  and
       @line_numbers   == other.line_numbers   and
       @locale         == other.locale         and
-      @locale_dir     == other.locale_dir and
+      @locale_dir     == other.locale_dir     and
       @main_page      == other.main_page      and
       @markup         == other.markup         and
       @op_dir         == other.op_dir         and
@@ -682,7 +692,7 @@ Usage: #{opt.program_name} [options] [names...]
 
       EOF
 
-      parsers = Hash.new { |h,parser| h[parser] = [] }
+      parsers = Hash.new { |h, parser| h[parser] = [] }
 
       RDoc::Parser.parsers.each do |regexp, parser|
         parsers[parser.name.sub('RDoc::Parser::', '')] << regexp.source
@@ -841,6 +851,14 @@ Usage: #{opt.program_name} [options] [names...]
 
       opt.separator nil
 
+      opt.on("--[no-]embed-mixins",
+             "Embed mixin methods, attributes, and constants",
+             "into class documentation. (default false)") do |value|
+        @embed_mixins = value
+      end
+
+      opt.separator nil
+
       markup_formats = RDoc::Text::MARKUP_FORMAT.keys.sort
 
       opt.on("--markup=MARKUP", markup_formats,

data/lib/rdoc/parser/c.rb

@@ -440,7 +440,7 @@ class RDoc::Parser::C < RDoc::Parser
   # Scans #content for rb_include_module
 
   def do_includes
-    @content.scan(/rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/) do |c,m|
+    @content.scan(/rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/) do |c, m|
       next unless cls = @classes[c]
       m = @known_classes[m] || m
 
@@ -756,17 +756,27 @@ class RDoc::Parser::C < RDoc::Parser
   def gen_const_table file_content
     table = {}
     @content.scan(%r{
-      ((?>^\s*/\*.*?\*/\s+))
-        rb_define_(\w+)\((?:\s*(?:\w+),)?\s*
-                           "(\w+)"\s*,
+      (?<doc>(?>^\s*/\*.*?\*/\s+))
+        rb_define_(?<type>\w+)\(\s*(?:\w+),\s*
+                           "(?<name>\w+)"\s*,
                            .*?\)\s*;
+    |  (?<doc>(?>^\s*/\*.*?\*/\s+))
+        rb_file_(?<type>const)\(\s*
+                           "(?<name>\w+)"\s*,
+                           .*?\)\s*;
+    |  (?<doc>(?>^\s*/\*.*?\*/\s+))
+        rb_curses_define_(?<type>const)\(\s*
+                           (?<name>\w+)
+                           \s*\)\s*;
     | Document-(?:const|global|variable):\s
-        ((?:\w+::)*\w+)
-        \s*?\n((?>.*?\*/))
+        (?<name>(?:\w+::)*\w+)
+        \s*?\n(?<doc>(?>.*?\*/))
     }mxi) do
-      case
-      when $1 then table[[$2, $3]] = $1
-      when $4 then table[$4] = "/*\n" + $5
+      name, doc, type = $~.values_at(:name, :doc, :type)
+      if type
+        table[[type, name]] = doc
+      else
+        table[name] = "/*\n" + doc
       end
     end
     table

data/lib/rdoc/parser/changelog.rb

@@ -193,7 +193,7 @@ class RDoc::Parser::ChangeLog < RDoc::Parser
 
     entries << [entry_name, entry_body] if entry_name
 
-    entries.reject! do |(entry,_)|
+    entries.reject! do |(entry, _)|
       entry == nil
     end
 
@@ -221,7 +221,7 @@ class RDoc::Parser::ChangeLog < RDoc::Parser
 
   module Git
     ##
-    # Parses auxiliary info.  Currentry `base-url` to expand
+    # Parses auxiliary info.  Currently `base-url` to expand
     # references is effective.
 
     def parse_info(info)

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
@@ -789,8 +798,10 @@ class RDoc::Parser::Ruby < RDoc::Parser
     al.line   = line_no
 
     read_documentation_modifiers al, RDoc::ATTR_MODIFIERS
-    context.add_alias al
-    @stats.add_alias al
+    if al.document_self or not @track_visibility
+      context.add_alias al
+      @stats.add_alias al
+    end
 
     al
   end
@@ -1039,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]) ||
@@ -1453,6 +1464,12 @@ class RDoc::Parser::Ruby < RDoc::Parser
     meth = RDoc::AnyMethod.new get_tkread, name
     look_for_directives_in meth, comment
     meth.singleton = single == SINGLE ? true : singleton
+    if singleton
+      # `current_line_visibility' is useless because it works against
+      # the normal method named as same as the singleton method, after
+      # the latter was defined.  Of course these are different things.
+      container.current_line_visibility = :public
+    end
 
     record_location meth
     meth.line   = line_no
@@ -1654,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
@@ -1776,6 +1793,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
 
     nest = 1
     save_visibility = container.visibility
+    container.visibility = :public unless current_method
 
     non_comment_seen = true
 
@@ -1873,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
@@ -1889,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

@@ -125,9 +125,11 @@ class RDoc::Parser
     return parser if ext_name.empty?
 
     if parser == RDoc::Parser::Simple and ext_name !~ /txt|rdoc/ then
-      case check_modeline file_name
+      case mode = check_modeline(file_name)
       when nil, 'rdoc' then # continue
-      else return nil
+      else
+        RDoc::Parser.parsers.find { |_, p| return p if mode.casecmp?(p.name[/\w+\z/]) }
+        return nil
       end
     end
 
@@ -164,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/rd/block_parser.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.7.3
+# This file is automatically generated by Racc 1.8.1
 # from Racc grammar file "block_parser.ry".
 #
 
@@ -23,7 +23,7 @@ unless $".find {|p| p.end_with?('/racc/info.rb')}
 $".push "#{__dir__}/racc/info.rb"
 
 module Racc
-  VERSION   = '1.7.3'
+  VERSION   = '1.8.1'
   Version = VERSION
   Copyright = 'Copyright (c) 1999-2006 Minero Aoki'
 end
@@ -31,10 +31,6 @@ end
 end
 
 
-unless defined?(NotImplementedError)
-  NotImplementedError = NotImplementError # :nodoc:
-end
-
 module Racc
   class ParseError < StandardError; end
 end
@@ -42,7 +38,7 @@ unless defined?(::ParseError)
   ParseError = Racc::ParseError # :nodoc:
 end
 
-# Racc is a LALR(1) parser generator.
+# Racc is an LALR(1) parser generator.
 # It is written in Ruby itself, and generates Ruby programs.
 #
 # == Command-line Reference