llm-shell 0.10.0 → 0.11.0

data/lib/llm/shell/internal/coderay/lib/coderay/encoders/terminal.rb

@@ -1,195 +0,0 @@
-module CodeRay
-  module Encoders
-    
-    # Outputs code highlighted for a color terminal.
-    # 
-    # Note: This encoder is in beta. It currently doesn't use the Styles.
-    # 
-    # Alias: +term+
-    # 
-    # == Authors & License
-    # 
-    # By Rob Aldred (http://robaldred.co.uk)
-    # 
-    # Based on idea by Nathan Weizenbaum (http://nex-3.com)
-    # 
-    # MIT License (http://www.opensource.org/licenses/mit-license.php)
-    class Terminal < Encoder
-      
-      register_for :terminal
-      
-      TOKEN_COLORS = {
-        :debug => "\e[1;37;44m",
-        
-        :annotation => "\e[34m",
-        :attribute_name => "\e[35m",
-        :attribute_value => "\e[31m",
-        :binary => {
-          :self => "\e[31m",
-          :char => "\e[1;31m",
-          :delimiter => "\e[1;31m",
-        },
-        :char => {
-          :self => "\e[35m",
-          :delimiter => "\e[1;35m"
-        },
-        :class => "\e[1;35;4m",
-        :class_variable => "\e[36m",
-        :color => "\e[32m",
-        :comment => {
-          :self => "\e[1;30m",
-          :char => "\e[37m",
-          :delimiter => "\e[37m",
-        },
-        :constant => "\e[1;34;4m",
-        :decorator => "\e[35m",
-        :definition => "\e[1;33m",
-        :directive => "\e[33m",
-        :docstring => "\e[31m",
-        :doctype => "\e[1;34m",
-        :done => "\e[1;30;2m",
-        :entity => "\e[31m",
-        :error => "\e[1;37;41m",
-        :exception => "\e[1;31m",
-        :float => "\e[1;35m",
-        :function => "\e[1;34m",
-        :global_variable => "\e[1;32m",
-        :hex => "\e[1;36m",
-        :id => "\e[1;34m",
-        :include => "\e[31m",
-        :integer => "\e[1;34m",
-        :imaginary => "\e[1;34m",
-        :important => "\e[1;31m",
-        :key => {
-          :self => "\e[35m",
-          :char => "\e[1;35m",
-          :delimiter => "\e[1;35m",
-        },
-        :keyword => "\e[32m",
-        :label => "\e[1;33m",
-        :local_variable => "\e[33m",
-        :namespace => "\e[1;35m",
-        :octal => "\e[1;34m",
-        :predefined => "\e[36m",
-        :predefined_constant => "\e[1;36m",
-        :predefined_type => "\e[1;32m",
-        :preprocessor => "\e[1;36m",
-        :pseudo_class => "\e[1;34m",
-        :regexp => {
-          :self => "\e[35m",
-          :delimiter => "\e[1;35m",
-          :modifier => "\e[35m",
-          :char => "\e[1;35m",
-        },
-        :reserved => "\e[32m",
-        :shell => {
-          :self => "\e[33m",
-          :char => "\e[1;33m",
-          :delimiter => "\e[1;33m",
-          :escape => "\e[1;33m",
-        },
-        :string => {
-          :self => "\e[31m",
-          :modifier => "\e[1;31m",
-          :char => "\e[1;35m",
-          :delimiter => "\e[1;31m",
-          :escape => "\e[1;31m",
-        },
-        :symbol => {
-          :self => "\e[33m",
-          :delimiter => "\e[1;33m",
-        },
-        :tag => "\e[32m",
-        :type => "\e[1;34m",
-        :value => "\e[36m",
-        :variable => "\e[34m",
-        
-        :insert => {
-          :self => "\e[42m",
-          :insert => "\e[1;32;42m",
-          :eyecatcher => "\e[102m",
-        },
-        :delete => {
-          :self => "\e[41m",
-          :delete => "\e[1;31;41m",
-          :eyecatcher => "\e[101m",
-        },
-        :change => {
-          :self => "\e[44m",
-          :change => "\e[37;44m",
-        },
-        :head => {
-          :self => "\e[45m",
-          :filename => "\e[37;45m"
-        },
-      }
-      
-      TOKEN_COLORS[:keyword] = TOKEN_COLORS[:reserved]
-      TOKEN_COLORS[:method] = TOKEN_COLORS[:function]
-      TOKEN_COLORS[:escape] = TOKEN_COLORS[:delimiter]
-      
-    protected
-      
-      def setup(options)
-        super
-        @opened = []
-        @color_scopes = [TOKEN_COLORS]
-      end
-      
-    public
-      
-      def text_token text, kind
-        if color = @color_scopes.last[kind]
-          color = color[:self] if color.is_a? Hash
-          
-          @out << color
-          @out << (text.index("\n") ? text.gsub("\n", "\e[0m\n" + color) : text)
-          @out << "\e[0m"
-          if outer_color = @color_scopes.last[:self]
-            @out << outer_color
-          end
-        else
-          @out << text
-        end
-      end
-      
-      def begin_group kind
-        @opened << kind
-        @out << open_token(kind)
-      end
-      alias begin_line begin_group
-      
-      def end_group kind
-        if @opened.pop
-          @color_scopes.pop
-          @out << "\e[0m"
-          if outer_color = @color_scopes.last[:self]
-            @out << outer_color
-          end
-        end
-      end
-      
-      def end_line kind
-        @out << (@line_filler ||= "\t" * 100)
-        end_group kind
-      end
-      
-    private
-      
-      def open_token kind
-        if color = @color_scopes.last[kind]
-          if color.is_a? Hash
-            @color_scopes << color
-            color[:self]
-          else
-            @color_scopes << @color_scopes.last
-            color
-          end
-        else
-          @color_scopes << @color_scopes.last
-          ''
-        end
-      end
-    end
-  end
-end

data/lib/llm/shell/internal/coderay/lib/coderay/encoders/text.rb

@@ -1,46 +0,0 @@
-module CodeRay
-module Encoders
-  
-  # Concats the tokens into a single string, resulting in the original
-  # code string if no tokens were removed.
-  # 
-  # Alias: +plain+, +plaintext+
-  # 
-  # == Options
-  # 
-  # === :separator
-  # A separator string to join the tokens.
-  # 
-  # Default: empty String
-  class Text < Encoder
-    
-    register_for :text
-    
-    FILE_EXTENSION = 'txt'
-    
-    DEFAULT_OPTIONS = {
-      :separator => nil
-    }
-    
-    def text_token text, kind
-      super
-      
-      if @first
-        @first = false
-      else
-        @out << @sep
-      end if @sep
-    end
-    
-  protected
-    def setup options
-      super
-      
-      @first = true
-      @sep = options[:separator]
-    end
-    
-  end
-  
-end
-end

data/lib/llm/shell/internal/coderay/lib/coderay/encoders/token_kind_filter.rb

@@ -1,111 +0,0 @@
-module CodeRay
-module Encoders
-  
-  load :filter
-  
-  # A Filter that selects tokens based on their token kind.
-  # 
-  # == Options
-  # 
-  # === :exclude
-  # 
-  # One or many symbols (in an Array) which shall be excluded.
-  # 
-  # Default: []
-  # 
-  # === :include
-  # 
-  # One or many symbols (in an array) which shall be included.
-  # 
-  # Default: :all, which means all tokens are included.
-  # 
-  # Exclusion wins over inclusion.
-  # 
-  # See also: CommentFilter
-  class TokenKindFilter < Filter
-    
-    register_for :token_kind_filter
-    
-    DEFAULT_OPTIONS = {
-      :exclude => [],
-      :include => :all
-    }
-    
-  protected
-    def setup options
-      super
-      
-      @group_excluded = false
-      @exclude = options[:exclude]
-      @exclude = Array(@exclude) unless @exclude == :all
-      @include = options[:include]
-      @include = Array(@include) unless @include == :all
-    end
-    
-    def include_text_token? text, kind
-      include_group? kind
-    end
-    
-    def include_group? kind
-       (@include == :all || @include.include?(kind)) &&
-      !(@exclude == :all || @exclude.include?(kind))
-    end
-    
-  public
-    
-    # Add the token to the output stream if +kind+ matches the conditions.
-    def text_token text, kind
-      super if !@group_excluded && include_text_token?(text, kind)
-    end
-    
-    # Add the token group to the output stream if +kind+ matches the
-    # conditions.
-    # 
-    # If it does not, all tokens inside the group are excluded from the
-    # stream, even if their kinds match.
-    def begin_group kind
-      if @group_excluded
-        @group_excluded += 1
-      elsif include_group? kind
-        super
-      else
-        @group_excluded = 1
-      end
-    end
-    
-    # See +begin_group+.
-    def begin_line kind
-      if @group_excluded
-        @group_excluded += 1
-      elsif include_group? kind
-        super
-      else
-        @group_excluded = 1
-      end
-    end
-    
-    # Take care of re-enabling the delegation of tokens to the output stream
-    # if an exluded group has ended.
-    def end_group kind
-      if @group_excluded
-        @group_excluded -= 1
-        @group_excluded = false if @group_excluded.zero?
-      else
-        super
-      end
-    end
-    
-    # See +end_group+.
-    def end_line kind
-      if @group_excluded
-        @group_excluded -= 1
-        @group_excluded = false if @group_excluded.zero?
-      else
-        super
-      end
-    end
-    
-  end
-  
-end
-end

data/lib/llm/shell/internal/coderay/lib/coderay/encoders/xml.rb

@@ -1,72 +0,0 @@
-module CodeRay
-module Encoders
-  
-  # = XML Encoder
-  #
-  # Uses REXML. Very slow.
-  class XML < Encoder
-    
-    register_for :xml
-    
-    FILE_EXTENSION = 'xml'
-    
-    autoload :REXML, 'rexml/document'
-    
-    DEFAULT_OPTIONS = {
-      :tab_width => 8,
-      :pretty => -1,
-      :transitive => false,
-    }
-    
-  protected
-    def setup options
-      super
-      
-      @doc = REXML::Document.new
-      @doc << REXML::XMLDecl.new
-      @tab_width = options[:tab_width]
-      @root = @node = @doc.add_element('coderay-tokens')
-    end
-    
-    def finish options
-      @doc.write @out, options[:pretty], options[:transitive], true
-      
-      super
-    end
-    
-  public
-    def text_token text, kind
-      if kind == :space
-        token = @node
-      else
-        token = @node.add_element kind.to_s
-      end
-      text.scan(/(\x20+)|(\t+)|(\n)|[^\x20\t\n]+/) do |space, tab, nl|
-        case
-        when space
-          token << REXML::Text.new(space, true)
-        when tab
-          token << REXML::Text.new(tab, true)
-        when nl
-          token << REXML::Text.new(nl, true)
-        else
-          token << REXML::Text.new($&)
-        end
-      end
-    end
-    
-    def begin_group kind
-      @node = @node.add_element kind.to_s
-    end
-    
-    def end_group kind
-      if @node == @root
-        raise 'no token to close!'
-      end
-      @node = @node.parent
-    end
-    
-  end
-  
-end
-end

data/lib/llm/shell/internal/coderay/lib/coderay/encoders/yaml.rb

@@ -1,50 +0,0 @@
-autoload :YAML, 'yaml'
-
-module CodeRay
-module Encoders
-  
-  # = YAML Encoder
-  #
-  # Slow.
-  class YAML < Encoder
-    
-    register_for :yaml
-    
-    FILE_EXTENSION = 'yaml'
-    
-  protected
-    def setup options
-      super
-      
-      @data = []
-    end
-    
-    def finish options
-      output ::YAML.dump(@data)
-    end
-    
-  public
-    def text_token text, kind
-      @data << [text, kind]
-    end
-    
-    def begin_group kind
-      @data << [:begin_group, kind]
-    end
-    
-    def end_group kind
-      @data << [:end_group, kind]
-    end
-    
-    def begin_line kind
-      @data << [:begin_line, kind]
-    end
-    
-    def end_line kind
-      @data << [:end_line, kind]
-    end
-    
-  end
-  
-end
-end

data/lib/llm/shell/internal/coderay/lib/coderay/encoders.rb

@@ -1,18 +0,0 @@
-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'
-    
-    autoload :Encoder, CodeRay.coderay_path('encoders', 'encoder')
-    
-  end
-end

data/lib/llm/shell/internal/coderay/lib/coderay/for_redcloth.rb

@@ -1,95 +0,0 @@
-module CodeRay
-  
-  # A little hack to enable CodeRay highlighting in RedCloth.
-  # 
-  # Usage:
-  #  require 'coderay'
-  #  require 'coderay/for_redcloth'
-  #  RedCloth.new('@[ruby]puts "Hello, World!"@').to_html
-  # 
-  # Make sure you have RedCloth 4.0.3 activated, for example by calling
-  #  require 'rubygems'
-  # before RedCloth is loaded and before calling CodeRay.for_redcloth.
-  module ForRedCloth
-    
-    def self.install
-      gem 'RedCloth', '>= 4.0.3' if defined? gem
-      require 'redcloth'
-      unless RedCloth::VERSION.to_s >= '4.0.3'
-        if defined? gem
-          raise 'CodeRay.for_redcloth needs RedCloth version 4.0.3 or later. ' +
-            "You have #{RedCloth::VERSION}. Please gem install RedCloth."
-        else
-          $".delete 'redcloth.rb'  # sorry, but it works
-          require 'rubygems'
-          return install  # retry
-        end
-      end
-      unless RedCloth::VERSION.to_s >= '4.2.2'
-        warn 'CodeRay.for_redcloth works best with RedCloth version 4.2.2 or later.'
-      end
-      RedCloth::TextileDoc.send :include, ForRedCloth::TextileDoc
-      RedCloth::Formatters::HTML.module_eval do
-        def unescape(html)  # :nodoc:
-          replacements = {
-            '&' => '&',
-            '"' => '"',
-            '>' => '>',
-            '&lt;' => '<',
-          }
-          html.gsub(/&(?:amp|quot|[gl]t);/) { |entity| replacements[entity] }
-        end
-        undef code, bc_open, bc_close, escape_pre
-        def code(opts)  # :nodoc:
-          opts[:block] = true
-          if !opts[:lang] && RedCloth::VERSION.to_s >= '4.2.0'
-            # simulating pre-4.2 behavior
-            if opts[:text].sub!(/\A\[(\w+)\]/, '')
-              if CodeRay::Scanners[$1].lang == :text
-                opts[:text] = $& + opts[:text]
-              else
-                opts[:lang] = $1
-              end
-            end
-          end
-          if opts[:lang] && !filter_coderay
-            require 'coderay'
-            @in_bc ||= nil
-            format = @in_bc ? :div : :span
-            opts[:text] = unescape(opts[:text]) unless @in_bc
-            highlighted_code = CodeRay.encode opts[:text], opts[:lang], format
-            highlighted_code.sub!(/\A<(span|div)/) { |m| m + pba(@in_bc || opts) }
-            highlighted_code
-          else
-            "<code#{pba(opts)}>#{opts[:text]}</code>"
-          end
-        end
-        def bc_open(opts)  # :nodoc:
-          opts[:block] = true
-          @in_bc = opts
-          opts[:lang] ? '' : "<pre#{pba(opts)}>"
-        end
-        def bc_close(opts)  # :nodoc:
-          opts = @in_bc
-          @in_bc = nil
-          opts[:lang] ? '' : "</pre>\n"
-        end
-        def escape_pre(text)  # :nodoc:
-          if @in_bc ||= nil
-            text
-          else
-            html_esc(text, :html_escape_preformatted)
-          end
-        end
-      end
-    end
-
-    module TextileDoc  # :nodoc:
-      attr_accessor :filter_coderay
-    end
-    
-  end
-  
-end
-
-CodeRay::ForRedCloth.install