xaiml 0.1.0

data/vendor/bundle/ruby/2.5.0/extensions/x86_64-darwin-17/2.5.0-static/ox-2.10.0/gem_make.out

@@ -0,0 +1,93 @@
+current directory: /Users/koji_dev/workspace/aiml/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox
+/Users/koji_dev/.rbenv/versions/2.5.1/bin/ruby -r ./siteconf20180906-71072-z51x0o.rb extconf.rb
+>>>>> Creating Makefile for ruby version 2.5.1 on x86_64-darwin17 <<<<<
+creating Makefile
+
+current directory: /Users/koji_dev/workspace/aiml/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox
+make "DESTDIR=" clean
+
+current directory: /Users/koji_dev/workspace/aiml/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox
+make "DESTDIR="
+compiling base64.c
+compiling builder.c
+builder.c:127:10: warning: implicit conversion loses integer precision: 'size_t' (aka 'unsigned long') to 'int' [-Wshorten-64-to-32]
+        int     i = size;
+                ~   ^~~~
+builder.c:191:8: warning: implicit conversion loses integer precision: 'long' to 'int' [-Wshorten-64-to-32]
+        len = RSTRING_LEN(v);
+            ~ ^~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:975:6: note: expanded from macro 'RSTRING_LEN'
+     RSTRING_EMBED_LEN(str) : \
+     ^~~~~~~~~~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:971:6: note: expanded from macro 'RSTRING_EMBED_LEN'
+     (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
+     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+builder.c:191:8: warning: implicit conversion loses integer precision: 'long' to 'int' [-Wshorten-64-to-32]
+        len = RSTRING_LEN(v);
+            ~ ^~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:976:28: note: expanded from macro 'RSTRING_LEN'
+     RSTRING(str)->as.heap.len)
+     ~~~~~~~~~~~~~~~~~~~~~~^~~
+builder.c:195:8: warning: implicit conversion loses integer precision: 'unsigned long' to 'int' [-Wshorten-64-to-32]
+        len = strlen(s);
+            ~ ^~~~~~~~~
+builder.c:617:8: warning: implicit conversion loses integer precision: 'long' to 'int' [-Wshorten-64-to-32]
+        len = RSTRING_LEN(*argv);
+            ~ ^~~~~~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:975:6: note: expanded from macro 'RSTRING_LEN'
+     RSTRING_EMBED_LEN(str) : \
+     ^~~~~~~~~~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:971:6: note: expanded from macro 'RSTRING_EMBED_LEN'
+     (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
+     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+builder.c:617:8: warning: implicit conversion loses integer precision: 'long' to 'int' [-Wshorten-64-to-32]
+        len = RSTRING_LEN(*argv);
+            ~ ^~~~~~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:976:28: note: expanded from macro 'RSTRING_LEN'
+     RSTRING(str)->as.heap.len)
+     ~~~~~~~~~~~~~~~~~~~~~~^~~
+builder.c:621:8: warning: implicit conversion loses integer precision: 'unsigned long' to 'int' [-Wshorten-64-to-32]
+        len = strlen(name);
+            ~ ^~~~~~~~~~~~
+builder.c:675:8: warning: implicit conversion loses integer precision: 'long' to 'int' [-Wshorten-64-to-32]
+        len = RSTRING_LEN(*argv);
+            ~ ^~~~~~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:975:6: note: expanded from macro 'RSTRING_LEN'
+     RSTRING_EMBED_LEN(str) : \
+     ^~~~~~~~~~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:971:6: note: expanded from macro 'RSTRING_EMBED_LEN'
+     (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
+     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+builder.c:675:8: warning: implicit conversion loses integer precision: 'long' to 'int' [-Wshorten-64-to-32]
+        len = RSTRING_LEN(*argv);
+            ~ ^~~~~~~~~~~~~~~~~~
+/Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/ruby/ruby.h:976:28: note: expanded from macro 'RSTRING_LEN'
+     RSTRING(str)->as.heap.len)
+     ~~~~~~~~~~~~~~~~~~~~~~^~~
+builder.c:679:8: warning: implicit conversion loses integer precision: 'unsigned long' to 'int' [-Wshorten-64-to-32]
+        len = strlen(name);
+            ~ ^~~~~~~~~~~~
+10 warnings generated.
+compiling cache.c
+compiling cache8.c
+compiling dump.c
+compiling err.c
+compiling gen_load.c
+compiling hash_load.c
+compiling obj_load.c
+compiling ox.c
+compiling parse.c
+compiling sax.c
+sax.c:514:25: warning: implicit conversion loses integer precision: 'long' to 'int' [-Wshorten-64-to-32]
+    coff = dr->buf.tail - dr->buf.head;
+         ~ ~~~~~~~~~~~~~^~~~~~~~~~~~~~
+1 warning generated.
+compiling sax_as.c
+compiling sax_buf.c
+compiling sax_hint.c
+compiling special.c
+linking shared-object ox.bundle
+
+current directory: /Users/koji_dev/workspace/aiml/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox
+make "DESTDIR=" install
+/usr/bin/install -c -m 0755 ox.bundle ./.gem.20180906-71072-1l9777a

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (C) 2005-2012 Kornelius Kalnbach <murphy@rubychan.de> (@murphy_karasu)
+
+http://coderay.rubychan.de/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/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/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/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 -page > 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/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/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/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/encoders/_map.rb

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,49 @@
+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