irb 1.1.1 → 1.2.0

data/irb.gemspec

@@ -16,11 +16,68 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/ruby/irb"
   spec.license       = "BSD-2-Clause"
 
-  spec.files         = [".gitignore", ".travis.yml", "Gemfile", "LICENSE.txt", "README.md", "Rakefile", "bin/console", "bin/setup", "exe/irb", "irb.gemspec", "lib/irb.rb", "lib/irb/cmd/chws.rb", "lib/irb/cmd/fork.rb", "lib/irb/cmd/help.rb", "lib/irb/cmd/load.rb", "lib/irb/cmd/nop.rb", "lib/irb/cmd/pushws.rb", "lib/irb/cmd/subirb.rb", "lib/irb/completion.rb", "lib/irb/context.rb", "lib/irb/ext/change-ws.rb", "lib/irb/ext/history.rb", "lib/irb/ext/loader.rb", "lib/irb/ext/multi-irb.rb", "lib/irb/ext/save-history.rb", "lib/irb/ext/tracer.rb", "lib/irb/ext/use-loader.rb", "lib/irb/ext/workspaces.rb", "lib/irb/extend-command.rb", "lib/irb/frame.rb", "lib/irb/help.rb", "lib/irb/init.rb", "lib/irb/input-method.rb", "lib/irb/inspector.rb", "lib/irb/lc/.document", "lib/irb/lc/error.rb", "lib/irb/lc/help-message", "lib/irb/lc/ja/encoding_aliases.rb", "lib/irb/lc/ja/error.rb", "lib/irb/lc/ja/help-message", "lib/irb/locale.rb", "lib/irb/magic-file.rb", "lib/irb/notifier.rb", "lib/irb/output-method.rb", "lib/irb/ruby-lex.rb", "lib/irb/ruby-token.rb", "lib/irb/slex.rb", "lib/irb/src_encoding.rb", "lib/irb/version.rb", "lib/irb/workspace.rb", "lib/irb/ws-for-case-2.rb", "lib/irb/xmp.rb"]
+  spec.files         = [
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "bin/console",
+    "bin/setup",
+    "doc/irb/irb-tools.rd.ja",
+    "doc/irb/irb.rd.ja",
+    "exe/irb",
+    "irb.gemspec",
+    "lib/irb.rb",
+    "lib/irb/cmd/chws.rb",
+    "lib/irb/cmd/fork.rb",
+    "lib/irb/cmd/help.rb",
+    "lib/irb/cmd/load.rb",
+    "lib/irb/cmd/nop.rb",
+    "lib/irb/cmd/pushws.rb",
+    "lib/irb/cmd/subirb.rb",
+    "lib/irb/color.rb",
+    "lib/irb/completion.rb",
+    "lib/irb/context.rb",
+    "lib/irb/ext/change-ws.rb",
+    "lib/irb/ext/history.rb",
+    "lib/irb/ext/loader.rb",
+    "lib/irb/ext/multi-irb.rb",
+    "lib/irb/ext/save-history.rb",
+    "lib/irb/ext/tracer.rb",
+    "lib/irb/ext/use-loader.rb",
+    "lib/irb/ext/workspaces.rb",
+    "lib/irb/extend-command.rb",
+    "lib/irb/frame.rb",
+    "lib/irb/help.rb",
+    "lib/irb/init.rb",
+    "lib/irb/input-method.rb",
+    "lib/irb/inspector.rb",
+    "lib/irb/lc/.document",
+    "lib/irb/lc/error.rb",
+    "lib/irb/lc/help-message",
+    "lib/irb/lc/ja/encoding_aliases.rb",
+    "lib/irb/lc/ja/error.rb",
+    "lib/irb/lc/ja/help-message",
+    "lib/irb/locale.rb",
+    "lib/irb/magic-file.rb",
+    "lib/irb/notifier.rb",
+    "lib/irb/output-method.rb",
+    "lib/irb/ruby-lex.rb",
+    "lib/irb/ruby_logo.aa",
+    "lib/irb/src_encoding.rb",
+    "lib/irb/version.rb",
+    "lib/irb/workspace.rb",
+    "lib/irb/ws-for-case-2.rb",
+    "lib/irb/xmp.rb",
+    "man/irb.1",
+  ]
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5")
+
+  spec.add_dependency "reline", ">= 0.0.1"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
 end

data/lib/irb.rb

@@ -9,7 +9,7 @@
 #
 #
 #
-require "e2mmap"
+require "ripper"
 
 require "irb/init"
 require "irb/context"
@@ -18,6 +18,7 @@ require "irb/extend-command"
 require "irb/ruby-lex"
 require "irb/input-method"
 require "irb/locale"
+require "irb/color"
 
 require "irb/version"
 
@@ -43,8 +44,8 @@ require "irb/version"
 #     irb(main):006:1> end
 #     #=> nil
 #
-# The Readline extension module can be used with irb. Use of Readline is
-# default if it's installed.
+# The singleline editor module or multiline editor module can be used with irb.
+# Use of multiline editor is default if it's installed.
 #
 # == Command line options
 #
@@ -59,21 +60,24 @@ require "irb/version"
 #     -W[level=2]       Same as `ruby -W`
 #     --inspect         Use `inspect' for output (default except for bc mode)
 #     --noinspect       Don't use inspect for output
-#     --readline        Use Readline extension module
-#     --noreadline      Don't use Readline extension module
+#     --multiline       Use multiline editor module
+#     --nomultiline     Don't use multiline editor module
+#     --singleline      Use singleline editor module
+#     --nosingleline    Don't use singleline editor module
+#     --colorize        Use colorization
+#     --nocolorize      Don't use colorization
 #     --prompt prompt-mode
 #     --prompt-mode prompt-mode
 #                       Switch prompt mode. Pre-defined prompt modes are
 #                       `default', `simple', `xmp' and `inf-ruby'
 #     --inf-ruby-mode   Use prompt appropriate for inf-ruby-mode on emacs.
-#                       Suppresses --readline.
+#                       Suppresses --multiline and --singleline.
 #     --simple-prompt   Simple prompt mode
 #     --noprompt        No prompt mode
 #     --tracer          Display trace for each execution of commands.
 #     --back-trace-limit n
 #                       Display backtrace top n and tail n. The default
 #                       value is 16.
-#     --irb_debug n     Set internal debug level to n (not for popular use)
 #     -v, --version     Print the version of irb
 #
 # == Configuration
@@ -95,19 +99,20 @@ require "irb/version"
 #     IRB.conf[:IRB_RC] = nil
 #     IRB.conf[:BACK_TRACE_LIMIT]=16
 #     IRB.conf[:USE_LOADER] = false
-#     IRB.conf[:USE_READLINE] = nil
+#     IRB.conf[:USE_MULTILINE] = nil
+#     IRB.conf[:USE_SINGLELINE] = nil
+#     IRB.conf[:USE_COLORIZE] = true
 #     IRB.conf[:USE_TRACER] = false
 #     IRB.conf[:IGNORE_SIGINT] = true
 #     IRB.conf[:IGNORE_EOF] = false
 #     IRB.conf[:PROMPT_MODE] = :DEFAULT
 #     IRB.conf[:PROMPT] = {...}
-#     IRB.conf[:DEBUG_LEVEL]=0
 #
 # === Auto indentation
 #
-# To enable auto-indent mode in irb, add the following to your +.irbrc+:
+# To disable auto-indent mode in irb, add the following to your +.irbrc+:
 #
-#     IRB.conf[:AUTO_INDENT] = true
+#     IRB.conf[:AUTO_INDENT] = false
 #
 # === Autocompletion
 #
@@ -117,16 +122,23 @@ require "irb/version"
 #
 # === History
 #
-# By default, irb disables history and will not store any commands you used.
+# By default, irb will store the last 1000 commands you used in
+# <code>IRB.conf[:HISTORY_FILE]</code> (<code>~/.irb_history</code> by default).
 #
-# If you want to enable history, add the following to your +.irbrc+:
+# If you want to disable history, add the following to your +.irbrc+:
 #
-#     IRB.conf[:SAVE_HISTORY] = 1000
-#
-# This will now store the last 1000 commands in <code>~/.irb_history</code>.
+#     IRB.conf[:SAVE_HISTORY] = nil
 #
 # See IRB::Context#save_history= for more information.
 #
+# The history of _resuls_ of commands evaluated is not stored by default,
+# but can be turned on to be stored with this +.irbrc+ setting:
+#
+#     IRB.conf[:EVAL_HISTORY] = <number>
+#
+# See IRB::Context#eval_history= and History class. The history of command
+# results is not permanently saved in any file.
+#
 # == Customizing the IRB Prompt
 #
 # In order to customize the prompt, you can change the following Hash:
@@ -136,7 +148,7 @@ require "irb/version"
 # This example can be used in your +.irbrc+
 #
 #     IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode
-#       :AUTO_INDENT => true,           # enables auto-indent mode
+#       :AUTO_INDENT => false,          # disables auto-indent mode
 #       :PROMPT_I =>  ">> ",		# simple prompt
 #       :PROMPT_S => nil,		# prompt for continuated strings
 #       :PROMPT_C => nil,		# prompt for continuated statement
@@ -165,6 +177,7 @@ require "irb/version"
 #
 #     IRB.conf[:PROMPT_MODE][:DEFAULT] = {
 #       :PROMPT_I => "%N(%m):%03n:%i> ",
+#       :PROMPT_N => "%N(%m):%03n:%i> ",
 #       :PROMPT_S => "%N(%m):%03n:%i%l ",
 #       :PROMPT_C => "%N(%m):%03n:%i* ",
 #       :RETURN => "%s\n" # used to printf
@@ -268,7 +281,9 @@ require "irb/version"
 # <code>_</code>::
 #   The value command executed, as a local variable
 # <code>__</code>::
-#   The history of evaluated commands
+#   The history of evaluated commands. Available only if
+#   <code>IRB.conf[:EVAL_HISTORY]</code> is not +nil+ (which is the default).
+#   See also IRB::Context#eval_history= and IRB::History.
 # <code>__[line_no]</code>::
 #   Returns the evaluation value at the given line number, +line_no+.
 #   If +line_no+ is a negative, the return value +line_no+ many lines before
@@ -405,14 +420,41 @@ module IRB
   end
 
   class Irb
+    ASSIGNMENT_NODE_TYPES = [
+      # Local, instance, global, class, constant, instance, and index assignment:
+      #   "foo = bar",
+      #   "@foo = bar",
+      #   "$foo = bar",
+      #   "@@foo = bar",
+      #   "::Foo = bar",
+      #   "a::Foo = bar",
+      #   "Foo = bar"
+      #   "foo.bar = 1"
+      #   "foo[1] = bar"
+      :assign,
+
+      # Operation assignment:
+      #   "foo += bar"
+      #   "foo -= bar"
+      #   "foo ||= bar"
+      #   "foo &&= bar"
+      :opassign,
+
+      # Multiple assignment:
+      #   "foo, bar = 1, 2
+      :massign,
+    ]
+    # Note: instance and index assignment expressions could also be written like:
+    # "foo.bar=(1)" and "foo.[]=(1, bar)", when expressed that way, the former
+    # be parsed as :assign and echo will be suppressed, but the latter is
+    # parsed as a :method_add_arg and the output won't be suppressed
+
     # Creates a new irb session
-    def initialize(workspace = nil, input_method = nil, output_method = nil)
-      @context = Context.new(self, workspace, input_method, output_method)
+    def initialize(workspace = nil, input_method = nil)
+      @context = Context.new(self, workspace, input_method)
       @context.main.extend ExtendCommandBundle
       @signal_status = :IN_IRB
-
       @scanner = RubyLex.new
-      @scanner.exception_on_syntax_error = false
     end
 
     def run(conf = IRB.conf)
@@ -458,14 +500,16 @@ module IRB
         else
           @context.io.prompt = p = ""
         end
-        if @context.auto_indent_mode
+        if @context.auto_indent_mode and !@context.io.respond_to?(:auto_indent)
           unless ltype
-            ind = prompt(@context.prompt_i, ltype, indent, line_no)[/.*\z/].size +
+            prompt_i = @context.prompt_i.nil? ? "" : @context.prompt_i
+            ind = prompt(prompt_i, ltype, indent, line_no)[/.*\z/].size +
               indent * 2 - p.size
             ind += 2 if continue
             @context.io.prompt = p + " " * ind if ind > 0
           end
         end
+        @context.io.prompt
       end
 
       @scanner.set_input(@context.io) do
@@ -486,12 +530,14 @@ module IRB
         end
       end
 
+      @scanner.set_auto_indent(@context) if @context.auto_indent_mode
+
       @scanner.each_top_level_statement do |line, line_no|
         signal_status(:IN_EVAL) do
           begin
-            line.untaint
+            line.untaint if RUBY_VERSION < '2.7'
             @context.evaluate(line, line_no, exception: exc)
-            output_value if @context.echo?
+            output_value if @context.echo? && (@context.echo_on_assignment? || !assignment_expression?(line))
           rescue Interrupt => exc
           rescue SystemExit, SignalException
             raise
@@ -506,7 +552,7 @@ module IRB
     end
 
     def handle_exception(exc)
-      if exc.backtrace && exc.backtrace[0] =~ /irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
+      if exc.backtrace && exc.backtrace[0] =~ /\/irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
          !(SyntaxError === exc)
         irb_bug = true
       else
@@ -663,10 +709,18 @@ module IRB
         when "l"
           ltype
         when "i"
-          if $1
-            format("%" + $1 + "d", indent)
+          if indent < 0
+            if $1
+              "-".rjust($1.to_i)
+            else
+              "-"
+            end
           else
-            indent.to_s
+            if $1
+              format("%" + $1 + "d", indent)
+            else
+              indent.to_s
+            end
           end
         when "n"
           if $1
@@ -702,6 +756,21 @@ module IRB
       format("#<%s: %s>", self.class, ary.join(", "))
     end
 
+    def assignment_expression?(line)
+      # Try to parse the line and check if the last of possibly multiple
+      # expressions is an assignment type.
+
+      # If the expression is invalid, Ripper.sexp should return nil which will
+      # result in false being returned. Any valid expression should return an
+      # s-expression where the second selement of the top level array is an
+      # array of parsed expressions. The first element of each expression is the
+      # expression's type.
+      verbose, $VERBOSE = $VERBOSE, nil
+      result = ASSIGNMENT_NODE_TYPES.include?(Ripper.sexp(line)&.dig(1,-1,0))
+      $VERBOSE = verbose
+      result
+    end
+
     ATTR_TTY = "\e[%sm"
     def ATTR_TTY.[](*a) self % a.join(";"); end
     ATTR_PLAIN = ""
@@ -749,8 +818,8 @@ class Binding
   #
   #     Potato.new
   #
-  # Running +ruby potato.rb+ will open an IRB session where +binding.irb+ is
-  # called, and you will see the following:
+  # Running <code>ruby potato.rb</code> will open an IRB session where
+  # +binding.irb+ is called, and you will see the following:
   #
   #     $ ruby potato.rb
   #
@@ -780,7 +849,7 @@ class Binding
   #     irb(#<Potato:0x00007feea1916670>):004:0> @cooked = true
   #     => true
   #
-  # You can exit the IRB session with the `exit` command. Note that exiting will
+  # You can exit the IRB session with the +exit+ command. Note that exiting will
   # resume execution where +binding.irb+ had paused it, as you can see from the
   # output printed to standard output in this example:
   #
@@ -790,9 +859,11 @@ class Binding
   #
   # See IRB@IRB+Usage for more information.
   def irb
-    IRB.setup(eval("__FILE__"), argv: [])
+    IRB.setup(source_location[0], argv: [])
     workspace = IRB::WorkSpace.new(self)
     STDOUT.print(workspace.code_around_binding)
-    IRB::Irb.new(workspace).run(IRB.conf)
+    binding_irb = IRB::Irb.new(workspace)
+    binding_irb.context.irb_path = File.expand_path(source_location[0])
+    binding_irb.run(IRB.conf)
   end
 end

data/lib/irb/cmd/fork.rb

@@ -21,7 +21,7 @@ module IRB
           class << self
             alias_method :exit, ExtendCommand.irb_original_method_name('exit')
           end
-          if iterator?
+          if block_given?
             begin
               yield
             ensure

data/lib/irb/cmd/help.rb

@@ -9,17 +9,18 @@
 #
 #
 
-require 'rdoc/ri/driver'
-
 require_relative "nop"
 
 # :stopdoc:
 module IRB
   module ExtendCommand
     class Help < Nop
-      begin
-        Ri = RDoc::RI::Driver.new
-      rescue SystemExit
+      def execute(*names)
+        require 'rdoc/ri/driver'
+        IRB::ExtendCommand::Help.const_set(:Ri, RDoc::RI::Driver.new)
+      rescue LoadError, SystemExit
+        IRB::ExtendCommand::Help.remove_method(:execute)
+        # raise NoMethodError in ensure
       else
         def execute(*names)
           if names.empty?
@@ -35,6 +36,9 @@ module IRB
           end
           nil
         end
+        nil
+      ensure
+        execute(*names)
       end
     end
   end

data/lib/irb/color.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+require 'reline'
+require 'ripper'
+
+module IRB # :nodoc:
+  module Color
+    CLEAR     = 0
+    BOLD      = 1
+    UNDERLINE = 4
+    REVERSE   = 7
+    RED       = 31
+    GREEN     = 32
+    YELLOW    = 33
+    BLUE      = 34
+    MAGENTA   = 35
+    CYAN      = 36
+
+    TOKEN_KEYWORDS = {
+      on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__'],
+      on_const: ['ENV'],
+    }
+    private_constant :TOKEN_KEYWORDS
+
+    # A constant of all-bit 1 to match any Ripper's state in #dispatch_seq
+    ALL = -1
+    private_constant :ALL
+
+    begin
+      # Following pry's colors where possible, but sometimes having a compromise like making
+      # backtick and regexp as red (string's color, because they're sharing tokens).
+      TOKEN_SEQ_EXPRS = {
+        on_CHAR:            [[BLUE, BOLD],            ALL],
+        on_backtick:        [[RED, BOLD],             ALL],
+        on_comment:         [[BLUE, BOLD],            ALL],
+        on_const:           [[BLUE, BOLD, UNDERLINE], ALL],
+        on_embexpr_beg:     [[RED],                   ALL],
+        on_embexpr_end:     [[RED],                   ALL],
+        on_embvar:          [[RED],                   ALL],
+        on_float:           [[MAGENTA, BOLD],         ALL],
+        on_gvar:            [[GREEN, BOLD],           ALL],
+        on_heredoc_beg:     [[RED],                   ALL],
+        on_heredoc_end:     [[RED],                   ALL],
+        on_ident:           [[BLUE, BOLD],            Ripper::EXPR_ENDFN],
+        on_imaginary:       [[BLUE, BOLD],            ALL],
+        on_int:             [[BLUE, BOLD],            ALL],
+        on_kw:              [[GREEN],                 ALL],
+        on_label:           [[MAGENTA],               ALL],
+        on_label_end:       [[RED, BOLD],             ALL],
+        on_qsymbols_beg:    [[RED, BOLD],             ALL],
+        on_qwords_beg:      [[RED, BOLD],             ALL],
+        on_rational:        [[BLUE, BOLD],            ALL],
+        on_regexp_beg:      [[RED, BOLD],             ALL],
+        on_regexp_end:      [[RED, BOLD],             ALL],
+        on_symbeg:          [[YELLOW],                ALL],
+        on_symbols_beg:     [[RED, BOLD],             ALL],
+        on_tstring_beg:     [[RED, BOLD],             ALL],
+        on_tstring_content: [[RED],                   ALL],
+        on_tstring_end:     [[RED, BOLD],             ALL],
+        on_words_beg:       [[RED, BOLD],             ALL],
+        on_parse_error:     [[RED, REVERSE],          ALL],
+        compile_error:      [[RED, REVERSE],          ALL],
+      }
+    rescue NameError
+      # Give up highlighting Ripper-incompatible older Ruby
+      TOKEN_SEQ_EXPRS = {}
+    end
+    private_constant :TOKEN_SEQ_EXPRS
+
+    class << self
+      def colorable?
+        $stdout.tty? && supported? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
+      end
+
+      def inspect_colorable?(obj, seen: {}.compare_by_identity)
+        case obj
+        when String, Symbol, Regexp, Integer, Float, FalseClass, TrueClass, NilClass
+          true
+        when Hash
+          without_circular_ref(obj, seen: seen) do
+            obj.all? { |k, v| inspect_colorable?(k, seen: seen) && inspect_colorable?(v, seen: seen) }
+          end
+        when Array
+          without_circular_ref(obj, seen: seen) do
+            obj.all? { |o| inspect_colorable?(o, seen: seen) }
+          end
+        when Range
+          inspect_colorable?(obj.begin, seen: seen) && inspect_colorable?(obj.end, seen: seen)
+        when Module
+          !obj.name.nil?
+        else
+          false
+        end
+      end
+
+      def clear
+        return '' unless colorable?
+        "\e[#{CLEAR}m"
+      end
+
+      def colorize(text, seq)
+        return text unless colorable?
+        seq = seq.map { |s| "\e[#{const_get(s)}m" }.join('')
+        "#{seq}#{text}#{clear}"
+      end
+
+      # If `complete` is false (code is incomplete), this does not warn compile_error.
+      # This option is needed to avoid warning a user when the compile_error is happening
+      # because the input is not wrong but just incomplete.
+      def colorize_code(code, complete: true)
+        return code unless colorable?
+
+        symbol_state = SymbolState.new
+        colored = +''
+        length = 0
+
+        scan(code, allow_last_error: !complete) do |token, str, expr|
+          in_symbol = symbol_state.scan_token(token)
+          str.each_line do |line|
+            line = Reline::Unicode.escape_for_print(line)
+            if seq = dispatch_seq(token, expr, line, in_symbol: in_symbol)
+              colored << seq.map { |s| "\e[#{s}m" }.join('')
+              colored << line.sub(/\Z/, clear)
+            else
+              colored << line
+            end
+          end
+          length += str.bytesize
+        end
+
+        # give up colorizing incomplete Ripper tokens
+        if length != code.bytesize
+          return Reline::Unicode.escape_for_print(code)
+        end
+
+        colored
+      end
+
+      private
+
+      def without_circular_ref(obj, seen:, &block)
+        return false if seen.key?(obj)
+        seen[obj] = true
+        block.call
+      ensure
+        seen.delete(obj)
+      end
+
+      # Ripper::Lexer::Elem#state is supported on Ruby 2.5+
+      def supported?
+        return @supported if defined?(@supported)
+        @supported = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+      end
+
+      def scan(code, allow_last_error:)
+        pos = [1, 0]
+
+        verbose, $VERBOSE = $VERBOSE, nil
+        lexer = Ripper::Lexer.new(code)
+        if lexer.respond_to?(:scan) # Ruby 2.7+
+          lexer.scan.each do |elem|
+            str = elem.tok
+            next if allow_last_error and /meets end of file|unexpected end-of-input/ =~ elem.message
+            next if ([elem.pos[0], elem.pos[1] + str.bytesize] <=> pos) <= 0
+
+            str.each_line do |line|
+              if line.end_with?("\n")
+                pos[0] += 1
+                pos[1] = 0
+              else
+                pos[1] += line.bytesize
+              end
+            end
+
+            yield(elem.event, str, elem.state)
+          end
+        else
+          lexer.parse.each do |elem|
+            yield(elem.event, elem.tok, elem.state)
+          end
+        end
+        $VERBOSE = verbose
+      end
+
+      def dispatch_seq(token, expr, str, in_symbol:)
+        if token == :on_parse_error or token == :compile_error
+          TOKEN_SEQ_EXPRS[token][0]
+        elsif in_symbol
+          [YELLOW]
+        elsif TOKEN_KEYWORDS.fetch(token, []).include?(str)
+          [CYAN, BOLD]
+        elsif (seq, exprs = TOKEN_SEQ_EXPRS[token]; (expr & (exprs || 0)) != 0)
+          seq
+        else
+          nil
+        end
+      end
+    end
+
+    # A class to manage a state to know whether the current token is for Symbol or not.
+    class SymbolState
+      def initialize
+        # Push `true` to detect Symbol. `false` to increase the nest level for non-Symbol.
+        @stack = []
+      end
+
+      # Return true if the token is a part of Symbol.
+      def scan_token(token)
+        prev_state = @stack.last
+        case token
+        when :on_symbeg, :on_symbols_beg, :on_qsymbols_beg
+          @stack << true
+        when :on_ident, :on_op, :on_const, :on_ivar, :on_cvar, :on_gvar, :on_kw
+          if @stack.last # Pop only when it's Symbol
+            @stack.pop
+            return prev_state
+          end
+        when :on_tstring_beg
+          @stack << false
+        when :on_embexpr_beg
+          @stack << false
+          return prev_state
+        when :on_tstring_end # :on_tstring_end may close Symbol
+          @stack.pop
+          return prev_state
+        when :on_embexpr_end
+          @stack.pop
+        end
+        @stack.last
+      end
+    end
+    private_constant :SymbolState
+  end
+end