typo 5.1.3 → 5.1.98

data/vendor/gems/coderay-0.8.260/lib/coderay/helpers/plugin.rb

@@ -0,0 +1,333 @@
+module CodeRay
+  
+# = PluginHost
+#
+# $Id: plugin.rb 255 2008-09-21 16:25:44Z murphy $
+#
+# A simple subclass plugin system.
+#
+#  Example:
+#    class Generators < PluginHost
+#      plugin_path 'app/generators'
+#    end
+#    
+#    class Generator
+#      extend Plugin
+#      PLUGIN_HOST = Generators
+#    end
+#    
+#    class FancyGenerator < Generator
+#      register_for :fancy
+#    end
+#
+#    Generators[:fancy]  #-> FancyGenerator
+#    # or
+#    CodeRay.require_plugin 'Generators/fancy'
+module PluginHost
+
+  # Raised if Encoders::[] fails because:
+  # * a file could not be found
+  # * the requested Encoder is not registered
+  PluginNotFound = Class.new Exception
+  HostNotFound = Class.new Exception
+
+  PLUGIN_HOSTS = []
+  PLUGIN_HOSTS_BY_ID = {}  # dummy hash
+
+  # Loads all plugins using list and load.
+  def load_all
+    for plugin in list
+      load plugin
+    end
+  end
+
+  # Returns the Plugin for +id+.
+  #
+  # Example:
+  #  yaml_plugin = MyPluginHost[:yaml]
+  def [] id, *args, &blk
+    plugin = validate_id(id)
+    begin
+      plugin = plugin_hash.[] plugin, *args, &blk
+    end while plugin.is_a? Symbol
+    plugin
+  end
+
+  # Alias for +[]+.
+  alias load []
+
+  def require_helper plugin_id, helper_name
+    path = path_to File.join(plugin_id, helper_name)
+    require path
+  end
+
+  class << self
+
+    # Adds the module/class to the PLUGIN_HOSTS list.
+    def extended mod
+      PLUGIN_HOSTS << mod
+    end
+
+    # Warns you that you should not #include this module.
+    def included mod
+      warn "#{name} should not be included. Use extend."
+    end
+
+    # Find the PluginHost for host_id.
+    def host_by_id host_id
+      unless PLUGIN_HOSTS_BY_ID.default_proc
+        ph = Hash.new do |h, a_host_id|
+          for host in PLUGIN_HOSTS
+            h[host.host_id] = host
+          end
+          h.fetch a_host_id, nil
+        end
+        PLUGIN_HOSTS_BY_ID.replace ph
+      end
+      PLUGIN_HOSTS_BY_ID[host_id]
+    end
+
+  end
+
+  # The path where the plugins can be found.
+  def plugin_path *args
+    unless args.empty?
+      @plugin_path = File.expand_path File.join(*args)
+      load_map
+    end
+    @plugin_path
+  end
+
+  # The host's ID.
+  #
+  # If PLUGIN_HOST_ID is not set, it is simply the class name.
+  def host_id
+    if self.const_defined? :PLUGIN_HOST_ID
+      self::PLUGIN_HOST_ID
+    else
+      name
+    end
+  end
+
+  # Map a plugin_id to another.
+  #
+  # Usage: Put this in a file plugin_path/_map.rb.
+  #
+  #  class MyColorHost < PluginHost
+  #    map :navy => :dark_blue,
+  #      :maroon => :brown,
+  #      :luna => :moon
+  #  end
+  def map hash
+    for from, to in hash
+      from = validate_id from
+      to = validate_id to
+      plugin_hash[from] = to unless plugin_hash.has_key? from
+    end
+  end
+
+  # Define the default plugin to use when no plugin is found
+  # for a given id.
+  #
+  # See also map.
+  #
+  #  class MyColorHost < PluginHost
+  #    map :navy => :dark_blue
+  #    default :gray
+  #  end
+  def default id = nil
+    if id
+      id = validate_id id
+      plugin_hash[nil] = id
+    else
+      plugin_hash[nil]
+    end
+  end
+
+  # Every plugin must register itself for one or more
+  # +ids+ by calling register_for, which calls this method.
+  #
+  # See Plugin#register_for.
+  def register plugin, *ids
+    for id in ids
+      unless id.is_a? Symbol
+        raise ArgumentError,
+          "id must be a Symbol, but it was a #{id.class}"
+      end
+      plugin_hash[validate_id(id)] = plugin
+    end
+  end
+
+  # A Hash of plugion_id => Plugin pairs.
+  def plugin_hash
+    @plugin_hash ||= create_plugin_hash
+  end
+
+  # Returns an array of all .rb files in the plugin path.
+  #
+  # The extension .rb is not included.
+  def list
+    Dir[path_to('*')].select do |file|
+      File.basename(file)[/^(?!_)\w+\.rb$/]
+    end.map do |file|
+      File.basename file, '.rb'
+    end
+  end
+
+  # Makes a map of all loaded plugins.
+  def inspect
+    map = plugin_hash.dup
+    map.each do |id, plugin|
+      map[id] = plugin.to_s[/(?>[\w_]+)$/]
+    end
+    "#{name}[#{host_id}]#{map.inspect}"
+  end
+
+protected
+  # Created a new plugin list and stores it to @plugin_hash.
+  def create_plugin_hash
+    @plugin_hash =
+      Hash.new do |h, plugin_id|
+        id = validate_id(plugin_id)
+        path = path_to id
+        begin
+          require path
+        rescue LoadError => boom
+          if h.has_key? nil  # default plugin
+            h[id] = h[nil]
+          else
+            raise PluginNotFound, 'Could not load plugin %p: %s' % [id, boom]
+          end
+        else
+          # Plugin should have registered by now
+          unless h.has_key? id
+            raise PluginNotFound,
+              "No #{self.name} plugin for #{id.inspect} found in #{path}."
+          end
+        end
+        h[id]
+      end
+  end
+
+  # Loads the map file (see map).
+  #
+  # This is done automatically when plugin_path is called.
+  def load_map
+    mapfile = path_to '_map'
+    if File.exist? mapfile
+      require mapfile
+    elsif $DEBUG
+      warn 'no _map.rb found for %s' % name
+    end
+  end
+
+  # Returns the Plugin for +id+.
+  # Use it like Hash#fetch.
+  #
+  # Example:
+  #  yaml_plugin = MyPluginHost[:yaml, :default]
+  def fetch id, *args, &blk
+    plugin_hash.fetch validate_id(id), *args, &blk
+  end
+
+  # Returns the expected path to the plugin file for the given id.
+  def path_to plugin_id
+    File.join plugin_path, "#{plugin_id}.rb"
+  end
+
+  # Converts +id+ to a Symbol if it is a String,
+  # or returns +id+ if it already is a Symbol.
+  #
+  # Raises +ArgumentError+ for all other objects, or if the
+  # given String includes non-alphanumeric characters (\W).
+  def validate_id id
+    if id.is_a? Symbol or id.nil?
+      id
+    elsif id.is_a? String
+      if id[/\w+/] == id
+        id.to_sym
+      else
+        raise ArgumentError, "Invalid id: '#{id}' given."
+      end
+    else
+      raise ArgumentError,
+        "String or Symbol expected, but #{id.class} given."
+    end
+  end
+
+end
+
+
+# = Plugin
+#
+#  Plugins have to include this module.
+#
+#  IMPORTANT: use extend for this module.
+#
+#  Example: see PluginHost.
+module Plugin
+
+  def included mod
+    warn "#{name} should not be included. Use extend."
+  end
+
+  # Register this class for the given langs.
+  # Example:
+  #   class MyPlugin < PluginHost::BaseClass
+  #     register_for :my_id
+  #     ...
+  #   end
+  #
+  # See PluginHost.register.
+  def register_for *ids
+    plugin_host.register self, *ids
+  end
+
+  # The host for this Plugin class.
+  def plugin_host host = nil
+    if host and not host.is_a? PluginHost
+      raise ArgumentError,
+        "PluginHost expected, but #{host.class} given."
+    end
+    self.const_set :PLUGIN_HOST, host if host
+    self::PLUGIN_HOST
+  end
+
+  # Require some helper files.
+  #
+  # Example:
+  #
+  #  class MyPlugin < PluginHost::BaseClass
+  #     register_for :my_id
+  #     helper :my_helper
+  #
+  # The above example loads the file myplugin/my_helper.rb relative to the
+  # file in which MyPlugin was defined.
+  def helper *helpers
+    for helper in helpers
+      self::PLUGIN_HOST.require_helper plugin_id, helper.to_s
+    end
+  end
+
+  # Returns the pulgin id used by the engine.
+  def plugin_id
+    name[/[\w_]+$/].downcase
+  end
+
+end
+
+# Convenience method for plugin loading.
+# The syntax used is:
+#
+#  CodeRay.require_plugin '<Host ID>/<Plugin ID>'
+#
+# Returns the loaded plugin.
+def self.require_plugin path
+  host_id, plugin_id = path.split '/', 2
+  host = PluginHost.host_by_id(host_id)
+  raise PluginHost::HostNotFound,
+    "No host for #{host_id.inspect} found." unless host
+  host.load plugin_id
+end
+
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/helpers/word_list.rb

@@ -0,0 +1,123 @@
+module CodeRay
+
+# = WordList
+# 
+# <b>A Hash subclass designed for mapping word lists to token types.</b>
+# 
+# Copyright (c) 2006 by murphy (Kornelius Kalnbach) <murphy rubychan de>
+#
+# License:: LGPL / ask the author
+# Version:: 1.1 (2006-Oct-19)
+#
+# A WordList is a Hash with some additional features.
+# It is intended to be used for keyword recognition.
+#
+# WordList is highly optimized to be used in Scanners,
+# typically to decide whether a given ident is a special token.
+#
+# For case insensitive words use CaseIgnoringWordList.
+#
+# Example:
+#
+#  # define word arrays
+#  RESERVED_WORDS = %w[
+#    asm break case continue default do else
+#    ...
+#  ]
+#  
+#  PREDEFINED_TYPES = %w[
+#    int long short char void
+#    ...
+#  ]
+#  
+#  PREDEFINED_CONSTANTS = %w[
+#    EOF NULL ...
+#  ]
+#  
+#  # make a WordList
+#  IDENT_KIND = WordList.new(:ident).
+#    add(RESERVED_WORDS, :reserved).
+#    add(PREDEFINED_TYPES, :pre_type).
+#    add(PREDEFINED_CONSTANTS, :pre_constant)
+#
+#  ...
+#
+#  def scan_tokens tokens, options
+#    ...
+#    
+#    elsif scan(/[A-Za-z_][A-Za-z_0-9]*/)
+#      # use it
+#      kind = IDENT_KIND[match]
+#      ...
+class WordList < Hash
+
+  # Creates a new WordList with +default+ as default value.
+  # 
+  # You can activate +caching+ to store the results for every [] request.
+  # 
+  # With caching, methods like +include?+ or +delete+ may no longer behave
+  # as you expect. Therefore, it is recommended to use the [] method only.
+  def initialize default = false, caching = false, &block
+    if block
+      raise ArgumentError, 'Can\'t combine block with caching.' if caching
+      super(&block)
+    else
+      if caching
+        super() do |h, k|
+          h[k] = h.fetch k, default
+        end
+      else
+        super default
+      end
+    end
+  end
+
+  # Add words to the list and associate them with +kind+.
+  # 
+  # Returns +self+, so you can concat add calls.
+  def add words, kind = true
+    words.each do |word|
+      self[word] = kind
+    end
+    self
+  end
+
+end
+
+
+# A CaseIgnoringWordList is like a WordList, only that
+# keys are compared case-insensitively.
+# 
+# Ignoring the text case is realized by sending the +downcase+ message to
+# all keys.
+# 
+# Caching usually makes a CaseIgnoringWordList faster, but it has to be
+# activated explicitely.
+class CaseIgnoringWordList < WordList
+
+  # Creates a new case-insensitive WordList with +default+ as default value.
+  # 
+  # You can activate caching to store the results for every [] request.
+  def initialize default = false, caching = false
+    if caching
+      super(default, false) do |h, k|
+        h[k] = h.fetch k.downcase, default
+      end
+    else
+      def self.[] key  # :nodoc:
+        super(key.downcase)
+      end
+    end
+  end
+
+  # Add +words+ to the list and associate them with +kind+.
+  def add words, kind = true
+    words.each do |word|
+      self[word.downcase] = kind
+    end
+    self
+  end
+
+end
+
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/scanner.rb

@@ -0,0 +1,255 @@
+module CodeRay
+
+  require 'coderay/helpers/plugin'
+
+  # = Scanners
+  #
+  # $Id: scanner.rb 253 2008-09-16 22:07:44Z murphy $
+  #
+  # This module holds the Scanner class and its subclasses.
+  # For example, the Ruby scanner is named CodeRay::Scanners::Ruby
+  # can be found in coderay/scanners/ruby.
+  #
+  # Scanner also provides methods and constants for the register
+  # mechanism and the [] method that returns the Scanner class
+  # belonging to the given lang.
+  #
+  # See PluginHost.
+  module Scanners
+    extend PluginHost
+    plugin_path File.dirname(__FILE__), 'scanners'
+
+    require 'strscan'
+
+    # = Scanner
+    #
+    # The base class for all Scanners.
+    #
+    # It is a subclass of Ruby's great +StringScanner+, which
+    # makes it easy to access the scanning methods inside.
+    #
+    # It is also +Enumerable+, so you can use it like an Array of
+    # Tokens:
+    #
+    #   require 'coderay'
+    #   
+    #   c_scanner = CodeRay::Scanners[:c].new "if (*p == '{') nest++;"
+    #   
+    #   for text, kind in c_scanner
+    #     puts text if kind == :operator
+    #   end
+    #   
+    #   # prints: (*==)++;
+    #
+    # OK, this is a very simple example :)
+    # You can also use +map+, +any?+, +find+ and even +sort_by+,
+    # if you want.
+    class Scanner < StringScanner
+      extend Plugin
+      plugin_host Scanners
+
+      # Raised if a Scanner fails while scanning
+      ScanError = Class.new(Exception)
+
+      require 'coderay/helpers/word_list'
+
+      # The default options for all scanner classes.
+      #
+      # Define @default_options for subclasses.
+      DEFAULT_OPTIONS = { :stream => false }
+
+      class << self
+
+        # Returns if the Scanner can be used in streaming mode.
+        def streamable?
+          is_a? Streamable
+        end
+
+        def normify code
+          code = code.to_s
+          code.force_encoding 'binary' if code.respond_to? :force_encoding
+          code.to_unix
+        end
+        
+        def file_extension extension = nil
+          if extension
+            @file_extension = extension.to_s
+          else
+            @file_extension ||= plugin_id.to_s
+          end
+        end
+
+      end
+
+=begin
+## Excluded for speed reasons; protected seems to make methods slow.
+
+  # Save the StringScanner methods from being called.
+  # This would not be useful for highlighting.
+  strscan_public_methods =
+    StringScanner.instance_methods -
+    StringScanner.ancestors[1].instance_methods
+  protected(*strscan_public_methods)
+=end
+
+      # Create a new Scanner.
+      #
+      # * +code+ is the input String and is handled by the superclass
+      #   StringScanner.
+      # * +options+ is a Hash with Symbols as keys.
+      #   It is merged with the default options of the class (you can
+      #   overwrite default options here.)
+      # * +block+ is the callback for streamed highlighting.
+      #
+      # If you set :stream to +true+ in the options, the Scanner uses a
+      # TokenStream with the +block+ as callback to handle the tokens.
+      #
+      # Else, a Tokens object is used.
+      def initialize code='', options = {}, &block
+        @options = self.class::DEFAULT_OPTIONS.merge options
+        raise "I am only the basic Scanner class. I can't scan "\
+          "anything. :( Use my subclasses." if self.class == Scanner
+
+        super Scanner.normify(code)
+
+        @tokens = options[:tokens]
+        if @options[:stream]
+          warn "warning in CodeRay::Scanner.new: :stream is set, "\
+            "but no block was given" unless block_given?
+          raise NotStreamableError, self unless kind_of? Streamable
+          @tokens ||= TokenStream.new(&block)
+        else
+          warn "warning in CodeRay::Scanner.new: Block given, "\
+            "but :stream is #{@options[:stream]}" if block_given?
+          @tokens ||= Tokens.new
+        end
+
+        setup
+      end
+
+      def reset
+        super
+        reset_instance
+      end
+
+      def string= code
+        code = Scanner.normify(code)
+        super code
+        reset_instance
+      end
+
+      # More mnemonic accessor name for the input string.
+      alias code string
+      alias code= string=
+
+      # Scans the code and returns all tokens in a Tokens object.
+      def tokenize new_string=nil, options = {}
+        options = @options.merge(options)
+        self.string = new_string if new_string
+        @cached_tokens =
+          if @options[:stream]  # :stream must have been set already
+            reset unless new_string
+            scan_tokens @tokens, options
+            @tokens
+          else
+            scan_tokens @tokens, options
+          end
+      end
+
+      def tokens
+        @cached_tokens ||= tokenize
+      end
+      
+      # Whether the scanner is in streaming mode.
+      def streaming?
+        !!@options[:stream]
+      end
+
+      # Traverses the tokens.
+      def each &block
+        raise ArgumentError,
+          'Cannot traverse TokenStream.' if @options[:stream]
+        tokens.each(&block)
+      end
+      include Enumerable
+
+      # The current line position of the scanner.
+      #
+      # Beware, this is implemented inefficiently. It should be used
+      # for debugging only.
+      def line
+        string[0..pos].count("\n") + 1
+      end
+
+    protected
+
+      # Can be implemented by subclasses to do some initialization
+      # that has to be done once per instance.
+      #
+      # Use reset for initialization that has to be done once per
+      # scan.
+      def setup
+      end
+
+      # This is the central method, and commonly the only one a
+      # subclass implements.
+      #
+      # Subclasses must implement this method; it must return +tokens+
+      # and must only use Tokens#<< for storing scanned tokens!
+      def scan_tokens tokens, options
+        raise NotImplementedError,
+          "#{self.class}#scan_tokens not implemented."
+      end
+
+      def reset_instance
+        @tokens.clear unless @options[:keep_tokens]
+        @cached_tokens = nil
+      end
+
+      # Scanner error with additional status information
+      def raise_inspect msg, tokens, state = 'No state given!', ambit = 30
+        raise ScanError, <<-EOE % [
+
+
+***ERROR in %s: %s (after %d tokens)
+
+tokens:
+%s
+
+current line: %d  pos = %d
+matched: %p  state: %p
+bol? = %p,  eos? = %p
+
+surrounding code:
+%p  ~~  %p
+
+
+***ERROR***
+
+        EOE
+          File.basename(caller[0]),
+          msg,
+          tokens.size,
+          tokens.last(10).map { |t| t.inspect }.join("\n"),
+          line, pos,
+          matched, state, bol?, eos?,
+          string[pos-ambit,ambit],
+          string[pos,ambit],
+        ]
+      end
+
+    end
+
+  end
+end
+
+class String
+  # I love this hack. It seems to silence all dos/unix/mac newline problems.
+  def to_unix
+    if index ?\r
+      gsub(/\r\n?/, "\n")
+    else
+      self
+    end
+  end
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/scanners/_map.rb

@@ -0,0 +1,15 @@
+module CodeRay
+module Scanners
+
+  map :cpp => :c,
+    :plain => :plaintext,
+    :pascal => :delphi,
+    :irb => :ruby,
+    :xhtml => :nitro_xhtml,
+    :javascript => :java_script,
+    :nitro => :nitro_xhtml
+
+  default :plain
+
+end
+end