rouge 3.17.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1353759e9c75e7413608191e1fc9f670c4ac4f9db4cb3bc82c9c64d11ae54470
+  data.tar.gz: ae8d26b4295c1089d10c6567c3c5796613be6222e5dd22553f5f62fc238b2765
+SHA512:
+  metadata.gz: ed188bc8fafde40a70384fc5bfb63a179ad23f4bab7c2616811e8260641b7a16fc2843b78c49543a4c45b8f790e47f68508f4979c9a10155ba4de94756c49382
+  data.tar.gz: f88c70213003b8235e275cca3d3776bb48abca5bd6cfdc52f7ef6ef398195028b7201b07c020ebaf5f509683cc7785a2bf93c6e0527a4c51a77f1ef8ca5eece9

data/Gemfile

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+
+gemspec
+
+gem 'rake'
+
+gem 'minitest', '>= 5.0'
+gem 'minitest-power_assert'
+
+gem 'parallel', '~> 1.13.0' if RUBY_VERSION < '2.2.0'
+gem 'rubocop', '~> 0.49.1'
+
+# don't try to install redcarpet under jruby
+gem 'redcarpet', :platforms => :ruby
+
+# Profiling
+if RUBY_VERSION >= '2.3.0'
+  gem 'memory_profiler', :require => false
+end
+
+# Needed for a Rake task
+gem 'git'
+gem 'yard'
+
+group :development do
+  gem 'pry'
+
+  # docs
+  gem 'github-markup'
+
+  # for visual tests
+  if RUBY_VERSION < '2.2.0'
+    gem 'sinatra', '~> 1.4.8'
+  else
+    gem 'sinatra'
+  end
+  gem 'shotgun'
+end

data/LICENSE

@@ -0,0 +1,186 @@
+# MIT license.  See http://www.opensource.org/licenses/mit-license.php
+
+Copyright (c) 2012 Jeanine Adkisson.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+# SPECIAL NOTE:
+Many of the lexers in this project are adaptations of those in Pygments
+(pygments.org).  The license for Pygments is as follows:
+
+# BEGIN pygments/LICENSE #
+
+Copyright (c) 2006-2012 by the respective authors (see AUTHORS file).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# END pygments/LICENSE #
+
+The contents of the AUTHORS file at the time of porting was:
+
+# BEGIN pygments/AUTHORS #
+
+Pygments is written and maintained by Georg Brandl <georg@python.org>.
+
+Major developers are Tim Hatch <tim@timhatch.com> and Armin Ronacher
+<armin.ronacher@active-4.com>.
+
+Other contributors, listed alphabetically, are:
+
+* Sam Aaron -- Ioke lexer
+* Kumar Appaiah -- Debian control lexer
+* Ali Afshar -- image formatter
+* Andreas Amann -- AppleScript lexer
+* Jeffrey Arnold -- R/S lexer, BUGS lexers
+* Jeremy Ashkenas -- CoffeeScript lexer
+* Stefan Matthias Aust -- Smalltalk lexer
+* Ben Bangert -- Mako lexers
+* Max Battcher -- Darcs patch lexer
+* Paul Baumgart, 280 North, Inc. -- Objective-J lexer
+* Michael Bayer -- Myghty lexers
+* John Benediktsson -- Factor lexer
+* Christopher Bertels -- Fancy lexer
+* Jarrett Billingsley -- MiniD lexer
+* Adam Blinkinsop -- Haskell, Redcode lexers
+* Frits van Bommel -- assembler lexers
+* Pierre Bourdon -- bugfixes
+* Hiram Chirino -- Scaml and Jade lexers
+* Leaf Corcoran -- MoonScript lexer
+* Christopher Creutzig -- MuPAD lexer
+* Pete Curry -- bugfixes
+* Owen Durni -- haXe lexer
+* Nick Efford -- Python 3 lexer
+* Sven Efftinge -- Xtend lexer
+* Artem Egorkine -- terminal256 formatter
+* James H. Fisher -- PostScript lexer
+* Carlos Galdino -- Elixir and Elixir Console lexers
+* Naveen Garg -- Autohotkey lexer
+* Laurent Gautier -- R/S lexer
+* Alex Gaynor -- PyPy log lexer
+* Bertrand Goetzmann -- Groovy lexer
+* Krzysiek Goj -- Scala lexer
+* Matt Good -- Genshi, Cheetah lexers
+* Patrick Gotthardt -- PHP namespaces support
+* Olivier Guibe -- Asymptote lexer
+* Martin Harriman -- SNOBOL lexer
+* Matthew Harrison -- SVG formatter
+* Steven Hazel -- Tcl lexer
+* Aslak Hellesøy -- Gherkin lexer
+* Greg Hendershott -- Racket lexer
+* Jordi Gutiérrez Hermoso -- Octave lexer
+* David Hess, Fish Software, Inc. -- Objective-J lexer
+* Varun Hiremath -- Debian control lexer
+* Doug Hogan -- Mscgen lexer
+* Ben Hollis -- Mason lexer
+* Tim Howard -- BlitzMax lexer
+* Ivan Inozemtsev -- Fantom lexer
+* Brian R. Jackson -- Tea lexer
+* Dennis Kaarsemaker -- sources.list lexer
+* Igor Kalnitsky -- vhdl lexer
+* Eric Knibbe -- Lasso lexer
+* Adam Koprowski -- Opa lexer
+* Benjamin Kowarsch -- Modula-2 lexer
+* Alexander Kriegisch -- Kconfig and AspectJ lexers
+* Marek Kubica -- Scheme lexer
+* Jochen Kupperschmidt -- Markdown processor
+* Gerd Kurzbach -- Modelica lexer
+* Olov Lassus -- Dart lexer
+* Sylvestre Ledru -- Scilab lexer
+* Mark Lee -- Vala lexer
+* Ben Mabey -- Gherkin lexer
+* Simone Margaritelli -- Hybris lexer
+* Kirk McDonald -- D lexer
+* Gordon McGregor -- SystemVerilog lexer
+* Stephen McKamey -- Duel/JBST lexer
+* Brian McKenna -- F# lexer
+* Lukas Meuser -- BBCode formatter, Lua lexer
+* Paul Miller -- LiveScript lexer
+* Hong Minhee -- HTTP lexer
+* Michael Mior -- Awk lexer
+* Jon Morton -- Rust lexer
+* Paulo Moura -- Logtalk lexer
+* Mher Movsisyan -- DTD lexer
+* Ana Nelson -- Ragel, ANTLR, R console lexers
+* Nam T. Nguyen -- Monokai style
+* Jesper Noehr -- HTML formatter "anchorlinenos"
+* Mike Nolta -- Julia lexer
+* Jonas Obrist -- BBCode lexer
+* David Oliva -- Rebol lexer
+* Jon Parise -- Protocol buffers lexer
+* Ronny Pfannschmidt -- BBCode lexer
+* Benjamin Peterson -- Test suite refactoring
+* Dominik Picheta -- Nimrod lexer
+* Clément Prévost -- UrbiScript lexer
+* Kashif Rasul -- CUDA lexer
+* Justin Reidy -- MXML lexer
+* Norman Richards -- JSON lexer
+* Lubomir Rintel -- GoodData MAQL and CL lexers
+* Andre Roberge -- Tango style
+* Konrad Rudolph -- LaTeX formatter enhancements
+* Mario Ruggier -- Evoque lexers
+* Stou Sandalski -- NumPy, FORTRAN, tcsh and XSLT lexers
+* Matteo Sasso -- Common Lisp lexer
+* Joe Schafer -- Ada lexer
+* Ken Schutte -- Matlab lexers
+* Tassilo Schweyer -- Io, MOOCode lexers
+* Joerg Sieker -- ABAP lexer
+* Robert Simmons -- Standard ML lexer
+* Kirill Simonov -- YAML lexer
+* Steve Spigarelli -- XQuery lexer
+* Jerome St-Louis -- eC lexer
+* James Strachan -- Kotlin lexer
+* Tiberius Teng -- default style overhaul
+* Jeremy Thurgood -- Erlang, Squid config lexers
+* Erick Tryzelaar -- Felix lexer
+* Daniele Varrazzo -- PostgreSQL lexers
+* Abe Voelker -- OpenEdge ABL lexer
+* Whitney Young -- ObjectiveC lexer
+* Matthias Vallentin -- Bro lexer
+* Nathan Weizenbaum -- Haml and Sass lexers
+* Dietmar Winkler -- Modelica lexer
+* Nils Winter -- Smalltalk lexer
+* Davy Wybiral -- Clojure lexer
+* Diego Zamboni -- CFengine3 lexer
+* Alex Zimin -- Nemerle lexer
+
+Many thanks for all contributions!
+
+# END pygments/AUTHORS #

data/bin/rougify

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pathname'
+ROOT_DIR = Pathname.new(__FILE__).dirname.parent
+load ROOT_DIR.join('lib/rouge.rb')
+load ROOT_DIR.join('lib/rouge/cli.rb')
+Signal.trap('PIPE', 'SYSTEM_DEFAULT') if Signal.list.include? 'PIPE'
+
+begin
+  Rouge::CLI.parse(ARGV).run
+rescue Rouge::CLI::Error => e
+  puts e.message
+  exit e.status
+rescue Interrupt
+  $stderr.puts "\nrouge: interrupted"
+  exit 2
+end

data/lib/rouge.rb

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# stdlib
+require 'pathname'
+
+# The containing module for Rouge
+module Rouge
+  class << self
+    def reload!
+      Object.send :remove_const, :Rouge
+      load __FILE__
+    end
+
+    # Highlight some text with a given lexer and formatter.
+    #
+    # @example
+    #   Rouge.highlight('@foo = 1', 'ruby', 'html')
+    #   Rouge.highlight('var foo = 1;', 'js', 'terminal256')
+    #
+    #   # streaming - chunks become available as they are lexed
+    #   Rouge.highlight(large_string, 'ruby', 'html') do |chunk|
+    #     $stdout.print chunk
+    #   end
+    def highlight(text, lexer, formatter, &b)
+      lexer = Lexer.find(lexer) unless lexer.respond_to? :lex
+      raise "unknown lexer #{lexer}" unless lexer
+
+      formatter = Formatter.find(formatter) unless formatter.respond_to? :format
+      raise "unknown formatter #{formatter}" unless formatter
+
+      formatter.format(lexer.lex(text), &b)
+    end
+  end
+end
+
+# mimic Kernel#require_relative API
+def load_relative(path)
+  load File.join(__dir__, "#{path}.rb")
+end
+
+def lexer_dir(path = '')
+  File.join(__dir__, 'rouge', 'lexers', path)
+end
+
+load_relative 'rouge/version'
+load_relative 'rouge/util'
+load_relative 'rouge/text_analyzer'
+load_relative 'rouge/token'
+
+load_relative 'rouge/lexer'
+load_relative 'rouge/regex_lexer'
+load_relative 'rouge/template_lexer'
+
+Dir.glob(lexer_dir('*rb')).each { |f| Rouge::Lexers.load_lexer(f.sub(lexer_dir, '')) }
+
+load_relative 'rouge/guesser'
+load_relative 'rouge/guessers/util'
+load_relative 'rouge/guessers/glob_mapping'
+load_relative 'rouge/guessers/modeline'
+load_relative 'rouge/guessers/filename'
+load_relative 'rouge/guessers/mimetype'
+load_relative 'rouge/guessers/source'
+load_relative 'rouge/guessers/disambiguation'
+
+load_relative 'rouge/formatter'
+load_relative 'rouge/formatters/html'
+load_relative 'rouge/formatters/html_table'
+load_relative 'rouge/formatters/html_pygments'
+load_relative 'rouge/formatters/html_legacy'
+load_relative 'rouge/formatters/html_linewise'
+load_relative 'rouge/formatters/html_line_table'
+load_relative 'rouge/formatters/html_inline'
+load_relative 'rouge/formatters/terminal256'
+load_relative 'rouge/formatters/terminal_truecolor'
+load_relative 'rouge/formatters/tex'
+load_relative 'rouge/formatters/null'
+
+load_relative 'rouge/theme'
+load_relative 'rouge/tex_theme_renderer'
+load_relative 'rouge/themes/thankful_eyes'
+load_relative 'rouge/themes/colorful'
+load_relative 'rouge/themes/base16'
+load_relative 'rouge/themes/github'
+load_relative 'rouge/themes/igor_pro'
+load_relative 'rouge/themes/monokai'
+load_relative 'rouge/themes/molokai'
+load_relative 'rouge/themes/monokai_sublime'
+load_relative 'rouge/themes/gruvbox'
+load_relative 'rouge/themes/tulip'
+load_relative 'rouge/themes/pastie'
+load_relative 'rouge/themes/bw'
+load_relative 'rouge/themes/magritte'

data/lib/rouge/cli.rb

@@ -0,0 +1,498 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# not required by the main lib.
+# to use this module, require 'rouge/cli'.
+
+require 'rbconfig'
+
+module Rouge
+  class FileReader
+    attr_reader :input
+    def initialize(input)
+      @input = input
+    end
+
+    def file
+      case input
+      when '-'
+        IO.new($stdin.fileno, 'rt:bom|utf-8')
+      when String
+        File.new(input, 'rt:bom|utf-8')
+      when ->(i){ i.respond_to? :read }
+        input
+      end
+    end
+
+    def read
+      @read ||= begin
+        file.read
+      rescue => e
+        $stderr.puts "unable to open #{input}: #{e.message}"
+        exit 1
+      ensure
+        file.close
+      end
+    end
+  end
+
+  class CLI
+    def self.doc
+      return enum_for(:doc) unless block_given?
+
+      yield %|usage: rougify {global options} [command] [args...]|
+      yield %||
+      yield %|where <command> is one of:|
+      yield %|	highlight	#{Highlight.desc}|
+      yield %|	help		#{Help.desc}|
+      yield %|	style		#{Style.desc}|
+      yield %|	list		#{List.desc}|
+      yield %|	guess		#{Guess.desc}|
+      yield %|	version		#{Version.desc}|
+      yield %||
+      yield %|global options:|
+      yield %[	--require|-r <fname>	require <fname> after loading rouge]
+      yield %||
+      yield %|See `rougify help <command>` for more info.|
+    end
+
+    class Error < StandardError
+      attr_reader :message, :status
+      def initialize(message, status=1)
+        @message = message
+        @status = status
+      end
+    end
+
+    def self.parse(argv=ARGV)
+      argv = normalize_syntax(argv)
+
+      while (head = argv.shift)
+        case head
+        when '-h', '--help', 'help', '-help'
+          return Help.parse(argv)
+        when '--require', '-r'
+          require argv.shift
+        else
+          break
+        end
+      end
+
+      klass = class_from_arg(head)
+      return klass.parse(argv) if klass
+
+      argv.unshift(head) if head
+      Highlight.parse(argv)
+    end
+
+    def initialize(options={})
+    end
+
+    def self.error!(msg, status=1)
+      raise Error.new(msg, status)
+    end
+
+    def error!(*a)
+      self.class.error!(*a)
+    end
+
+    def self.class_from_arg(arg)
+      case arg
+      when 'version', '--version', '-v'
+        Version
+      when 'help', nil
+        Help
+      when 'highlight', 'hi'
+        Highlight
+      when 'style'
+        Style
+      when 'list'
+        List
+      when 'guess'
+        Guess
+      end
+    end
+
+    class Version < CLI
+      def self.desc
+        "print the rouge version number"
+      end
+
+      def self.parse(*); new; end
+
+      def run
+        puts Rouge.version
+      end
+    end
+
+    class Help < CLI
+      def self.desc
+        "print help info"
+      end
+
+      def self.doc
+        return enum_for(:doc) unless block_given?
+
+        yield %|usage: rougify help <command>|
+        yield %||
+        yield %|print help info for <command>.|
+      end
+
+      def self.parse(argv)
+        opts = { :mode => CLI }
+        until argv.empty?
+          arg = argv.shift
+          klass = class_from_arg(arg)
+          if klass
+            opts[:mode] = klass
+            next
+          end
+        end
+        new(opts)
+      end
+
+      def initialize(opts={})
+        @mode = opts[:mode]
+      end
+
+      def run
+        @mode.doc.each(&method(:puts))
+      end
+    end
+
+    class Highlight < CLI
+      def self.desc
+        "highlight code"
+      end
+
+      def self.doc
+        return enum_for(:doc) unless block_given?
+
+        yield %[usage: rougify highlight <filename> [options...]]
+        yield %[       rougify highlight [options...]]
+        yield %[]
+        yield %[--input-file|-i <filename>  specify a file to read, or - to use stdin]
+        yield %[]
+        yield %[--lexer|-l <lexer>          specify the lexer to use.]
+        yield %[                            If not provided, rougify will try to guess]
+        yield %[                            based on --mimetype, the filename, and the]
+        yield %[                            file contents.]
+        yield %[]
+        yield %[--formatter|-f <opts>       specify the output formatter to use.]
+        yield %[                            If not provided, rougify will default to]
+        yield %[                            terminal256.]
+        yield %[]
+        yield %[--theme|-t <theme>          specify the theme to use for highlighting]
+        yield %[                            the file. (only applies to some formatters)]
+        yield %[]
+        yield %[--mimetype|-m <mimetype>    specify a mimetype for lexer guessing]
+        yield %[]
+        yield %[--lexer-opts|-L <opts>      specify lexer options in CGI format]
+        yield %[                            (opt1=val1&opt2=val2)]
+        yield %[]
+        yield %[--formatter-opts|-F <opts>  specify formatter options in CGI format]
+        yield %[                            (opt1=val1&opt2=val2)]
+        yield %[]
+        yield %[--require|-r <filename>     require a filename or library before]
+        yield %[                            highlighting]
+        yield %[]
+        yield %[--escape                    allow the use of escapes between <! and !>]
+        yield %[]
+        yield %[--escape-with <l> <r>       allow the use of escapes between custom]
+        yield %[                            delimiters. implies --escape]
+      end
+
+      # There is no consistent way to do this, but this is used elsewhere,
+      # and we provide explicit opt-in and opt-out with $COLORTERM
+      def self.supports_truecolor?
+        return true if %w(24bit truecolor).include?(ENV['COLORTERM'])
+        return false if ENV['COLORTERM'] && ENV['COLORTERM'] =~ /256/
+
+        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+          ENV['ConEmuANSI'] == 'ON' && !ENV['ANSICON']
+        else
+          ENV['TERM'] !~ /(^rxvt)|(-color$)/
+        end
+      end
+
+      def self.parse(argv)
+        opts = {
+          :formatter => supports_truecolor? ? 'terminal-truecolor' : 'terminal256',
+          :theme => 'thankful_eyes',
+          :css_class => 'codehilite',
+          :input_file => '-',
+          :lexer_opts => {},
+          :formatter_opts => {},
+          :requires => [],
+        }
+
+        until argv.empty?
+          arg = argv.shift
+          case arg
+          when '-r', '--require'
+            opts[:requires] << argv.shift
+          when '--input-file', '-i'
+            opts[:input_file] = argv.shift
+          when '--mimetype', '-m'
+            opts[:mimetype] = argv.shift
+          when '--lexer', '-l'
+            opts[:lexer] = argv.shift
+          when '--formatter-preset', '-f'
+            opts[:formatter] = argv.shift
+          when '--theme', '-t'
+            opts[:theme] = argv.shift
+          when '--css-class', '-c'
+            opts[:css_class] = argv.shift
+          when '--lexer-opts', '-L'
+            opts[:lexer_opts] = parse_cgi(argv.shift)
+          when '--escape'
+            opts[:escape] = ['<!', '!>']
+          when '--escape-with'
+            opts[:escape] = [argv.shift, argv.shift]
+          when /^--/
+            error! "unknown option #{arg.inspect}"
+          else
+            opts[:input_file] = arg
+          end
+        end
+
+        new(opts)
+      end
+
+      def input_stream
+        @input_stream ||= FileReader.new(@input_file)
+      end
+
+      def input
+        @input ||= input_stream.read
+      end
+
+      def lexer_class
+        @lexer_class ||= Lexer.guess(
+          :filename => @input_file,
+          :mimetype => @mimetype,
+          :source => input_stream,
+        )
+      end
+
+      def raw_lexer
+        lexer_class.new(@lexer_opts)
+      end
+
+      def escape_lexer
+        Rouge::Lexers::Escape.new(
+          start: @escape[0],
+          end: @escape[1],
+          lang: raw_lexer,
+        )
+      end
+
+      def lexer
+        @lexer ||= @escape ? escape_lexer : raw_lexer
+      end
+
+      attr_reader :input_file, :lexer_name, :mimetype, :formatter, :escape
+
+      def initialize(opts={})
+        Rouge::Lexer.enable_debug!
+
+        opts[:requires].each do |r|
+          require r
+        end
+
+        @input_file = opts[:input_file]
+
+        if opts[:lexer]
+          @lexer_class = Lexer.find(opts[:lexer]) \
+            or error! "unknown lexer #{opts[:lexer].inspect}"
+        else
+          @lexer_name = opts[:lexer]
+          @mimetype = opts[:mimetype]
+        end
+
+        @lexer_opts = opts[:lexer_opts]
+
+        theme = Theme.find(opts[:theme]).new or error! "unknown theme #{opts[:theme]}"
+
+        # TODO: document this in --help
+        @formatter = case opts[:formatter]
+        when 'terminal256' then Formatters::Terminal256.new(theme)
+        when 'terminal-truecolor' then Formatters::TerminalTruecolor.new(theme)
+        when 'html' then Formatters::HTML.new
+        when 'html-pygments' then Formatters::HTMLPygments.new(Formatters::HTML.new, opts[:css_class])
+        when 'html-inline' then Formatters::HTMLInline.new(theme)
+        when 'html-line-table' then Formatters::HTMLLineTable.new(Formatters::HTML.new)
+        when 'html-table' then Formatters::HTMLTable.new(Formatters::HTML.new)
+        when 'null', 'raw', 'tokens' then Formatters::Null.new
+        when 'tex' then Formatters::Tex.new
+        else
+          error! "unknown formatter preset #{opts[:formatter]}"
+        end
+
+        @escape = opts[:escape]
+      end
+
+      def run
+        Formatter.enable_escape! if @escape
+        formatter.format(lexer.lex(input), &method(:print))
+      end
+
+    private_class_method
+      def self.parse_cgi(str)
+        pairs = CGI.parse(str).map { |k, v| [k.to_sym, v.first] }
+        Hash[pairs]
+      end
+    end
+
+    class Style < CLI
+      def self.desc
+        "print CSS styles"
+      end
+
+      def self.doc
+        return enum_for(:doc) unless block_given?
+
+        yield %|usage: rougify style [<theme-name>] [<options>]|
+        yield %||
+        yield %|Print CSS styles for the given theme.  Extra options are|
+        yield %|passed to the theme. To select a mode (light/dark) for the|
+        yield %|theme, append '.light' or '.dark' to the <theme-name>|
+        yield %|respectively. Theme defaults to thankful_eyes.|
+        yield %||
+        yield %|options:|
+        yield %|  --scope     	(default: .highlight) a css selector to scope by|
+        yield %|  --tex       	(default: false) render as TeX|
+        yield %|  --tex-prefix	(default: RG) a command prefix for TeX|
+        yield %|              	implies --tex if specified|
+        yield %||
+        yield %|available themes:|
+        yield %|  #{Theme.registry.keys.sort.join(', ')}|
+      end
+
+      def self.parse(argv)
+        opts = {
+          :theme_name => 'thankful_eyes',
+          :tex => false,
+          :tex_prefix => 'RG'
+        }
+
+        until argv.empty?
+          arg = argv.shift
+          case arg
+          when '--tex'
+            opts[:tex] = true
+          when '--tex-prefix'
+            opts[:tex] = true
+            opts[:tex_prefix] = argv.shift
+          when /--(\w+)/
+            opts[$1.tr('-', '_').to_sym] = argv.shift
+          else
+            opts[:theme_name] = arg
+          end
+        end
+
+        new(opts)
+      end
+
+      def initialize(opts)
+        theme_name = opts.delete(:theme_name)
+        theme_class = Theme.find(theme_name) \
+          or error! "unknown theme: #{theme_name}"
+
+        @theme = theme_class.new(opts)
+        if opts[:tex]
+          tex_prefix = opts[:tex_prefix]
+          @theme = TexThemeRenderer.new(@theme, prefix: tex_prefix)
+        end
+      end
+
+      def run
+        @theme.render(&method(:puts))
+      end
+    end
+
+    class List < CLI
+      def self.desc
+        "list available lexers"
+      end
+
+      def self.doc
+        return enum_for(:doc) unless block_given?
+
+        yield %|usage: rouge list|
+        yield %||
+        yield %|print a list of all available lexers with their descriptions.|
+      end
+
+      def self.parse(argv)
+        new
+      end
+
+      def run
+        puts "== Available Lexers =="
+
+        Lexer.all.sort_by(&:tag).each do |lexer|
+          desc = String.new("#{lexer.desc}")
+          if lexer.aliases.any?
+            desc << " [aliases: #{lexer.aliases.join(',')}]"
+          end
+          puts "%s: %s" % [lexer.tag, desc]
+
+          lexer.option_docs.keys.sort.each do |option|
+            puts "  ?#{option}= #{lexer.option_docs[option]}"
+          end
+
+          puts
+        end
+      end
+    end
+
+    class Guess < CLI
+      def self.desc
+        "guess the languages of file"
+      end
+
+      def self.parse(args)
+        new(input_file: args.shift)
+      end
+
+      attr_reader :input_file, :input_source
+
+      def initialize(opts)
+        @input_file = opts[:input_file] || '-'
+        @input_source = FileReader.new(@input_file).read
+      end
+
+      def lexers
+        Lexer.guesses(
+          filename: input_file,
+          source: input_source,
+        )
+      end
+
+      def run
+        lexers.each do |l|
+          puts "{ tag: #{l.tag.inspect}, title: #{l.title.inspect}, desc: #{l.desc.inspect} }"
+        end
+      end
+    end
+
+
+  private_class_method
+    def self.normalize_syntax(argv)
+      out = []
+      argv.each do |arg|
+        case arg
+        when /^(--\w+)=(.*)$/
+          out << $1 << $2
+        when /^(-\w)(.+)$/
+          out << $1 << $2
+        else
+          out << arg
+        end
+      end
+
+      out
+    end
+  end
+end