pygments.rb 2.0.0.rc3 → 2.3.0

data/lib/pygments/popen.rb

@@ -13,23 +13,13 @@ end
 # Python process.
 module Pygments
   class Popen
-    def popen4(argv)
-      stdin, stdout, stderr, wait_thr = Open3.popen3(*argv)
-      while (pid = wait_thr.pid).nil? && wait_thr.alive?
-        # For unknown reasons, wait_thr.pid is not immediately available on JRuby
-      end
-      [pid, stdin, stdout, stderr]
-    end
-
     # Get things started by opening a pipe to mentos (the freshmaker), a
     # Python process that talks to the Pygments library. We'll talk back and
     # forth across this pipe.
-    def start(pygments_path = File.expand_path('../../vendor/pygments-main', __dir__))
-      begin
-        @log = Logger.new(ENV['MENTOS_LOG'] || File::NULL)
-        @log.level = Logger::INFO
-        @log.datetime_format = '%Y-%m-%d %H:%M '
-      end
+    def start(pygments_path = File.join(__dir__, '..', '..', 'vendor', 'pygments-main'))
+      @log = Logger.new(ENV['MENTOS_LOG'] || File::NULL)
+      @log.level = Logger::INFO
+      @log.datetime_format = '%Y-%m-%d %H:%M '
 
       ENV['PYGMENTS_PATH'] = pygments_path
 
@@ -38,11 +28,11 @@ module Pygments
 
       # A pipe to the mentos python process. #popen4 gives us
       # the pid and three IO objects to write and read.
-      argv = [*python_binary, File.expand_path('mentos.py', __dir__)]
+      argv = [*python_binary, File.join(__dir__, 'mentos.py')]
       @pid, @in, @out, @err = popen4(argv)
       @in.binmode
       @out.binmode
-      @log.info "Starting pid #{@pid} with fd #{@out.to_i} and python #{python_binary}."
+      @log.info "Starting pid #{@pid} with python #{python_binary}."
     end
 
     def python_binary
@@ -53,29 +43,6 @@ module Pygments
       @python_bin = python_bin
     end
 
-    # Detect a suitable Python binary to use.
-    def find_python_binary
-      if Gem.win_platform?
-        return %w[py python3 python].first { |py| !which(py).nil? }
-      end
-
-      # On non-Windows platforms, we simply rely on shebang
-      []
-    end
-
-    # Cross platform which command
-    # from http://stackoverflow.com/a/5471032/284795
-    def which(command)
-      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-      ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
-        exts.each do |ext|
-          path = File.join(dir, "#{command}#{ext}")
-          return path if File.executable?(path) && !File.directory?(path)
-        end
-      end
-      nil
-    end
-
     # Stop the child process by issuing a kill -9.
     #
     # We then call waitpid() with the pid, which waits for that particular
@@ -88,13 +55,15 @@ module Pygments
     # Technically, kill() can also fail with EPERM or EINVAL (wherein
     # the signal isn't sent); but we have permissions, and
     # we're not doing anything invalid here.
+    # @param reason [String]
     def stop(reason)
       unless @pid.nil?
         @log.info "Killing pid: #{@pid}. Reason: #{reason}"
         begin
           Process.kill('KILL', @pid)
           Process.waitpid(@pid)
-        rescue Errno::ESRCH, Errno::ECHILD
+        rescue Errno::ESRCH, Errno::ECHILD => e
+          @log.warn(e)
         end
       end
       @pid = nil
@@ -108,7 +77,7 @@ module Pygments
     # process and the pid has already been re-used) we'll want to raise
     # that as a more informative Mentos exception.
     #
-    # Returns true if the child is alive.
+    # @return [Boolean] true if the child is alive.
     def alive?
       return true if defined?(@pid) && @pid && Process.kill(0, @pid)
 
@@ -119,9 +88,16 @@ module Pygments
       raise MentosError, 'EPERM checking if child process is alive.'
     end
 
+    # Public: Returns version of underlying Pygments library
+    #
+    # @return [Integer]
+    def pygments_version
+      mentos(:version)[0]
+    end
+
     # Public: Get an array of available Pygments formatters
     #
-    # Returns an array of formatters.
+    # @return [Array<String>] an array of formatters
     def formatters
       mentos(:get_all_formatters).each_with_object({}) do |(name, desc, aliases), hash|
         # Remove the long-winded and repetitive 'Formatter' suffix
@@ -134,23 +110,10 @@ module Pygments
       end
     end
 
-    # Public: Get all lexers from a serialized array. This avoids needing to spawn
-    # mentos when it's not really needed (e.g., one-off jobs, loading the Rails env, etc).
-    #
-    # Should be preferred to #lexers!
-    #
-    # Returns an array of lexers.
-    def lexers
-      lexer_file = File.expand_path('../../lexers', __dir__)
-      raw = File.open(lexer_file, 'rb').read
-      Marshal.load(raw)
-    rescue Errno::ENOENT
-      raise MentosError, 'Error loading lexer file. Was it created and vendored?'
-    end
-
-    # Public: Get back all available lexers from mentos itself
+    # Get all available lexers from mentos itself
+    # Do not use this method directly, instead use Pygments#lexers
     #
-    # Returns an array of lexers.
+    # @return [Array<String>] an array of lexers
     def lexers!
       mentos(:get_all_lexers).each_with_object({}) do |lxr, hash|
         name = lxr[0]
@@ -163,17 +126,17 @@ module Pygments
       end
     end
 
-    # Public: Return an array of all available filters
+    # @return [Array<String>] an array of all available filters
     def filters
       mentos(:get_all_filters)
     end
 
-    # Public: Return an array of all available styles
+    # @return [Array<String>] an array of all available styles
     def styles
       mentos(:get_all_styles)
     end
 
-    # Public: Return css for highlighted code
+    # @return [String] css for highlighted code
     def css(klass = '', opts = {})
       if klass.is_a?(Hash)
         opts = klass
@@ -182,8 +145,8 @@ module Pygments
       mentos(:css, ['html', klass], opts)
     end
 
-    # Public: Return the name of a lexer.
-    def lexer_name_for(*args)
+    # @return [[String], nil] aliases of a lexer.
+    def lexer_names_for(*args)
       # Pop off the last arg if it's a hash, which becomes our opts
       opts = if args.last.is_a?(Hash)
                args.pop
@@ -193,13 +156,14 @@ module Pygments
 
       code = (args.pop if args.last.is_a?(String))
 
-      mentos(:lexer_name_for, args, opts, code)
+      mentos(:lexer_names_for, args, opts, code)
     end
 
     # Public: Highlight code.
     #
-    # Takes a first-position argument of the code to be highlighted, and a
-    # second-position hash of various arguments specifying highlighting properties.
+    # Takes a first-position argument of the code to be highlighted,
+    # and a second-position hash of various arguments specifying
+    # highlighting properties.
     #
     # Returns the highlighted string
     # or nil when the request to the Python process timed out.
@@ -216,30 +180,63 @@ module Pygments
 
       # Get back the string from mentos and force encoding if we can
       str = mentos(:highlight, nil, opts, code)
-      if str.respond_to?(:force_encoding)
-        str.force_encoding(opts[:options][:outencoding])
-      end
+      str.force_encoding(opts[:options][:outencoding]) if str.respond_to?(:force_encoding)
       str
     end
 
     private
 
-    def with_watchdog(timeout_time, error_message)
+    # @param argv [Array<String>]
+    def popen4(argv)
+      stdin, stdout, stderr, wait_thr = Open3.popen3(*argv, { close_others: true })
+      while (pid = wait_thr.pid).nil? && wait_thr.alive?
+        # wait_thr.pid is not immediately available on JRuby. Why???
+      end
+      [pid, stdin, stdout, stderr]
+    end
+
+    # Detect a suitable Python binary to use.
+    def find_python_binary
+      return %w[py python3 python].first { |py| !which(py).nil? } if Gem.win_platform?
+
+      # On non-Windows platforms, we simply rely on shebang
+      []
+    end
+
+    # Cross platform which command
+    # from http://stackoverflow.com/a/5471032/284795
+    def which(command)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
+        exts.each do |ext|
+          path = File.join(dir, "#{command}#{ext}")
+          return path if File.executable?(path) && !File.directory?(path)
+        end
+      end
+      nil
+    end
+
+    # @param timeout [Integer]
+    # @param error_message [String]
+    # @yield
+    def with_watchdog(timeout, error_message)
       state_mutex = Mutex.new
       state = :alive
       wd_cleanup = ConditionVariable.new
 
-      watchdog = timeout_time > 0 ? Thread.new do
-        state_mutex.synchronize do
-          wd_cleanup.wait(state_mutex, timeout_time) if state != :finished
-          if state != :finished
-            @log.error error_message
-            stop error_message
-            state = :timeout
-          end
+      watchdog = if timeout.positive?
+                   Thread.new do
+                     state_mutex.synchronize do
+                       wd_cleanup.wait(state_mutex, timeout) if state != :finished
+                       if state != :finished
+                         @log.error error_message
+                         stop error_message
+                         state = :timeout
+                       end
+                     end
+                   end
+                 end
 
-        end
-      end : nil
       begin
         yield
       ensure
@@ -258,53 +255,20 @@ module Pygments
 
     # Our 'rpc'-ish request to mentos. Requires a method name, and then optional
     # args, kwargs, code.
-    def mentos(method, args = [], kwargs = {}, original_code = nil)
+    def mentos(method, args = [], kwargs = {}, code = nil)
       # Open the pipe if necessary
       start unless alive?
 
-      # Timeout requests that take too long.
-      # Invalid MENTOS_TIMEOUT results in just using default.
-      timeout_time = kwargs.delete(:timeout)
-      if timeout_time.nil?
-        timeout_time = begin
-                         Integer(ENV['MENTOS_TIMEOUT'])
-                       rescue TypeError
-                         0
-                       end
-      end
-
-      # For sanity checking on both sides of the pipe when highlighting, we prepend and
-      # append an id.  mentos checks that these are 8 character ids and that they match.
-      # It then returns the id's back to Rubyland.
-      id = (0...8).map { rand(65..89).chr }.join
-      code = original_code ? add_ids(original_code, id) : nil
-
       # Add metadata to the header and generate it.
-      bytesize = if code
-                   code.bytesize
-                 else
-                   0
-                 end
-
-      kwargs.freeze
-      kwargs = kwargs.merge('fd' => @out.to_i, 'id' => id, 'bytes' => bytesize)
+      kwargs = kwargs.merge('bytes' => (code.nil? ? 0 : code.bytesize))
       out_header = JSON.generate(method: method, args: args, kwargs: kwargs)
 
       begin
-        res = with_watchdog(timeout_time, "Timeout on a mentos #{method} call") do
-          # Get the size of the header itself and write that.
-          @in.write([out_header.bytesize].pack('N'))
-          @log.info "Size out: #{out_header.bytesize}"
-
-          # mentos is now waiting for the header, and, potentially, code.
-          @in.write(out_header)
-          @log.info "Out header: #{out_header}"
-          @in.write(code) unless code.nil?
-
-          @in.flush
+        timeout = get_timeout(kwargs.delete(:timeout))
+        res = with_watchdog(timeout, "Timeout on a mentos #{method} call") do
+          write_header(out_header, code)
 
           # mentos will now return data to us. First it sends the header.
-
           header_len_bytes = @out.read(4)
           if header_len_bytes.nil?
             raise Errno::EPIPE, %(Failed to read response from Python process on a mentos #{method} call)
@@ -315,7 +279,7 @@ module Pygments
           header = @out.read(header_len)
 
           # Now handle the header, any read any more data required.
-          handle_header_and_return(header, id)
+          handle_header_and_return(header)
         end
 
         # Finally, return what we got.
@@ -338,74 +302,70 @@ module Pygments
       end
     end
 
+    # @param header [String]
+    # @param code [String, nil]
+    def write_header(header, code)
+      # Get the size of the header itself and write that.
+      @in.write([header.bytesize].pack('N'))
+      @log.info "Size out: #{header.bytesize}"
+
+      # mentos is now waiting for the header, and, potentially, code.
+      @in.write(header)
+      @log.info "Out header: #{header}"
+      @in.write(code) unless code.nil?
+      @in.flush
+    end
+
+    # @param timeout [Integer, nil]
+    # @return [Integer]
+    def get_timeout(timeout)
+      return timeout unless timeout.nil?
+
+      begin
+        Integer(ENV['MENTOS_TIMEOUT'])
+      rescue TypeError
+        0
+      end
+    end
+
     # Based on the header we receive, determine if we need
     # to read more bytes, and read those bytes if necessary.
     #
-    # Then, do a sanity check with the ids.
-    #
-    # Returns a result - either highlighted text or metadata.
-    def handle_header_and_return(header, id)
-      if header
-        @log.info "In header: #{header}"
-        header = header_to_json(header)
-        bytes = header[:bytes]
-
-        # Read more bytes (the actual response body)
-        res = @out.read(bytes.to_i)
-
-        if header[:method] == 'highlight'
-          # Make sure we have a result back; else consider this an error.
-          raise MentosError, 'No highlight result back from mentos.' if res.nil?
-
-          @log.info 'Highlight in process.'
-
-          # Get the id's
-          start_id = res[0..7]
-          end_id = res[-8..-1]
-
-          # Sanity check.
-          if !((start_id == id) && (end_id == id))
-            raise MentosError, "ID's did not match. Aborting."
-          else
-            # We're good. Remove the padding
-            res = res[10..-11]
-            @log.info 'Highlighting complete.'
-            res
-          end
-        end
-        res
-      else
-        raise MentosError, 'No header received back.'
+    # @param header [String, nil]
+    # @return [String, nil] either highlighted text or metadata.
+    def handle_header_and_return(header)
+      raise MentosError, 'No header received back.' if header.nil?
+
+      @log.info "In header: #{header}"
+      header = header_to_json(header)
+      bytes = header[:bytes]
+
+      # Read more bytes (the actual response body)
+      res = @out.read(bytes.to_i)
+
+      if header[:method] == 'highlight' && res.nil?
+        # Make sure we have a result back; else consider this an error.
+        raise MentosError, 'No highlight result back from mentos.'
       end
-    end
 
-    # With the code, prepend the id (with two spaces to avoid escaping weirdness if
-    # the following text starts with a slash (like terminal code), and append the
-    # id, with two padding also. This means we are sending over the 8 characters +
-    # code + 8 characters.
-    def add_ids(code, id)
-      (id + "  #{code}  #{id}").freeze
+      res
     end
 
-    # Return the final result for the API. Return Ruby objects for the methods that
-    # want them, text otherwise.
+    # @return Ruby objects for the methods that want them, text otherwise.
     def return_result(res, method)
-      unless method == :lexer_name_for || method == :highlight || method == :css
-        res = JSON.parse(res, symbolize_names: true)
-      end
-      res = res.rstrip if res.class == String
+      res = JSON.parse(res, symbolize_names: true) unless %i[highlight css].include?(method)
+      res = res.rstrip if res.instance_of?(String)
       res
     end
 
     # Convert a text header into JSON for easy access.
+    # @param header [String]
+    # @return [JSON]
     def header_to_json(header)
-      header = JSON.parse(header, symbolize_names: true)
+      json = JSON.parse(header, symbolize_names: true)
+      raise MentosError, json[:error] unless json[:error].nil?
 
-      if header[:error]
-        raise MentosError, header[:error]
-      else
-        header
-      end
+      json
     end
   end
 end

data/lib/pygments/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pygments
-  VERSION = '2.0.0.rc3'
+  VERSION = '2.3.0'
 end

data/lib/pygments.rb

@@ -1,28 +1,37 @@
 # frozen_string_literal: true
 
-require File.join(File.dirname(__FILE__), 'pygments/popen')
 require 'forwardable'
 
-module Pygments
-  autoload :Lexer, 'pygments/lexer'
+require_relative 'pygments/lexer'
+require_relative 'pygments/popen'
 
+module Pygments
   class << self
     extend Forwardable
 
+    def lexers
+      LexerCache.instance.raw_lexers
+    end
+
     def engine
       Thread.current.thread_variable_get(:pygments_engine) ||
         Thread.current.thread_variable_set(:pygments_engine, Pygments::Popen.new)
     end
 
+    def lexer_name_for(*args)
+      names = engine.lexer_names_for(*args)
+      names&.[](0)
+    end
+
     def_delegators :engine,
                    :formatters,
-                   :lexers,
                    :lexers!,
                    :filters,
                    :styles,
                    :css,
-                   :lexer_name_for,
+                   :lexer_names_for,
                    :highlight,
-                   :start
+                   :start,
+                   :pygments_version
   end
 end

data/pygments.rb.gemspec

@@ -1,27 +1,32 @@
 # frozen_string_literal: true
 
-require File.expand_path('lib/pygments/version', __dir__)
+require_relative 'lib/pygments/version'
 
 Gem::Specification.new do |s|
   s.name = 'pygments.rb'
   s.version = Pygments::VERSION
 
   s.summary = 'pygments wrapper for ruby'
-  s.description = 'pygments.rb exposes the pygments syntax highlighter to Ruby'
-
+  s.description = 'pygments.rb is a Ruby wrapper for Pygments syntax highlighter'
+  s.license = 'MIT'
   s.homepage = 'https://github.com/pygments/pygments.rb'
-  s.required_ruby_version = '>= 2.3.0'
 
   s.authors = ['Aman Gupta', 'Ted Nyman', 'Marat Radchenko']
   s.email = ['marat@slonopotamus.org']
-  s.license = 'MIT'
 
-  s.add_development_dependency 'rake-compiler', '~> 1.1.0'
-  s.add_development_dependency 'rubocop', '~> 0.81.0'
-  s.add_development_dependency 'test-unit', '~> 3.3.0'
+  s.metadata = {
+    'homepage_uri' => s.homepage,
+    'bug_tracker_uri' => "#{s.homepage}/issues",
+    'changelog_uri' => "#{s.homepage}/blob/master/CHANGELOG.adoc",
+    'documentation_uri' => "https://www.rubydoc.info/gems/#{s.name}",
+    'source_code_uri' => s.homepage
+  }
+
+  s.required_ruby_version = '>= 2.3.0'
 
-  # s.extensions = ['ext/extconf.rb']
-  s.require_paths = ['lib']
+  s.add_development_dependency 'rake', '~> 13.0.0'
+  s.add_development_dependency 'rubocop', '~> 0.81.0'
+  s.add_development_dependency 'test-unit', '~> 3.5.0'
 
-  s.files = `git ls-files`.split("\n").reject { |f| File.symlink?(f) } + ['lexers']
+  s.files = `git ls-files -z`.split("\0").reject { |f| File.symlink?(f) }
 end

data/test/test_pygments.rb

@@ -10,7 +10,9 @@ PE = Pygments.engine
 class PygmentsHighlightTest < Test::Unit::TestCase
   RUBY_CODE = "#!/usr/bin/ruby\nputs 'foo'"
   RUBY_CODE_TRAILING_NEWLINE = "#!/usr/bin/ruby\nputs 'foo'\n"
-  TEST_CODE = File.read(File.join(File.dirname(__FILE__), '..', 'lib', 'pygments', 'mentos.py'))
+  TEST_CODE = File.read(
+    File.join(__dir__, '..', 'lib', 'pygments', 'mentos.py')
+  )
 
   def test_highlight_defaults_to_html
     code = P.highlight(RUBY_CODE)
@@ -21,13 +23,9 @@ class PygmentsHighlightTest < Test::Unit::TestCase
   def test_full_html_highlight
     code = P.highlight(RUBY_CODE)
     assert_match '<span class="ch">#!/usr/bin/ruby</span>', code
-    assert_equal "<div class=\"highlight\"><pre><span></span><span class=\"ch\">#!/usr/bin/ruby</span>\n<span class=\"nb\">puts</span> <span class=\"s1\">&#39;foo&#39;</span>\n</pre></div>", code
-  end
-
-  def test_full_table_highlight
-    code = P.highlight(RUBY_CODE, options: { linenos: true })
-    assert_match '<span class="ch">#!/usr/bin/ruby</span>', code
-    assert_equal "<table class=\"highlighttable\"><tr><td class=\"linenos\"><div class=\"linenodiv\"><pre>1\n2</pre></div></td><td class=\"code\"><div class=\"highlight\"><pre><span></span><span class=\"ch\">#!/usr/bin/ruby</span>\n<span class=\"nb\">puts</span> <span class=\"s1\">&#39;foo&#39;</span>\n</pre></div>\n</td></tr></table>", code
+    assert_equal %(<div class="highlight"><pre><span></span><span class="ch">#!/usr/bin/ruby</span>
+<span class="nb">puts</span> <span class="s1">&#39;foo&#39;</span>
+</pre></div>), code
   end
 
   def test_highlight_works_with_larger_files
@@ -94,12 +92,12 @@ class PygmentsHighlightTest < Test::Unit::TestCase
   end
 
   def test_highlight_works_with_multiple_newlines
-    code = P.highlight(RUBY_CODE_TRAILING_NEWLINE + "derp\n\n")
+    code = P.highlight("#{RUBY_CODE_TRAILING_NEWLINE}derp\n\n")
     assert_match '<span class="ch">#!/usr/bin/ruby</span>', code
   end
 
   def test_highlight_works_with_trailing_cr
-    code = P.highlight(RUBY_CODE_TRAILING_NEWLINE + "\r")
+    code = P.highlight("#{RUBY_CODE_TRAILING_NEWLINE}\r")
     assert_match '<span class="ch">#!/usr/bin/ruby</span>', code
   end
 
@@ -108,6 +106,12 @@ class PygmentsHighlightTest < Test::Unit::TestCase
     assert_match '>importr</span>', code
   end
 
+  def test_version
+    version_str = P.pygments_version
+    # This will throw "Malformed version number string" ArgumentError if version_str is not a valid version string
+    Gem::Version.new(version_str)
+  end
+
   def test_highlight_on_multi_threads
     omit 'We do not actually support multithreading'
 
@@ -119,56 +123,31 @@ class PygmentsHighlightTest < Test::Unit::TestCase
   end
 end
 
-# Philosophically, I'm not the biggest fan of testing private
-# methods, but given the relative delicacy of validity checking
-# over the pipe I think it's necessary and informative.
-class PygmentsValidityTest < Test::Unit::TestCase
-  def test_add_ids_with_padding
-    res = PE.send(:add_ids, 'herp derp baz boo foo', 'ABCDEFGH')
-    assert_equal 'ABCDEFGH  herp derp baz boo foo  ABCDEFGH', res
-  end
-
-  def test_add_ids_on_empty_string
-    res = PE.send(:add_ids, '', 'ABCDEFGH')
-    assert_equal 'ABCDEFGH    ABCDEFGH', res
-  end
-
-  def test_add_ids_with_unicode_data
-    res = PE.send(:add_ids, '# ø ø ø', 'ABCDEFGH')
-    assert_equal 'ABCDEFGH  # ø ø ø  ABCDEFGH', res
-  end
-
-  def test_add_ids_with_starting_slashes
-    res = PE.send(:add_ids, '\\# ø ø ø..//', 'ABCDEFGH')
-    assert_equal 'ABCDEFGH  \\# ø ø ø..//  ABCDEFGH', res
-  end
-end
-
 class PygmentsLexerTest < Test::Unit::TestCase
   RUBY_CODE = "#!/usr/bin/ruby\nputs 'foo'"
 
   def test_lexer_by_mimetype
-    assert_equal 'rb', P.lexer_name_for(mimetype: 'text/x-ruby')
+    assert_includes P.lexer_names_for(mimetype: 'text/x-ruby'), 'rb'
     assert_equal 'json', P.lexer_name_for(mimetype: 'application/json')
   end
 
   def test_lexer_by_filename
-    assert_equal 'rb', P.lexer_name_for(filename: 'test.rb')
+    assert_includes P.lexer_names_for(filename: 'test.rb'), 'rb'
     assert_equal 'scala', P.lexer_name_for(filename: 'test.scala')
   end
 
   def test_lexer_by_name
-    assert_equal 'rb', P.lexer_name_for(lexer: 'ruby')
+    assert_includes P.lexer_names_for(lexer: 'ruby'), 'rb'
     assert_equal 'python', P.lexer_name_for(lexer: 'python')
     assert_equal 'c', P.lexer_name_for(lexer: 'c')
   end
 
   def test_lexer_by_filename_and_content
-    assert_equal 'rb', P.lexer_name_for(RUBY_CODE, filename: 'test.rb')
+    assert_includes P.lexer_names_for(RUBY_CODE, filename: 'test.rb'), 'rb'
   end
 
   def test_lexer_by_content
-    assert_equal 'rb', P.lexer_name_for(RUBY_CODE)
+    assert_includes P.lexer_names_for(RUBY_CODE), 'rb'
   end
 
   def test_lexer_by_nothing