geminfo 0.1.0 → 0.1.1

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

@@ -1,85 +0,0 @@
-module CodeRay
-  
-  # A Hash of all known token kinds and their associated CSS classes.
-  TokenKinds = Hash.new(false)
-  
-  # speedup
-  TokenKinds.compare_by_identity if TokenKinds.respond_to? :compare_by_identity
-  
-  TokenKinds.update(  # :nodoc:
-    :debug               => 'debug',              # highlight for debugging (white on blue background)
-    
-    :annotation          => 'annotation',         # Groovy, Java
-    :attribute_name      => 'attribute-name',     # HTML, CSS
-    :attribute_value     => 'attribute-value',    # HTML
-    :binary              => 'binary',             # Python, Ruby
-    :char                => 'char',               # most scanners, also inside of strings
-    :class               => 'class',              # lots of scanners, for different purposes also in CSS
-    :class_variable      => 'class-variable',     # Ruby, YAML
-    :color               => 'color',              # CSS
-    :comment             => 'comment',            # most scanners
-    :constant            => 'constant',           # PHP, Ruby
-    :content             => 'content',            # inside of strings, most scanners
-    :decorator           => 'decorator',          # Python
-    :definition          => 'definition',         # CSS
-    :delimiter           => 'delimiter',          # inside strings, comments and other types
-    :directive           => 'directive',          # lots of scanners
-    :doctype             => 'doctype',            # Goorvy, HTML, Ruby, YAML
-    :docstring           => 'docstring',          # Python
-    :done                => 'done',               # Taskpaper
-    :entity              => 'entity',             # HTML
-    :error               => 'error',              # invalid token, most scanners
-    :escape              => 'escape',             # Ruby (string inline variables like #$foo, #@bar)
-    :exception           => 'exception',          # Java, PHP, Python
-    :filename            => 'filename',           # Diff
-    :float               => 'float',              # most scanners
-    :function            => 'function',           # CSS, JavaScript, PHP
-    :global_variable     => 'global-variable',    # Ruby, YAML
-    :hex                 => 'hex',                # hexadecimal number; lots of scanners
-    :id                  => 'id',                 # CSS
-    :imaginary           => 'imaginary',          # Python
-    :important           => 'important',          # CSS, Taskpaper
-    :include             => 'include',            # C, Groovy, Java, Python, Sass
-    :inline              => 'inline',             # nested code, eg. inline string evaluation; lots of scanners
-    :inline_delimiter    => 'inline-delimiter',   # used instead of :inline > :delimiter FIXME: Why use inline_delimiter?
-    :instance_variable   => 'instance-variable',  # Ruby
-    :integer             => 'integer',            # most scanners
-    :key                 => 'key',                # lots of scanners, used together with :value
-    :keyword             => 'keyword',            # reserved word that's actually implemented; most scanners
-    :label               => 'label',              # C, PHP
-    :local_variable      => 'local-variable',     # local and magic variables; some scanners
-    :map                 => 'map',                # Lua tables
-    :modifier            => 'modifier',           # used inside on strings; lots of scanners
-    :namespace           => 'namespace',          # Clojure, Java, Taskpaper
-    :octal               => 'octal',              # lots of scanners
-    :predefined          => 'predefined',         # predefined function: lots of scanners
-    :predefined_constant => 'predefined-constant',# lots of scanners
-    :predefined_type     => 'predefined-type',    # C, Java, PHP
-    :preprocessor        => 'preprocessor',       # C, Delphi, HTML
-    :pseudo_class        => 'pseudo-class',       # CSS
-    :regexp              => 'regexp',             # Groovy, JavaScript, Ruby
-    :reserved            => 'reserved',           # most scanners
-    :shell               => 'shell',              # Ruby
-    :string              => 'string',             # most scanners
-    :symbol              => 'symbol',             # Clojure, Ruby, YAML
-    :tag                 => 'tag',                # CSS, HTML
-    :type                => 'type',               # CSS, Java, SQL, YAML
-    :value               => 'value',              # used together with :key; CSS, JSON, YAML
-    :variable            => 'variable',           # Sass, SQL, YAML
-    
-    :change              => 'change',             # Diff
-    :delete              => 'delete',             # Diff
-    :head                => 'head',               # Diff, YAML
-    :insert              => 'insert',             # Diff
-    :eyecatcher          => 'eyecatcher',         # Diff
-    
-    :ident               => false,                # almost all scanners
-    :operator            => false,                # almost all scanners
-    
-    :space               => false,                # almost all scanners
-    :plain               => false                 # almost all scanners
-  )
-  
-  TokenKinds[:method]  = TokenKinds[:function]
-  TokenKinds[:unknown] = TokenKinds[:plain]
-end

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

@@ -1,161 +0,0 @@
-module CodeRay
-  
-  # The Tokens class represents a list of tokens returned from
-  # a Scanner. It's actually just an Array with a few helper methods.
-  #
-  # A token itself is not a special object, just two elements in an Array:
-  # * the _token_ _text_ (the original source of the token in a String) or
-  #   a _token_ _action_ (begin_group, end_group, begin_line, end_line)
-  # * the _token_ _kind_ (a Symbol representing the type of the token)
-  #
-  # It looks like this:
-  #
-  #   ..., '# It looks like this', :comment, ...
-  #   ..., '3.1415926', :float, ...
-  #   ..., '$^', :error, ...
-  #
-  # Some scanners also yield sub-tokens, represented by special
-  # token actions, for example :begin_group and :end_group.
-  #
-  # The Ruby scanner, for example, splits "a string" into:
-  #
-  #  [
-  #   :begin_group, :string,
-  #   '"',          :delimiter,
-  #   'a string',   :content,
-  #   '"',          :delimiter,
-  #   :end_group,   :string
-  #  ]
-  #
-  # Tokens can be used to save the output of a Scanners in a simple
-  # Ruby object that can be send to an Encoder later:
-  #
-  #   tokens = CodeRay.scan('price = 2.59', :ruby).tokens
-  #   tokens.encode(:html)
-  #   tokens.html
-  #   CodeRay.encoder(:html).encode_tokens(tokens)
-  #
-  # Tokens gives you the power to handle pre-scanned code very easily:
-  # You can serialize it to a JSON string and store it in a database, pass it
-  # around to encode it more than once, send it to other algorithms...
-  class Tokens < Array
-    
-    # The Scanner instance that created the tokens.
-    attr_accessor :scanner
-    
-    # Encode the tokens using encoder.
-    #
-    # encoder can be
-    # * a plugin name like :html oder 'statistic'
-    # * an Encoder object
-    #
-    # options are passed to the encoder.
-    def encode encoder, options = {}
-      encoder = Encoders[encoder].new options if encoder.respond_to? :to_sym
-      encoder.encode_tokens self, options
-    end
-    
-    # Turn tokens into a string by concatenating them.
-    def to_s
-      encode CodeRay::Encoders::Encoder.new
-    end
-    
-    # Redirects unknown methods to encoder calls.
-    #
-    # For example, if you call +tokens.html+, the HTML encoder
-    # is used to highlight the tokens.
-    def method_missing meth, options = {}
-      encode meth, options
-    rescue PluginHost::PluginNotFound
-      super
-    end
-    
-    # Split the tokens into parts of the given +sizes+.
-    # 
-    # The result will be an Array of Tokens objects. The parts have
-    # the text size specified by the parameter. In addition, each
-    # part closes all opened tokens. This is useful to insert tokens
-    # betweem them.
-    # 
-    # This method is used by @Scanner#tokenize@ when called with an Array
-    # of source strings. The Diff encoder uses it for inline highlighting.
-    def split_into_parts *sizes
-      return Array.new(sizes.size) { Tokens.new } if size == 2 && first == ''
-      parts = []
-      opened = []
-      content = nil
-      part = Tokens.new
-      part_size = 0
-      size = sizes.first
-      i = 0
-      for item in self
-        case content
-        when nil
-          content = item
-        when String
-          if size && part_size + content.size > size  # token must be cut
-            if part_size < size  # some part of the token goes into this part
-              content = content.dup  # content may no be safe to change
-              part << content.slice!(0, size - part_size) << item
-            end
-            # close all open groups and lines...
-            closing = opened.reverse.flatten.map do |content_or_kind|
-              case content_or_kind
-              when :begin_group
-                :end_group
-              when :begin_line
-                :end_line
-              else
-                content_or_kind
-              end
-            end
-            part.concat closing
-            begin
-              parts << part
-              part = Tokens.new
-              size = sizes[i += 1]
-            end until size.nil? || size > 0
-            # ...and open them again.
-            part.concat opened.flatten
-            part_size = 0
-            redo unless content.empty?
-          else
-            part << content << item
-            part_size += content.size
-          end
-          content = nil
-        when Symbol
-          case content
-          when :begin_group, :begin_line
-            opened << [content, item]
-          when :end_group, :end_line
-            opened.pop
-          else
-            raise ArgumentError, 'Unknown token action: %p, kind = %p' % [content, item]
-          end
-          part << content << item
-          content = nil
-        else
-          raise ArgumentError, 'Token input junk: %p, kind = %p' % [content, item]
-        end
-      end
-      parts << part
-      parts << Tokens.new while parts.size < sizes.size
-      parts
-    end
-    
-    # Return the actual number of tokens.
-    def count
-      size / 2
-    end
-    
-    alias text_token push
-    def begin_group kind; push :begin_group, kind end
-    def end_group kind; push :end_group, kind end
-    def begin_line kind; push :begin_line, kind end
-    def end_line kind; push :end_line, kind end
-    alias tokens concat
-    
-  end
-  
-end

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

@@ -1,55 +0,0 @@
-module CodeRay
-  
-  # The result of a scan operation is a TokensProxy, but should act like Tokens.
-  # 
-  # This proxy makes it possible to use the classic CodeRay.scan.encode API
-  # while still providing the benefits of direct streaming.
-  class TokensProxy
-    
-    attr_accessor :input, :lang, :options, :block
-    
-    # Create a new TokensProxy with the arguments of CodeRay.scan.
-    def initialize input, lang, options = {}, block = nil
-      @input   = input
-      @lang    = lang
-      @options = options
-      @block   = block
-    end
-    
-    # Call CodeRay.encode if +encoder+ is a Symbol;
-    # otherwise, convert the receiver to tokens and call encoder.encode_tokens.
-    def encode encoder, options = {}
-      if encoder.respond_to? :to_sym
-        CodeRay.encode(input, lang, encoder, options)
-      else
-        encoder.encode_tokens tokens, options
-      end
-    end
-    
-    # Tries to call encode;
-    # delegates to tokens otherwise.
-    def method_missing method, *args, &blk
-      encode method.to_sym, *args
-    rescue PluginHost::PluginNotFound
-      tokens.send(method, *args, &blk)
-    end
-    
-    # The (cached) result of the tokenized input; a Tokens instance.
-    def tokens
-      @tokens ||= scanner.tokenize(input)
-    end
-    
-    # A (cached) scanner instance to use for the scan task.
-    def scanner
-      @scanner ||= CodeRay.scanner(lang, options, &block)
-    end
-    
-    # Overwrite Struct#each.
-    def each *args, &blk
-      tokens.each(*args, &blk)
-      self
-    end
-    
-  end
-  
-end

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

@@ -1,3 +0,0 @@
-module CodeRay
-  VERSION = '1.1.0'
-end

data/path/gems/coderay-1.1.0/test/functional/basic.rb

@@ -1,318 +0,0 @@
-# encoding: utf-8
-require 'test/unit'
-require File.expand_path('../../lib/assert_warning', __FILE__)
-
-$:.unshift File.expand_path('../../../lib', __FILE__)
-require 'coderay'
-
-class BasicTest < Test::Unit::TestCase
-  
-  def test_version
-    assert_nothing_raised do
-      assert_match(/\A\d\.\d\.\d?\z/, CodeRay::VERSION)
-    end
-  end
-  
-  def with_empty_load_path
-    old_load_path = $:.dup
-    $:.clear
-    yield
-  ensure
-    $:.replace old_load_path
-  end
-  
-  def test_autoload
-    with_empty_load_path do
-      assert_nothing_raised do
-        CodeRay::Scanners::Java::BuiltinTypes
-      end
-    end
-  end
-  
-  RUBY_TEST_CODE = 'puts "Hello, World!"'
-  
-  RUBY_TEST_TOKENS = [
-    ['puts', :ident],
-    [' ', :space],
-    [:begin_group, :string],
-      ['"', :delimiter],
-      ['Hello, World!', :content],
-      ['"', :delimiter],
-    [:end_group, :string]
-  ].flatten
-  def test_simple_scan
-    assert_nothing_raised do
-      assert_equal RUBY_TEST_TOKENS, CodeRay.scan(RUBY_TEST_CODE, :ruby).tokens
-    end
-  end
-  
-  RUBY_TEST_HTML = 'puts <span class="string"><span class="delimiter">&quot;</span>' + 
-    '<span class="content">Hello, World!</span><span class="delimiter">&quot;</span></span>'
-  def test_simple_highlight
-    assert_nothing_raised do
-      assert_equal RUBY_TEST_HTML, CodeRay.scan(RUBY_TEST_CODE, :ruby).html
-    end
-  end
-  
-  def test_scan_file
-    CodeRay.scan_file __FILE__
-  end
-  
-  def test_encode
-    assert_equal 1, CodeRay.encode('test', :python, :count)
-  end
-  
-  def test_encode_tokens
-    assert_equal 1, CodeRay.encode_tokens(CodeRay::Tokens['test', :string], :count)
-  end
-  
-  def test_encode_file
-    assert_equal File.read(__FILE__), CodeRay.encode_file(__FILE__, :text)
-  end
-  
-  def test_highlight
-    assert_match '<pre>test</pre>', CodeRay.highlight('test', :python)
-  end
-  
-  def test_highlight_file
-    assert_match "require <span class=\"string\"><span class=\"delimiter\">'</span><span class=\"content\">test/unit</span><span class=\"delimiter\">'</span></span>\n", CodeRay.highlight_file(__FILE__)
-  end
-  
-  def test_duo
-    assert_equal(RUBY_TEST_CODE,
-      CodeRay::Duo[:plain, :text].highlight(RUBY_TEST_CODE))
-    assert_equal(RUBY_TEST_CODE,
-      CodeRay::Duo[:plain => :text].highlight(RUBY_TEST_CODE))
-  end
-  
-  def test_duo_stream
-    assert_equal(RUBY_TEST_CODE,
-      CodeRay::Duo[:plain, :text].highlight(RUBY_TEST_CODE, :stream => true))
-  end
-  
-  def test_comment_filter
-    assert_equal <<-EXPECTED, CodeRay.scan(<<-INPUT, :ruby).comment_filter.text
-#!/usr/bin/env ruby
-
-code
-
-more code  
-      EXPECTED
-#!/usr/bin/env ruby
-=begin
-A multi-line comment.
-=end
-code
-# A single-line comment.
-more code  # and another comment, in-line.
-      INPUT
-  end
-  
-  def test_lines_of_code
-    assert_equal 2, CodeRay.scan(<<-INPUT, :ruby).lines_of_code
-#!/usr/bin/env ruby
-=begin
-A multi-line comment.
-=end
-code
-# A single-line comment.
-more code  # and another comment, in-line.
-      INPUT
-    rHTML = <<-RHTML
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
-  <title><%= controller.controller_name.titleize %>: <%= controller.action_name %></title>
-  <%= stylesheet_link_tag 'scaffold' %>
-</head>
-<body>
-
-<p style="color: green"><%= flash[:notice] %></p>
-
-<div id="main">
-  <%= yield %>
-</div>
-
-</body>
-</html>
-      RHTML
-    assert_equal 0, CodeRay.scan(rHTML, :html).lines_of_code
-    assert_equal 0, CodeRay.scan(rHTML, :php).lines_of_code
-    assert_equal 0, CodeRay.scan(rHTML, :yaml).lines_of_code
-    assert_equal 4, CodeRay.scan(rHTML, :erb).lines_of_code
-  end
-  
-  def test_list_of_encoders
-    assert_kind_of(Array, CodeRay::Encoders.list)
-    assert CodeRay::Encoders.list.include?(:count)
-  end
-  
-  def test_list_of_scanners
-    assert_kind_of(Array, CodeRay::Scanners.list)
-    assert CodeRay::Scanners.list.include?(:text)
-  end
-  
-  def test_token_kinds
-    assert_kind_of Hash, CodeRay::TokenKinds
-    for kind, css_class in CodeRay::TokenKinds
-      assert_kind_of Symbol, kind
-      if css_class != false
-        assert_kind_of String, css_class, "TokenKinds[%p] == %p" % [kind, css_class]
-      end
-    end
-    assert_equal 'reserved', CodeRay::TokenKinds[:reserved]
-    assert_equal false,      CodeRay::TokenKinds[:shibboleet]
-  end
-  
-  class Milk < CodeRay::Encoders::Encoder
-    FILE_EXTENSION = 'cocoa'
-  end
-  
-  class HoneyBee < CodeRay::Encoders::Encoder
-  end
-  
-  def test_encoder_file_extension
-    assert_nothing_raised do
-      assert_equal 'html', CodeRay::Encoders::Page::FILE_EXTENSION
-      assert_equal 'cocoa', Milk::FILE_EXTENSION
-      assert_equal 'cocoa', Milk.new.file_extension
-      assert_equal 'honeybee', HoneyBee::FILE_EXTENSION
-      assert_equal 'honeybee', HoneyBee.new.file_extension
-    end
-    assert_raise NameError do
-      HoneyBee::MISSING_CONSTANT
-    end
-  end
-  
-  def test_encoder_tokens
-    encoder = CodeRay::Encoders::Encoder.new
-    encoder.send :setup, {}
-    assert_raise(ArgumentError) { encoder.token :strange, '' }
-    encoder.token 'test', :debug
-  end
-  
-  def test_encoder_deprecated_interface
-    encoder = CodeRay::Encoders::Encoder.new
-    encoder.send :setup, {}
-    assert_warning 'Using old Tokens#<< interface.' do
-      encoder << ['test', :content]
-    end
-    assert_raise ArgumentError do
-      encoder << [:strange, :input]
-    end
-    assert_raise ArgumentError do
-      encoder.encode_tokens [['test', :token]]
-    end
-  end
-  
-  def encoder_token_interface_deprecation_warning_given
-    CodeRay::Encoders::Encoder.send :class_variable_get, :@@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN
-  end
-  
-  def test_scanner_file_extension
-    assert_equal 'rb', CodeRay::Scanners::Ruby.file_extension
-    assert_equal 'rb', CodeRay::Scanners::Ruby.new.file_extension
-    assert_equal 'java', CodeRay::Scanners::Java.file_extension
-    assert_equal 'java', CodeRay::Scanners::Java.new.file_extension
-  end
-  
-  def test_scanner_lang
-    assert_equal :ruby, CodeRay::Scanners::Ruby.lang
-    assert_equal :ruby, CodeRay::Scanners::Ruby.new.lang
-    assert_equal :java, CodeRay::Scanners::Java.lang
-    assert_equal :java, CodeRay::Scanners::Java.new.lang
-  end
-  
-  def test_scanner_tokenize
-    assert_equal ['foo', :plain], CodeRay::Scanners::Plain.new.tokenize('foo')
-    assert_equal [['foo', :plain], ['bar', :plain]], CodeRay::Scanners::Plain.new.tokenize(['foo', 'bar'])
-    CodeRay::Scanners::Plain.new.tokenize 42
-  end
-  
-  def test_scanner_tokens
-    scanner = CodeRay::Scanners::Plain.new
-    scanner.tokenize('foo')
-    assert_equal ['foo', :plain], scanner.tokens
-    scanner.string = ''
-    assert_equal ['', :plain], scanner.tokens
-  end
-  
-  def test_scanner_line_and_column
-    scanner = CodeRay::Scanners::Plain.new "foo\nbär+quux"
-    assert_equal 0, scanner.pos
-    assert_equal 1, scanner.line
-    assert_equal 1, scanner.column
-    scanner.scan(/foo/)
-    assert_equal 3, scanner.pos
-    assert_equal 1, scanner.line
-    assert_equal 4, scanner.column
-    scanner.scan(/\n/)
-    assert_equal 4, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 1, scanner.column
-    scanner.scan(/b/)
-    assert_equal 5, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 2, scanner.column
-    scanner.scan(/a/)
-    assert_equal 5, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 2, scanner.column
-    scanner.scan(/ä/)
-    assert_equal 7, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 4, scanner.column
-    scanner.scan(/r/)
-    assert_equal 8, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 5, scanner.column
-  end
-  
-  def test_scanner_use_subclasses
-    assert_raise NotImplementedError do
-      CodeRay::Scanners::Scanner.new
-    end
-  end
-  
-  class InvalidScanner < CodeRay::Scanners::Scanner
-  end
-  
-  def test_scanner_scan_tokens
-    assert_raise NotImplementedError do
-      InvalidScanner.new.tokenize ''
-    end
-  end
-  
-  class RaisingScanner < CodeRay::Scanners::Scanner
-    def scan_tokens encoder, options
-      raise_inspect 'message', [], :initial
-    end
-  end
-  
-  def test_scanner_raise_inspect
-    assert_raise CodeRay::Scanners::Scanner::ScanError do
-      RaisingScanner.new.tokenize ''
-    end
-  end
-  
-  def test_scan_a_frozen_string
-    assert_nothing_raised do
-      CodeRay.scan RUBY_VERSION, :ruby
-      CodeRay.scan RUBY_VERSION, :plain
-    end
-  end
-  
-  def test_scan_a_non_string
-    assert_nothing_raised do
-      CodeRay.scan 42, :ruby
-      CodeRay.scan nil, :ruby
-      CodeRay.scan self, :ruby
-      CodeRay.encode ENV.to_hash, :ruby, :page
-      CodeRay.highlight CodeRay, :plain
-    end
-  end
-  
-end