pygments.rb 1.1.2 → 2.0.0

data/lib/pygments/version.rb

@@ -1,5 +1,5 @@
-# coding: utf-8
 # frozen_string_literal: true
+
 module Pygments
-  VERSION = '1.1.2'
+  VERSION = '2.0.0'
 end

data/pygments.rb.gemspec

@@ -1,26 +1,27 @@
-require File.expand_path('../lib/pygments/version', __FILE__)
+# frozen_string_literal: true
+
+require File.expand_path('lib/pygments/version', __dir__)
 
 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.homepage = 'https://github.com/tmm1/pygments.rb'
-  s.has_rdoc = false
+  s.homepage = 'https://github.com/pygments/pygments.rb'
+  s.required_ruby_version = '>= 2.3.0'
 
-  s.authors = ['Aman Gupta', 'Ted Nyman']
-  s.email = ['aman@tmm1.net']
+  s.authors = ['Aman Gupta', 'Ted Nyman', 'Marat Radchenko']
+  s.email = ['marat@slonopotamus.org']
   s.license = 'MIT'
 
-  s.add_dependency 'multi_json', '>= 1.0.0'
-  s.add_development_dependency 'rake-compiler', '~> 0.7.6'
-  s.add_development_dependency 'test-unit', '~> 3.0.0'
+  s.add_development_dependency 'rake', '~> 13.0.0'
+  s.add_development_dependency 'rubocop', '~> 0.81.0'
+  s.add_development_dependency 'test-unit', '~> 3.3.0'
 
   # s.extensions = ['ext/extconf.rb']
   s.require_paths = ['lib']
 
-  exclude = `find . -type l -printf '%P\\0'`.split("\0").map {|f| "':!#{f}'" } * ' '
-  s.files = `git ls-files -- . #{exclude}`.split("\n")
+  s.files = `git ls-files`.split("\n").reject { |f| File.symlink?(f) } + ['lexers']
 end

data/test/test_pygments.rb

@@ -1,10 +1,8 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 require 'test/unit'
 require File.join(File.dirname(__FILE__), '..', '/lib/pygments.rb')
-ENV['mentos-test'] = "yes"
-
+ENV['mentos-test'] = 'yes'
 
 P = Pygments
 PE = Pygments.engine
@@ -12,7 +10,7 @@ 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"
-  REDIS_CODE = File.read(File.join(File.dirname(__FILE__), '..', '/test/test_data.c'))
+  TEST_CODE = File.read(File.join(File.dirname(__FILE__), '..', 'lib', 'pygments', 'mentos.py'))
 
   def test_highlight_defaults_to_html
     code = P.highlight(RUBY_CODE)
@@ -27,74 +25,69 @@ class PygmentsHighlightTest < Test::Unit::TestCase
   end
 
   def test_full_table_highlight
-    code = P.highlight(RUBY_CODE, :options => {:linenos => true})
+    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
   end
 
   def test_highlight_works_with_larger_files
-    code = P.highlight(REDIS_CODE)
-    assert_match 'used_memory_peak_human', code
-    assert_equal 458511, code.bytesize.to_i
+    code = P.highlight(TEST_CODE)
+    assert_match 'Main loop, waiting for inputs on stdin', code
   end
 
-  def test_returns_nil_on_timeout
-    large_code = REDIS_CODE * 300
-    code = P.highlight(large_code) # a 30 mb highlight request will timeout
-    assert_equal nil, code
+  def test_raises_exception_on_timeout
+    assert_raise MentosError.new('Timeout on a mentos highlight call') do
+      # Assume highlighting a large file will take more than 1 millisecond
+      P.highlight(TEST_CODE * 10, timeout: 0.001)
+    end
   end
 
   def test_highlight_works_with_null_bytes
-    code = P.highlight("\0hello", :lexer => 'rb')
-    assert_match "hello", code
+    code = P.highlight("\0hello", lexer: 'rb')
+    assert_match 'hello', code
   end
 
   def test_highlight_works_on_utf8
-    code = P.highlight('# ø', :lexer => 'rb', :options => {:encoding => 'utf-8'})
-    assert_match "# ø", code
+    code = P.highlight('# ø', lexer: 'rb', options: { encoding: 'utf-8' })
+    assert_match '# ø', code
   end
 
   def test_highlight_works_on_utf8_automatically
-    code = P.highlight('# ø', :lexer => 'rb')
-    assert_match "# ø", code
+    code = P.highlight('# ø', lexer: 'rb')
+    assert_match '# ø', code
   end
 
   def test_highlight_works_on_utf8_all_chars_automatically
-    code = P.highlight('def foo: # ø', :lexer => 'py')
+    code = P.highlight('def foo: # ø', lexer: 'py')
 
-    assert_equal "<div class=\"highlight\"><pre><span></sp", code[0,38]
+    assert_equal '<div class="highlight"><pre><span></sp', code[0, 38]
   end
 
   def test_highlight_works_with_multiple_utf8
-    code = P.highlight('# ø ø ø', :lexer => 'rb', :options => {:encoding => 'utf-8'})
-    assert_match "# ø ø ø", code
+    code = P.highlight('# ø ø ø', lexer: 'rb', options: { encoding: 'utf-8' })
+    assert_match '# ø ø ø', code
   end
 
   def test_highlight_works_with_multiple_utf8_and_trailing_newline
-    code = P.highlight("#!/usr/bin/ruby\nputs 'ø..ø'\n", :lexer => 'rb')
-    assert_match "ø..ø", code
+    code = P.highlight("#!/usr/bin/ruby\nputs 'ø..ø'\n", lexer: 'rb')
+    assert_match 'ø..ø', code
   end
 
   def test_highlight_formatter_bbcode
-    code = P.highlight(RUBY_CODE, :formatter => 'bbcode')
+    code = P.highlight(RUBY_CODE, formatter: 'bbcode')
     assert_match 'color=#408080][i]#!/usr/bin/ruby[/i]', code
   end
 
   def test_highlight_formatter_terminal
-    code = P.highlight(RUBY_CODE, :formatter => 'terminal')
+    code = P.highlight(RUBY_CODE, formatter: 'terminal')
     assert_match '39;49;00m', code
   end
 
   def test_highlight_options
-    code = P.highlight(RUBY_CODE, :options => {:full => true, :title => 'test'})
+    code = P.highlight(RUBY_CODE, options: { full: true, title: 'test' })
     assert_match '<title>test</title>', code
   end
 
-  def test_highlight_works_with_single_character_input
-    code = P.highlight("a")
-    assert_match "a\n</pre>", code
-  end
-
   def test_highlight_works_with_trailing_newline
     code = P.highlight(RUBY_CODE_TRAILING_NEWLINE)
     assert_match '<span class="ch">#!/usr/bin/ruby</span>', code
@@ -111,66 +104,18 @@ class PygmentsHighlightTest < Test::Unit::TestCase
   end
 
   def test_highlight_still_works_with_invalid_code
-    code = P.highlight("importr python;    wat?", :lexer => 'py')
-    assert_match ">importr</span>", code
+    code = P.highlight('importr python;    wat?', lexer: 'py')
+    assert_match '>importr</span>', code
   end
 
   def test_highlight_on_multi_threads
+    omit 'We do not actually support multithreading'
+
     10.times.map do
       Thread.new do
         test_full_html_highlight
       end
-    end.each do |thread|
-      thread.join
-    end
-  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
-
-  def test_get_fixed_bits_from_header
-    bits = PE.send(:get_fixed_bits_from_header, '{"herp": "derp"}')
-    assert_equal "00000000000000000000000000010000", bits
-  end
-
-  def test_get_fixed_bits_from_header_works_with_large_headers
-    bits = PE.send(:get_fixed_bits_from_header, '{"herp": "derp"}' * 10000)
-    assert_equal "00000000000000100111000100000000", bits
-  end
-
-  def test_size_check
-    size = "00000000000000000000000000100110"
-    res = PE.send(:size_check, size)
-    assert_equal res, true
-  end
-
-  def test_size_check_bad
-    size = "some random thing"
-    res = PE.send(:size_check, size)
-    assert_equal res, false
+    end.each(&:join)
   end
 end
 
@@ -178,23 +123,23 @@ 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_equal 'json', P.lexer_name_for(:mimetype => 'application/json')
+    assert_equal 'rb', P.lexer_name_for(mimetype: 'text/x-ruby')
+    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_equal 'scala', P.lexer_name_for(:filename => 'test.scala')
+    assert_equal 'rb', P.lexer_name_for(filename: 'test.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_equal 'python', P.lexer_name_for(:lexer => 'python')
-    assert_equal 'c', P.lexer_name_for(:lexer => 'c')
+    assert_equal 'rb', P.lexer_name_for(lexer: 'ruby')
+    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_equal 'rb', P.lexer_name_for(RUBY_CODE, filename: 'test.rb')
   end
 
   def test_lexer_by_content
@@ -203,7 +148,7 @@ class PygmentsLexerTest < Test::Unit::TestCase
 
   def test_lexer_by_nothing
     assert_raise MentosError do
-      P.lexer_name_for(:invalid => true)
+      P.lexer_name_for(invalid: true)
     end
   end
 end
@@ -240,14 +185,13 @@ class PygmentsLexerClassTest < Test::Unit::TestCase
     assert_equal P::Lexer['Java'], P::Lexer.find_by_extname('.java')
   end
 
- def test_find_lexer_by_mimetype
+  def test_find_lexer_by_mimetype
     assert_equal P::Lexer['Ruby'], P::Lexer.find_by_mimetype('text/x-ruby')
     assert_equal P::Lexer['JSON'], P::Lexer.find_by_mimetype('application/json')
     assert_equal P::Lexer['Python'], P::Lexer.find_by_mimetype('text/x-python')
- end
+  end
 end
 
-
 class PygmentsCssTest < Test::Unit::TestCase
   include Pygments
 
@@ -260,11 +204,11 @@ class PygmentsCssTest < Test::Unit::TestCase
   end
 
   def test_css_options
-    assert_match(/^\.codeerr \{/, P.css(:classprefix => 'code'))
+    assert_match(/^\.codeerr \{/, P.css(classprefix: 'code'))
   end
 
   def test_css_prefix_and_options
-    assert_match(/^\.mycode \.codeerr \{/, P.css('.mycode', :classprefix => 'code'))
+    assert_match(/^\.mycode \.codeerr \{/, P.css('.mycode', classprefix: 'code'))
   end
 
   def test_css_default
@@ -272,7 +216,7 @@ class PygmentsCssTest < Test::Unit::TestCase
   end
 
   def test_css_colorful
-    assert_match '.c { color: #888888 }', P.css(:style => 'colorful')
+    assert_match '.c { color: #888888 }', P.css(style: 'colorful')
   end
 end
 
@@ -287,15 +231,13 @@ class PygmentsConfigTest < Test::Unit::TestCase
 
   def test_lexers
     list = P.lexers
-    assert list.has_key?('Ruby')
+    assert list.key?('Ruby')
     assert list['Ruby'][:aliases].include?('duby')
   end
 
   def test_formatters
     list = P.formatters
-    assert list.has_key?('Html')
+    assert list.key?('Html')
     assert list['Html'][:aliases].include?('html')
   end
 end
-
-

data/vendor/pygments-main/{AUTHORS → Pygments-2.7.3.dist-info/AUTHORS}

@@ -7,7 +7,8 @@ Other contributors, listed alphabetically, are:
 
 * Sam Aaron -- Ioke lexer
 * Ali Afshar -- image formatter
-* Thomas Aglassinger -- Easytrieve, JCL, Rexx and Transact-SQL lexers
+* Thomas Aglassinger -- Easytrieve, JCL, Rexx, Transact-SQL and VBScript
+  lexers
 * Muthiah Annamalai -- Ezhil lexer
 * Kumar Appaiah -- Debian control lexer
 * Andreas Amann -- AppleScript lexer
@@ -31,8 +32,10 @@ Other contributors, listed alphabetically, are:
 * Sébastien Bigaret -- QVT Operational lexer
 * Jarrett Billingsley -- MiniD lexer
 * Adam Blinkinsop -- Haskell, Redcode lexers
+* Stéphane Blondon -- SGF and Sieve lexers
 * Frits van Bommel -- assembler lexers
 * Pierre Bourdon -- bugfixes
+* Martijn Braam -- Kernel log lexer, BARE lexer
 * Matthias Bussonnier -- ANSI style handling for terminal-256 formatter
 * chebee7i -- Python traceback lexer improvements
 * Hiram Chirino -- Scaml and Jade lexers
@@ -53,26 +56,30 @@ Other contributors, listed alphabetically, are:
 * Sven Efftinge -- Xtend lexer
 * Artem Egorkine -- terminal256 formatter
 * Matthew Fernandez -- CAmkES lexer
+* Paweł Fertyk -- GDScript lexer, HTML formatter improvements
 * Michael Ficarra -- CPSA lexer
 * James H. Fisher -- PostScript lexer
 * William S. Fulton -- SWIG lexer
 * Carlos Galdino -- Elixir and Elixir Console lexers
 * Michael Galloy -- IDL lexer
 * Naveen Garg -- Autohotkey lexer
+* Simon Garnotel -- FreeFem++ lexer
 * Laurent Gautier -- R/S lexer
 * Alex Gaynor -- PyPy log lexer
 * Richard Gerkin -- Igor Pro lexer
 * Alain Gilbert -- TypeScript lexer
 * Alex Gilding -- BlitzBasic lexer
+* GitHub, Inc -- DASM16, Augeas, TOML, and Slash lexers
 * Bertrand Goetzmann -- Groovy lexer
 * Krzysiek Goj -- Scala lexer
+* Rostyslav Golda -- FloScript lexer
 * Andrey Golovizin -- BibTeX lexers
 * Matt Good -- Genshi, Cheetah lexers
 * Michał Górny -- vim modeline support
 * Alex Gosse -- TrafficScript lexer
 * Patrick Gotthardt -- PHP namespaces support
 * Olivier Guibe -- Asymptote lexer
-* Jordi Gutiérrez Hermoso -- Octave lexer
+* Phil Hagelberg -- Fennel lexer
 * Florian Hahn -- Boogie lexer
 * Martin Harriman -- SNOBOL lexer
 * Matthew Harrison -- SVG formatter
@@ -81,7 +88,9 @@ Other contributors, listed alphabetically, are:
 * Aslak Hellesøy -- Gherkin lexer
 * Greg Hendershott -- Racket lexer
 * Justin Hendrick -- ParaSail lexer
+* Jordi Gutiérrez Hermoso -- Octave lexer
 * David Hess, Fish Software, Inc. -- Objective-J lexer
+* Ken Hilton -- Typographic Number Theory and Arrow lexers
 * Varun Hiremath -- Debian control lexer
 * Rob Hoelz -- Perl 6 lexer
 * Doug Hogan -- Mscgen lexer
@@ -98,6 +107,7 @@ Other contributors, listed alphabetically, are:
 * Dennis Kaarsemaker -- sources.list lexer
 * Dmitri Kabak -- Inferno Limbo lexer
 * Igor Kalnitsky -- vhdl lexer
+* Colin Kennedy - USD lexer
 * Alexander Kit -- MaskJS lexer
 * Pekka Klärck -- Robot Framework lexer
 * Gerwin Klein -- Isabelle lexer
@@ -129,6 +139,7 @@ Other contributors, listed alphabetically, are:
 * Stephen McKamey -- Duel/JBST lexer
 * Brian McKenna -- F# lexer
 * Charles McLaughlin -- Puppet lexer
+* Kurt McKee -- Tera Term macro lexer, PostgreSQL updates, MySQL overhaul
 * Lukas Meuser -- BBCode formatter, Lua lexer
 * Cat Miller -- Pig lexer
 * Paul Miller -- LiveScript lexer
@@ -145,6 +156,7 @@ Other contributors, listed alphabetically, are:
 * Nam T. Nguyen -- Monokai style
 * Jesper Noehr -- HTML formatter "anchorlinenos"
 * Mike Nolta -- Julia lexer
+* Avery Nortonsmith -- Pointless lexer
 * Jonas Obrist -- BBCode lexer
 * Edward O'Callaghan -- Cryptol lexer
 * David Oliva -- Rebol lexer
@@ -155,10 +167,14 @@ Other contributors, listed alphabetically, are:
 * Dominik Picheta -- Nimrod lexer
 * Andrew Pinkham -- RTF Formatter Refactoring
 * Clément Prévost -- UrbiScript lexer
+* Tanner Prynn -- cmdline -x option and loading lexers from files
 * Oleh Prypin -- Crystal lexer (based on Ruby lexer)
+* Xidorn Quan -- Web IDL lexer
 * Elias Rabel -- Fortran fixed form lexer
 * raichoo -- Idris lexer
+* Daniel Ramirez -- GDScript lexer
 * Kashif Rasul -- CUDA lexer
+* Nathan Reed -- HLSL lexer
 * Justin Reidy -- MXML lexer
 * Norman Richards -- JSON lexer
 * Corey Richardson -- Rust lexer updates
@@ -172,9 +188,12 @@ Other contributors, listed alphabetically, are:
 * Stou Sandalski -- NumPy, FORTRAN, tcsh and XSLT lexers
 * Matteo Sasso -- Common Lisp lexer
 * Joe Schafer -- Ada lexer
+* Max Schillinger -- TiddlyWiki5 lexer
 * Ken Schutte -- Matlab lexers
+* René Schwaiger -- Rainbow Dash style
 * Sebastian Schweizer -- Whiley lexer
 * Tassilo Schweyer -- Io, MOOCode lexers
+* Pablo Seminario -- PromQL lexer
 * Ted Shaw -- AutoIt lexer
 * Joerg Sieker -- ABAP lexer
 * Robert Simmons -- Standard ML lexer
@@ -183,7 +202,7 @@ Other contributors, listed alphabetically, are:
 * Alexander Smishlajev -- Visual FoxPro lexer
 * Steve Spigarelli -- XQuery lexer
 * Jerome St-Louis -- eC lexer
-* Camil Staps -- Clean and NuSMV lexers
+* Camil Staps -- Clean and NuSMV lexers; Solarized style
 * James Strachan -- Kotlin lexer
 * Tom Stuart -- Treetop lexer
 * Colin Sullivan -- SuperCollider lexer
@@ -214,5 +233,6 @@ Other contributors, listed alphabetically, are:
 * Alex Zimin -- Nemerle lexer
 * Rob Zimmerman -- Kal lexer
 * Vincent Zurczak -- Roboconf lexer
+* Hubert Gruniaux -- C and C++ lexer improvements
 
 Many thanks for all contributions!