geminfo 0.1.0

data/path/gems/coderay-1.1.0/README_INDEX.rdoc

@@ -0,0 +1,123 @@
+= CodeRay
+
+Tired of blue'n'gray? Try the original version of this documentation on
+coderay.rubychan.de[http://coderay.rubychan.de/doc/] :-)
+
+== About
+
+CodeRay is a Ruby library for syntax highlighting.
+
+You put your code in, and you get it back colored; Keywords, strings,
+floats, comments - all in different colors. And with line numbers.
+
+*Syntax* *Highlighting*...
+* makes code easier to read and maintain
+* lets you detect syntax errors faster
+* helps you to understand the syntax of a language
+* looks nice
+* is what everybody wants to have on their website
+* solves all your problems and makes the girls run after you
+
+
+== Installation
+
+ % gem install coderay
+
+
+=== Dependencies
+
+CodeRay needs Ruby 1.8.7+ or 1.9.2+. It also runs on Rubinius and JRuby.
+
+
+== Example Usage
+
+ require 'coderay'
+ 
+ html = CodeRay.scan("puts 'Hello, world!'", :ruby).div(:line_numbers => :table)
+
+
+== Documentation
+
+See CodeRay.
+
+
+== Credits
+
+=== Special Thanks to
+
+* licenser (Heinz N. Gies) for ending my QBasic career, inventing the Coder
+  project and the input/output plugin system.
+  CodeRay would not exist without him.
+* bovi (Daniel Bovensiepen) for helping me out on various occasions.
+
+=== Thanks to
+
+* Caleb Clausen for writing RubyLexer (see
+  http://rubyforge.org/projects/rubylexer) and lots of very interesting mail
+  traffic
+* birkenfeld (Georg Brandl) and mitsuhiku (Arnim Ronacher) for PyKleur, now pygments.
+  You guys rock!
+* Jamis Buck for writing Syntax (see http://rubyforge.org/projects/syntax)
+  I got some useful ideas from it.
+* Doug Kearns and everyone else who worked on ruby.vim - it not only helped me
+  coding CodeRay, but also gave me a wonderful target to reach for the Ruby
+  scanner.
+* everyone who uses CodeBB on http://www.rubyforen.de and http://www.python-forum.de
+* iGEL, magichisoka, manveru, WoNáDo and everyone I forgot from rubyforen.de
+* Dethix from ruby-mine.de
+* zickzackw
+* Dookie (who is no longer with us...) and Leonidas from http://www.python-forum.de
+* Andreas Schwarz for finding out that CaseIgnoringWordList was not case
+  ignoring! Such things really make you write tests.
+* closure for the first version of the Scheme scanner.
+* Stefan Walk for the first version of the JavaScript and PHP scanners.
+* Josh Goebel for another version of the JavaScript scanner, a SQL and a Diff scanner.
+* Jonathan Younger for pointing out the licence confusion caused by wrong LICENSE file.
+* Jeremy Hinegardner for finding the shebang-on-empty-file bug in FileType.
+* Charles Oliver Nutter and Yehuda Katz for helping me benchmark CodeRay on JRuby.
+* Andreas Neuhaus for pointing out a markup bug in coderay/for_redcloth.
+* 0xf30fc7 for the FileType patch concerning Delphi file extensions.
+* The folks at redmine.org - thank you for using and fixing CodeRay!
+* Keith Pitt for his SQL scanners
+* Rob Aldred for the terminal encoder
+* Trans for pointing out $DEBUG dependencies
+* Flameeyes for finding that Term::ANSIColor was obsolete
+* matz and all Ruby gods and gurus
+* The inventors of: the computer, the internet, the true color display, HTML &
+  CSS, VIM, Ruby, pizza, microwaves, guitars, scouting, programming, anime, 
+  manga, coke and green ice tea.
+
+Where would we be without all those people?
+
+=== Created using
+
+* Ruby[http://ruby-lang.org/]
+* Chihiro (my Sony VAIO laptop); Henrietta (my old MacBook);
+  Triella, born Rico (my new MacBook); as well as
+  Seras and Hikari (my PCs)
+* RDE[http://homepage2.nifty.com/sakazuki/rde_e.html],
+  VIM[http://vim.org] and TextMate[http://macromates.com]
+* Subversion[http://subversion.tigris.org/]
+* Redmine[http://redmine.org/]
+* Firefox[http://www.mozilla.org/products/firefox/],
+  Firebug[http://getfirebug.com/], Safari[http://www.apple.com/safari/], and
+  Thunderbird[http://www.mozilla.org/products/thunderbird/]
+* RubyGems[http://docs.rubygems.org/] and Rake[http://rake.rubyforge.org/]
+* TortoiseSVN[http://tortoisesvn.tigris.org/] using Apache via
+  XAMPP[http://www.apachefriends.org/en/xampp.html]
+* RDoc (though I'm quite unsatisfied with it)
+* Microsoft Windows (yes, I confess!) and MacOS X
+* GNUWin32, MinGW and some other tools to make the shell under windows a bit
+  less useless
+* Term::ANSIColor[http://term-ansicolor.rubyforge.org/]
+* PLEAC[http://pleac.sourceforge.net/] code examples
+* Github
+* Travis CI (http://travis-ci.org/rubychan/github)
+
+=== Free
+
+* As you can see, CodeRay was created under heavy use of *free* software.
+* So CodeRay is also *free*.
+* If you use CodeRay to create software, think about making this software
+  *free*, too.
+* Thanks :)

data/path/gems/coderay-1.1.0/Rakefile

@@ -0,0 +1,37 @@
+require 'bundler/gem_tasks'
+
+$:.unshift File.dirname(__FILE__) unless $:.include? '.'
+
+ROOT = '.'
+LIB_ROOT = File.join ROOT, 'lib'
+
+task :default => :test
+
+if File.directory? 'rake_tasks'
+  
+  # load rake tasks from subfolder
+  for task_file in Dir['rake_tasks/*.rake'].sort
+    load task_file
+  end
+  
+else
+  
+  # fallback tasks when rake_tasks folder is not present (eg. in the distribution package)
+  desc 'Run CodeRay tests (basic)'
+  task :test do
+    ruby './test/functional/suite.rb'
+    ruby './test/functional/for_redcloth.rb'
+  end
+  
+  gem 'rdoc' if defined? gem
+  require 'rdoc/task'
+  desc 'Generate documentation for CodeRay'
+  Rake::RDocTask.new :doc do |rd|
+    rd.title = 'CodeRay Documentation'
+    rd.main = 'README_INDEX.rdoc'
+    rd.rdoc_files.add Dir['lib']
+    rd.rdoc_files.add rd.main
+    rd.rdoc_dir = 'doc'
+  end
+  
+end

data/path/gems/coderay-1.1.0/bin/coderay

@@ -0,0 +1,215 @@
+#!/usr/bin/env ruby
+require 'coderay'
+
+$options, args = ARGV.partition { |arg| arg[/^-[hv]$|--\w+/] }
+subcommand = args.first if /^\w/ === args.first
+subcommand = nil if subcommand && File.exist?(subcommand)
+args.delete subcommand
+
+def option? *options
+  !($options & options).empty?
+end
+
+def tty?
+  $stdout.tty? || option?('--tty')
+end
+
+def version
+  puts <<-USAGE
+CodeRay #{CodeRay::VERSION}
+  USAGE
+end
+
+def help
+  puts <<-HELP
+This is CodeRay #{CodeRay::VERSION}, a syntax highlighting tool for selected languages.
+
+usage:
+  coderay [-language] [input] [-format] [output]
+  
+defaults:
+  language   detect from input file name or shebang; fall back to plain text
+  input      STDIN
+  format     detect from output file name or use terminal; fall back to HTML
+  output     STDOUT
+
+common:
+  coderay file.rb                      # highlight file to terminal
+  coderay file.rb > file.html          # highlight file to HTML page
+  coderay file.rb -div > file.html     # highlight file to HTML snippet
+
+configure output:
+  coderay file.py output.json          # output tokens as JSON
+  coderay file.py -loc                 # count lines of code in Python file
+
+configure input:
+  coderay -python file                 # specify the input language
+  coderay -ruby                        # take input from STDIN
+
+more:
+  coderay stylesheet [style]           # print CSS stylesheet
+  HELP
+end
+
+def commands
+  puts <<-COMMANDS
+  general:
+    highlight   code highlighting (default command, optional)
+    stylesheet  print the CSS stylesheet with the given name (aliases: style, css)
+  
+  about:
+    list [of]   list all available plugins (or just the scanners|encoders|styles|filetypes)
+    commands    print this list
+    help        show some help
+    version     print CodeRay version
+  COMMANDS
+end
+
+def print_list_of plugin_host
+  plugins = plugin_host.all_plugins.map do |plugin|
+    info = "  #{plugin.plugin_id}: #{plugin.title}"
+    
+    aliases = (plugin.aliases - [:default]).map { |key| "-#{key}" }.sort_by { |key| key.size }
+    if plugin.respond_to?(:file_extension) || !aliases.empty?
+      additional_info = []
+      additional_info << aliases.join(', ') unless aliases.empty?
+      info << " (#{additional_info.join('; ')})"
+    end
+    
+    info << '  <-- default' if plugin.aliases.include? :default
+    
+    info
+  end
+  puts plugins.sort
+end
+
+if option? '-v', '--version'
+  version
+end
+
+if option? '-h', '--help'
+  help
+end
+
+case subcommand
+when 'highlight', nil
+  if ARGV.empty?
+    version
+    help
+  else
+    signature = args.map { |arg| arg[/^-/] ? '-' : 'f' }.join
+    names     = args.map { |arg| arg.sub(/^-/, '') }
+    case signature
+    when /^$/
+      exit
+    when /^ff?$/
+      input_file, output_file, = *names
+    when /^f-f?$/
+      input_file, output_format, output_file, = *names
+    when /^-ff?$/
+      input_lang, input_file, output_file, = *names
+    when /^-f-f?$/
+      input_lang, input_file, output_format, output_file, = *names
+    when /^--?f?$/
+      input_lang, output_format, output_file, = *names
+    else
+      $stdout = $stderr
+      help
+      puts
+      puts "Unknown parameter order: #{args.join ' '}, expected: [-language] [input] [-format] [output]"
+      exit 1
+    end
+    
+    if input_file
+      input_lang ||= CodeRay::FileType.fetch input_file, :text, true
+    end
+    
+    if output_file
+      output_format ||= CodeRay::FileType[output_file] || :plain
+    else
+      output_format ||= :terminal
+    end
+    
+    output_format = :page if output_format.to_s == 'html'
+    
+    if input_file
+      input = File.read input_file
+    else
+      input = $stdin.read
+    end
+    
+    begin
+      file =
+        if output_file
+          File.open output_file, 'w'
+        else
+          $stdout
+        end
+      CodeRay.encode(input, input_lang, output_format, :out => file)
+      file.puts
+    rescue CodeRay::PluginHost::PluginNotFound => boom
+      $stdout = $stderr
+      if boom.message[/CodeRay::(\w+)s could not load plugin :?(.*?): /]
+        puts "I don't know the #$1 \"#$2\"."
+      else
+        puts boom.message
+      end
+      # puts "I don't know this plugin: #{boom.message[/Could not load plugin (.*?): /, 1]}."
+    rescue CodeRay::Scanners::Scanner::ScanError
+      # this is sometimes raised by pagers; ignore
+    # FIXME: rescue Errno::EPIPE
+    ensure
+      file.close if output_file
+    end
+  end
+when 'li', 'list'
+  arg = args.first && args.first.downcase
+  if [nil, 's', 'sc', 'scanner', 'scanners'].include? arg
+    puts 'input languages (Scanners):'
+    print_list_of CodeRay::Scanners
+  end
+  
+  if [nil, 'e', 'en', 'enc', 'encoder', 'encoders'].include? arg
+    puts 'output formats (Encoders):'
+    print_list_of CodeRay::Encoders
+  end
+  
+  if [nil, 'st', 'style', 'styles'].include? arg
+    puts 'CSS themes for HTML output (Styles):'
+    print_list_of CodeRay::Styles
+  end
+  
+  if [nil, 'f', 'ft', 'file', 'filetype', 'filetypes'].include? arg
+    puts 'recognized file types:'
+    
+    filetypes = Hash.new { |h, k| h[k] = [] }
+    CodeRay::FileType::TypeFromExt.inject filetypes do |types, (ext, type)|
+      types[type.to_s] << ".#{ext}"
+      types
+    end
+    CodeRay::FileType::TypeFromName.inject filetypes do |types, (name, type)|
+      types[type.to_s] << name
+      types
+    end
+    
+    filetypes.sort.each do |type, exts|
+      puts "  #{type}: #{exts.sort_by { |ext| ext.size }.join(', ')}"
+    end
+  end
+when 'stylesheet', 'style', 'css'
+  puts CodeRay::Encoders[:html]::CSS.new(args.first || :default).stylesheet
+when 'commands'
+  commands
+when 'help'
+  help
+else
+  $stdout = $stderr
+  help
+  puts
+  if subcommand[/\A\w+\z/]
+    puts "Unknown command: #{subcommand}"
+  else
+    puts "File not found: #{subcommand}"
+  end
+  exit 1
+end

data/path/gems/coderay-1.1.0/lib/coderay/duo.rb

@@ -0,0 +1,81 @@
+module CodeRay
+  
+  # = Duo
+  #
+  # A Duo is a convenient way to use CodeRay. You just create a Duo,
+  # giving it a lang (language of the input code) and a format (desired
+  # output format), and call Duo#highlight with the code.
+  # 
+  # Duo makes it easy to re-use both scanner and encoder for a repetitive
+  # task. It also provides a very easy interface syntax:
+  # 
+  #   require 'coderay'
+  #   CodeRay::Duo[:python, :div].highlight 'import this'
+  # 
+  # Until you want to do uncommon things with CodeRay, I recommend to use
+  # this method, since it takes care of everything.
+  class Duo
+
+    attr_accessor :lang, :format, :options
+    
+    # Create a new Duo, holding a lang and a format to highlight code.
+    # 
+    # simple:
+    #   CodeRay::Duo[:ruby, :html].highlight 'bla 42'
+    # 
+    # with options:
+    #   CodeRay::Duo[:ruby, :html, :hint => :debug].highlight '????::??'
+    # 
+    # alternative syntax without options:
+    #   CodeRay::Duo[:ruby => :statistic].encode 'class << self; end'
+    # 
+    # alternative syntax with options:
+    #   CodeRay::Duo[{ :ruby => :statistic }, :do => :something].encode 'abc'
+    # 
+    # The options are forwarded to scanner and encoder
+    # (see CodeRay.get_scanner_options).
+    def initialize lang = nil, format = nil, options = {}
+      if format.nil? && lang.is_a?(Hash) && lang.size == 1
+        @lang = lang.keys.first
+        @format = lang[@lang]
+      else
+        @lang = lang
+        @format = format
+      end
+      @options = options
+    end
+    
+    class << self
+      # To allow calls like Duo[:ruby, :html].highlight.
+      alias [] new
+    end
+    
+    # The scanner of the duo. Only created once.
+    def scanner
+      @scanner ||= CodeRay.scanner @lang, CodeRay.get_scanner_options(@options)
+    end
+    
+    # The encoder of the duo. Only created once.
+    def encoder
+      @encoder ||= CodeRay.encoder @format, @options
+    end
+    
+    # Tokenize and highlight the code using +scanner+ and +encoder+.
+    def encode code, options = {}
+      options = @options.merge options
+      encoder.encode(code, @lang, options)
+    end
+    alias highlight encode
+    
+    # Allows to use Duo like a proc object:
+    # 
+    #  CodeRay::Duo[:python => :yaml].call(code)
+    # 
+    # or, in Ruby 1.9 and later:
+    # 
+    #  CodeRay::Duo[:python => :yaml].(code)
+    alias call encode
+    
+  end
+  
+end

data/path/gems/coderay-1.1.0/lib/coderay/encoder.rb

@@ -0,0 +1,201 @@
+module CodeRay
+  
+  # This module holds the Encoder class and its subclasses.
+  # For example, the HTML encoder is named CodeRay::Encoders::HTML
+  # can be found in coderay/encoders/html.
+  #
+  # Encoders also provides methods and constants for the register
+  # mechanism and the [] method that returns the Encoder class
+  # belonging to the given format.
+  module Encoders
+    
+    extend PluginHost
+    plugin_path File.dirname(__FILE__), 'encoders'
+    
+    # = Encoder
+    #
+    # The Encoder base class. Together with Scanner and
+    # Tokens, it forms the highlighting triad.
+    #
+    # Encoder instances take a Tokens object and do something with it.
+    #
+    # The most common Encoder is surely the HTML encoder
+    # (CodeRay::Encoders::HTML). It highlights the code in a colorful
+    # html page.
+    # If you want the highlighted code in a div or a span instead,
+    # use its subclasses Div and Span.
+    class Encoder
+      extend Plugin
+      plugin_host Encoders
+      
+      class << self
+        
+        # If FILE_EXTENSION isn't defined, this method returns the
+        # downcase class name instead.
+        def const_missing sym
+          if sym == :FILE_EXTENSION
+            (defined?(@plugin_id) && @plugin_id || name[/\w+$/].downcase).to_s
+          else
+            super
+          end
+        end
+        
+        # The default file extension for output file of this encoder class.
+        def file_extension
+          self::FILE_EXTENSION
+        end
+        
+      end
+      
+      # Subclasses are to store their default options in this constant.
+      DEFAULT_OPTIONS = { }
+      
+      # The options you gave the Encoder at creating.
+      attr_accessor :options, :scanner
+      
+      # Creates a new Encoder.
+      # +options+ is saved and used for all encode operations, as long
+      # as you don't overwrite it there by passing additional options.
+      #
+      # Encoder objects provide three encode methods:
+      # - encode simply takes a +code+ string and a +lang+
+      # - encode_tokens expects a +tokens+ object instead
+      #
+      # Each method has an optional +options+ parameter. These are
+      # added to the options you passed at creation.
+      def initialize options = {}
+        @options = self.class::DEFAULT_OPTIONS.merge options
+        @@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN = false
+      end
+      
+      # Encode a Tokens object.
+      def encode_tokens tokens, options = {}
+        options = @options.merge options
+        @scanner = tokens.scanner if tokens.respond_to? :scanner
+        setup options
+        compile tokens, options
+        finish options
+      end
+      
+      # Encode the given +code+ using the Scanner for +lang+.
+      def encode code, lang, options = {}
+        options = @options.merge options
+        @scanner = Scanners[lang].new code, CodeRay.get_scanner_options(options).update(:tokens => self)
+        setup options
+        @scanner.tokenize
+        finish options
+      end
+      
+      # You can use highlight instead of encode, if that seems
+      # more clear to you.
+      alias highlight encode
+      
+      # The default file extension for this encoder.
+      def file_extension
+        self.class.file_extension
+      end
+      
+      def << token
+        unless @@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN
+          warn 'Using old Tokens#<< interface.'
+          @@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN = true
+        end
+        self.token(*token)
+      end
+      
+      # Called with +content+ and +kind+ of the currently scanned token.
+      # For simple scanners, it's enougth to implement this method.
+      #
+      # By default, it calls text_token, begin_group, end_group, begin_line,
+      # or end_line, depending on the +content+.
+      def token content, kind
+        case content
+        when String
+          text_token content, kind
+        when :begin_group
+          begin_group kind
+        when :end_group
+          end_group kind
+        when :begin_line
+          begin_line kind
+        when :end_line
+          end_line kind
+        else
+          raise ArgumentError, 'Unknown token content type: %p, kind = %p' % [content, kind]
+        end
+      end
+      
+      # Called for each text token ([text, kind]), where text is a String.
+      def text_token text, kind
+        @out << text
+      end
+      
+      # Starts a token group with the given +kind+.
+      def begin_group kind
+      end
+      
+      # Ends a token group with the given +kind+.
+      def end_group kind
+      end
+      
+      # Starts a new line token group with the given +kind+.
+      def begin_line kind
+      end
+      
+      # Ends a new line token group with the given +kind+.
+      def end_line kind
+      end
+      
+    protected
+      
+      # Called with merged options before encoding starts.
+      # Sets @out to an empty string.
+      #
+      # See the HTML Encoder for an example of option caching.
+      def setup options
+        @out = get_output(options)
+      end
+      
+      def get_output options
+        options[:out] || ''
+      end
+      
+      # Append data.to_s to the output. Returns the argument.
+      def output data
+        @out << data.to_s
+        data
+      end
+      
+      # Called with merged options after encoding starts.
+      # The return value is the result of encoding, typically @out.
+      def finish options
+        @out
+      end
+      
+      # Do the encoding.
+      #
+      # The already created +tokens+ object must be used; it must be a
+      # Tokens object.
+      def compile tokens, options = {}
+        content = nil
+        for item in tokens
+          if item.is_a? Array
+            raise ArgumentError, 'Two-element array tokens are no longer supported.'
+          end
+          if content
+            token content, item
+            content = nil
+          else
+            content = item
+          end
+        end
+        raise 'odd number list for Tokens' if content
+      end
+      
+      alias tokens compile
+      public :tokens
+      
+    end
+    
+  end
+end