rougegal 2.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9dd978789e1300afab6966f401f5c2e1ab5e389
+  data.tar.gz: abf0f6b74e7c2c19ee377867f3f84d40f302141b
+SHA512:
+  metadata.gz: d389b693704093514efa64ecbedb4ac16682d0cef3954ffa4f9e824b96452e2569f1a0d8444ef0c7a09e9d8437997b546cd8a3bf1235d86614b275e0de5286fd
+  data.tar.gz: c86bec7607ce7a1442c8736a531e31e3dd79608b9ff35048620b4215f4a1d0d85703b482c969b9ebe4c5fe07d0832d600727f0e38d5aeb0481c9dd2ce49cf1d6

data/Gemfile

@@ -0,0 +1,26 @@
+source 'http://rubygems.org'
+
+gemspec
+
+gem 'minitest', '~> 4.0'
+gem 'wrong'
+gem 'json'
+
+gem 'rubocop', '~> 0.49.1' if RUBY_VERSION >= '2.0.0'
+
+gem 'rake'
+
+# don't try to install redcarpet under jruby
+gem 'redcarpet', :platforms => :ruby
+
+group :development do
+  gem 'pry'
+
+  # docs
+  gem 'yard'
+  gem 'github-markup'
+
+  # for visual tests
+  gem 'sinatra'
+  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,17 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+ROOT_DIR = Pathname.new(__FILE__).dirname.parent
+load ROOT_DIR.join('lib/rougegal.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/cli.rb

@@ -0,0 +1,394 @@
+# -*- coding: utf-8 -*- #
+
+# not required by the main lib.
+# to use this module, require 'rouge/cli'.
+
+module Rouge
+  class FileReader
+    attr_reader :input
+    def initialize(input)
+      @input = input
+    end
+
+    def file
+      case input
+      when '-'
+        IO.new($stdin.fileno, 'r:utf-8')
+      when String
+        File.new(input, 'r: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 [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 %|	version		#{Version.desc}|
+      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)
+
+      mode = argv.shift
+
+      klass = class_from_arg(mode)
+      return klass.parse(argv) if klass
+
+      case mode
+      when '-h', '--help', 'help', '-help', nil
+        Help.parse(argv)
+      else
+        argv.unshift(mode) if mode
+        Highlight.parse(argv)
+      end
+    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'
+        Help
+      when 'highlight', 'hi'
+        Highlight
+      when 'style'
+        Style
+      when 'list'
+        List
+      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]
+      end
+
+      def self.parse(argv)
+        opts = {
+          :formatter => '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 /^--/
+            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 lexer
+        @lexer ||= lexer_class.new(@lexer_opts)
+      end
+
+      attr_reader :input_file, :lexer_name, :mimetype, :formatter
+
+      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]}"
+
+        @formatter = case opts[:formatter]
+        when 'terminal256' then Formatters::Terminal256.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-table' then Formatters::HTMLTable.new(Formatters::HTML.new)
+        else
+          error! "unknown formatter preset #{opts[:formatter]}"
+        end
+      end
+
+      def run
+        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.  Theme defaults to thankful_eyes.|
+        yield %||
+        yield %|options:|
+        yield %|  --scope	(default: .highlight) a css selector to scope by|
+        yield %||
+        yield %|available themes:|
+        yield %|  #{Theme.registry.keys.sort.join(', ')}|
+      end
+
+      def self.parse(argv)
+        opts = { :theme_name => 'thankful_eyes' }
+
+        until argv.empty?
+          arg = argv.shift
+          case arg
+          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)
+      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 = "#{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
+
+  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