xaiml 0.1.3 → 0.1.4

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/duo.rb

@@ -1,81 +0,0 @@
-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/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/_map.rb

@@ -1,17 +0,0 @@
-module CodeRay
-module Encoders
-  
-  map \
-    :loc             => :lines_of_code,
-    :plain           => :text,
-    :plaintext       => :text,
-    :remove_comments => :comment_filter,
-    :stats           => :statistic,
-    :term            => :terminal,
-    :tty             => :terminal,
-    :yml             => :yaml
-  
-  # No default because Tokens#nonsense should raise NoMethodError.
-  
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/comment_filter.rb

@@ -1,25 +0,0 @@
-module CodeRay
-module Encoders
-  
-  load :token_kind_filter
-  
-  # A simple Filter that removes all tokens of the :comment kind.
-  # 
-  # Alias: +remove_comments+
-  # 
-  # Usage:
-  #  CodeRay.scan('print # foo', :ruby).comment_filter.text
-  #  #-> "print "
-  # 
-  # See also: TokenKindFilter, LinesOfCode
-  class CommentFilter < TokenKindFilter
-    
-    register_for :comment_filter
-    
-    DEFAULT_OPTIONS = superclass::DEFAULT_OPTIONS.merge \
-      :exclude => [:comment, :docstring]
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/count.rb

@@ -1,39 +0,0 @@
-module CodeRay
-module Encoders
-  
-  # Returns the number of tokens.
-  # 
-  # Text and block tokens are counted.
-  class Count < Encoder
-    
-    register_for :count
-    
-  protected
-    
-    def setup options
-      super
-      
-      @count = 0
-    end
-    
-    def finish options
-      output @count
-    end
-    
-  public
-    
-    def text_token text, kind
-      @count += 1
-    end
-    
-    def begin_group kind
-      @count += 1
-    end
-    alias end_group begin_group
-    alias begin_line begin_group
-    alias end_line begin_group
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/debug.rb

@@ -1,49 +0,0 @@
-module CodeRay
-module Encoders
-  
-  # = Debug Encoder
-  #
-  # Fast encoder producing simple debug output.
-  #
-  # It is readable and diff-able and is used for testing.
-  #
-  # You cannot fully restore the tokens information from the
-  # output, because consecutive :space tokens are merged.
-  # 
-  # See also: Scanners::Debug
-  class Debug < Encoder
-    
-    register_for :debug
-    
-    FILE_EXTENSION = 'raydebug'
-    
-    def text_token text, kind
-      if kind == :space
-        @out << text
-      else
-        text = text.gsub('\\', '\\\\\\\\') if text.index('\\')
-        text = text.gsub(')',  '\\\\)')    if text.index(')')
-        @out << "#{kind}(#{text})"
-      end
-    end
-    
-    def begin_group kind
-      @out << "#{kind}<"
-    end
-    
-    def end_group kind
-      @out << '>'
-    end
-    
-    def begin_line kind
-      @out << "#{kind}["
-    end
-    
-    def end_line kind
-      @out << ']'
-    end
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/debug_lint.rb

@@ -1,63 +0,0 @@
-module CodeRay
-module Encoders
-  
-  load :lint
-  
-  # = Debug Lint Encoder
-  #
-  # Debug encoder with additional checks for:
-  # 
-  # - empty tokens
-  # - incorrect nesting
-  # 
-  # It will raise an InvalidTokenStream exception when any of the above occurs.
-  # 
-  # See also: Encoders::Debug
-  class DebugLint < Debug
-    
-    register_for :debug_lint
-    
-    def text_token text, kind
-      raise Lint::EmptyToken,       'empty token for %p' % [kind] if text.empty?
-      raise Lint::UnknownTokenKind, 'unknown token kind %p (text was %p)' % [kind, text] unless TokenKinds.has_key? kind
-      super
-    end
-    
-    def begin_group kind
-      @opened << kind
-      super
-    end
-    
-    def end_group kind
-      raise Lint::IncorrectTokenGroupNesting, 'We are inside %s, not %p (end_group)' % [@opened.reverse.map(&:inspect).join(' < '), kind] if @opened.last != kind
-      @opened.pop
-      super
-    end
-    
-    def begin_line kind
-      @opened << kind
-      super
-    end
-    
-    def end_line kind
-      raise Lint::IncorrectTokenGroupNesting, 'We are inside %s, not %p (end_line)' % [@opened.reverse.map(&:inspect).join(' < '), kind] if @opened.last != kind
-      @opened.pop
-      super
-    end
-    
-    protected
-    
-    def setup options
-      super
-      @opened = []
-    end
-    
-    def finish options
-      raise 'Some tokens still open at end of token stream: %p' % [@opened] unless @opened.empty?
-      super
-    end
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/div.rb

@@ -1,23 +0,0 @@
-module CodeRay
-module Encoders
-  
-  load :html
-  
-  # Wraps HTML output into a DIV element, using inline styles by default.
-  # 
-  # See Encoders::HTML for available options.
-  class Div < HTML
-    
-    FILE_EXTENSION = 'div.html'
-    
-    register_for :div
-    
-    DEFAULT_OPTIONS = HTML::DEFAULT_OPTIONS.merge \
-      :css          => :style,
-      :wrap         => :div,
-      :line_numbers => false
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/encoder.rb

@@ -1,190 +0,0 @@
-module CodeRay
-  module 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] || ''.dup
-      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

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/filter.rb

@@ -1,58 +0,0 @@
-module CodeRay
-module Encoders
-  
-  # A Filter encoder has another Tokens instance as output.
-  # It can be subclass to select, remove, or modify tokens in the stream.
-  # 
-  # Subclasses of Filter are called "Filters" and can be chained.
-  # 
-  # == Options
-  # 
-  # === :tokens
-  # 
-  # The Tokens object which will receive the output.
-  # 
-  # Default: Tokens.new
-  # 
-  # See also: TokenKindFilter
-  class Filter < Encoder
-    
-    register_for :filter
-    
-  protected
-    def setup options
-      super
-      
-      @tokens = options[:tokens] || Tokens.new
-    end
-    
-    def finish options
-      output @tokens
-    end
-    
-  public
-    
-    def text_token text, kind  # :nodoc:
-      @tokens.text_token text, kind
-    end
-    
-    def begin_group kind  # :nodoc:
-      @tokens.begin_group kind
-    end
-    
-    def begin_line kind  # :nodoc:
-      @tokens.begin_line kind
-    end
-    
-    def end_group kind  # :nodoc:
-      @tokens.end_group kind
-    end
-    
-    def end_line kind  # :nodoc:
-      @tokens.end_line kind
-    end
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/html/css.rb

@@ -1,65 +0,0 @@
-module CodeRay
-module Encoders
-
-  class HTML
-    class CSS  # :nodoc:
-
-      attr :stylesheet
-
-      def CSS.load_stylesheet style = nil
-        CodeRay::Styles[style]
-      end
-
-      def initialize style = :default
-        @styles = Hash.new
-        style = CSS.load_stylesheet style
-        @stylesheet = [
-          style::CSS_MAIN_STYLES,
-          style::TOKEN_COLORS.gsub(/^(?!$)/, '.CodeRay ')
-        ].join("\n")
-        parse style::TOKEN_COLORS
-      end
-
-      def get_style_for_css_classes css_classes
-        cl = @styles[css_classes.first]
-        return '' unless cl
-        style = ''
-        1.upto css_classes.size do |offset|
-          break if style = cl[css_classes[offset .. -1]]
-        end
-        # warn 'Style not found: %p' % [styles] if style.empty?
-        return style
-      end
-
-    private
-
-      CSS_CLASS_PATTERN = /
-        (                    # $1 = selectors
-          (?:
-            (?: \s* \. [-\w]+ )+
-            \s* ,?
-          )+
-        )
-        \s* \{ \s*
-        ( [^\}]+ )?          # $2 = style
-        \s* \} \s*
-      |
-        ( [^\n]+ )           # $3 = error
-      /mx
-      def parse stylesheet
-        stylesheet.scan CSS_CLASS_PATTERN do |selectors, style, error|
-          raise "CSS parse error: '#{error.inspect}' not recognized" if error
-          for selector in selectors.split(',')
-            classes = selector.scan(/[-\w]+/)
-            cl = classes.pop
-            @styles[cl] ||= Hash.new
-            @styles[cl][classes] = style.to_s.strip.delete(' ').chomp(';')
-          end
-        end
-      end
-
-    end
-  end
-
-end
-end