xaiml 0.1.0

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

@@ -0,0 +1,151 @@
+module CodeRay
+  
+  # = FileType
+  #
+  # A simple filetype recognizer.
+  #
+  # == Usage
+  #
+  #  # determine the type of the given
+  #  lang = FileType[file_name]
+  #  
+  #  # return :text if the file type is unknown
+  #  lang = FileType.fetch file_name, :text
+  #  
+  #  # try the shebang line, too
+  #  lang = FileType.fetch file_name, :text, true
+  module FileType
+    
+    UnknownFileType = Class.new Exception
+    
+    class << self
+      
+      # Try to determine the file type of the file.
+      #
+      # +filename+ is a relative or absolute path to a file.
+      #
+      # The file itself is only accessed when +read_shebang+ is set to true.
+      # That means you can get filetypes from files that don't exist.
+      def [] filename, read_shebang = false
+        name = File.basename filename
+        ext = File.extname(name).sub(/^\./, '')  # from last dot, delete the leading dot
+        ext2 = filename.to_s[/\.(.*)/, 1]  # from first dot
+        
+        type =
+          TypeFromExt[ext] ||
+          TypeFromExt[ext.downcase] ||
+          (TypeFromExt[ext2] if ext2) ||
+          (TypeFromExt[ext2.downcase] if ext2) ||
+          TypeFromName[name] ||
+          TypeFromName[name.downcase]
+        type ||= type_from_shebang(filename) if read_shebang
+        
+        type
+      end
+      
+      # This works like Hash#fetch.
+      #
+      # If the filetype cannot be found, the +default+ value
+      # is returned.
+      def fetch filename, default = nil, read_shebang = false
+        if default && block_given?
+          warn 'Block supersedes default value argument; use either.'
+        end
+        
+        if type = self[filename, read_shebang]
+          type
+        else
+          return yield if block_given?
+          return default if default
+          raise UnknownFileType, 'Could not determine type of %p.' % filename
+        end
+      end
+      
+    protected
+      
+      def type_from_shebang filename
+        return unless File.exist? filename
+        File.open filename, 'r' do |f|
+          if first_line = f.gets
+            if type = first_line[TypeFromShebang]
+              type.to_sym
+            end
+          end
+        end
+      end
+      
+    end
+    
+    TypeFromExt = {
+      'c'         => :c,
+      'cfc'       => :xml,
+      'cfm'       => :xml,
+      'clj'       => :clojure,
+      'css'       => :css,
+      'diff'      => :diff,
+      'dpr'       => :delphi,
+      'erb'       => :erb,
+      'gemspec'   => :ruby,
+      'go'        => :go, 
+      'groovy'    => :groovy,
+      'gvy'       => :groovy,
+      'h'         => :c,
+      'haml'      => :haml,
+      'htm'       => :html,
+      'html'      => :html,
+      'html.erb'  => :erb,
+      'java'      => :java,
+      'js'        => :java_script,
+      'json'      => :json,
+      'lua'       => :lua,
+      'mab'       => :ruby,
+      'pas'       => :delphi,
+      'patch'     => :diff,
+      'phtml'     => :php,
+      'php'       => :php,
+      'php3'      => :php,
+      'php4'      => :php,
+      'php5'      => :php,
+      'prawn'     => :ruby,
+      'py'        => :python,
+      'py3'       => :python,
+      'pyw'       => :python,
+      'rake'      => :ruby,
+      'raydebug'  => :raydebug,
+      'rb'        => :ruby,
+      'rbw'       => :ruby,
+      'rhtml'     => :erb,
+      'rjs'       => :ruby,
+      'rpdf'      => :ruby,
+      'ru'        => :ruby,  # config.ru
+      'rxml'      => :ruby,
+      'sass'      => :sass,
+      'sql'       => :sql,
+      'taskpaper' => :taskpaper,
+      'template'  => :json,  # AWS CloudFormation template
+      'tmproj'    => :xml,
+      'xaml'      => :xml,
+      'xhtml'     => :html,
+      'xml'       => :xml,
+      'yaml'      => :yaml,
+      'yml'       => :yaml,
+    }
+    for cpp_alias in %w[cc cpp cp cxx c++ C hh hpp h++ cu]
+      TypeFromExt[cpp_alias] = :cpp
+    end
+    
+    TypeFromShebang = /\b(?:ruby|perl|python|sh)\b/
+    
+    TypeFromName = {
+      'Capfile'  => :ruby,
+      'Rakefile' => :ruby,
+      'Rantfile' => :ruby,
+      'Gemfile'  => :ruby,
+      'Guardfile' => :ruby,
+      'Vagrantfile' => :ruby,
+      'Appraisals' => :ruby
+    }
+    
+  end
+  
+end

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

@@ -0,0 +1,55 @@
+module CodeRay
+  
+  # = Plugin
+  #
+  #  Plugins have to include this module.
+  #
+  #  IMPORTANT: Use extend for this module.
+  #
+  #  See CodeRay::PluginHost for examples.
+  module Plugin
+    
+    attr_reader :plugin_id
+    
+    # Register this class for the given +id+.
+    # 
+    # Example:
+    #   class MyPlugin < PluginHost::BaseClass
+    #     register_for :my_id
+    #     ...
+    #   end
+    #
+    # See PluginHost.register.
+    def register_for id
+      @plugin_id = id
+      plugin_host.register self, id
+    end
+    
+    # Returns the title of the plugin, or sets it to the
+    # optional argument +title+.
+    def title title = nil
+      if title
+        @title = title.to_s
+      else
+        @title ||= name[/([^:]+)$/, 1]
+      end
+    end
+    
+    # The PluginHost for this Plugin class.
+    def plugin_host host = nil
+      if host.is_a? PluginHost
+        const_set :PLUGIN_HOST, host
+      end
+      self::PLUGIN_HOST
+    end
+    
+    def aliases
+      plugin_host.plugin_hash.inject [] do |aliases, (key, _)|
+        aliases << key if plugin_host[key] == self
+        aliases
+      end
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,221 @@
+module CodeRay
+  
+  # = PluginHost
+  #
+  # A simple subclass/subfolder plugin system.
+  #
+  # Example:
+  #  class Generators
+  #    extend 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'
+  #  # or
+  #  Generators::Fancy
+  module PluginHost
+    
+    # Raised if Encoders::[] fails because:
+    # * a file could not be found
+    # * the requested Plugin is not registered
+    PluginNotFound = Class.new LoadError
+    HostNotFound   = Class.new LoadError
+    
+    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? String
+      plugin
+    end
+    
+    alias load []
+    
+    # Tries to +load+ the missing plugin by translating +const+ to the
+    # underscore form (eg. LinesOfCode becomes lines_of_code).
+    def const_missing const
+      id = const.to_s.
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        downcase
+      load id
+    end
+    
+    class << self
+      
+      # Adds the module/class to the PLUGIN_HOSTS list.
+      def extended mod
+        PLUGIN_HOSTS << mod
+      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)
+      end
+      @plugin_path ||= ''
+    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, or return the default plugin.
+    #
+    # See also map.
+    #
+    #  class MyColorHost < PluginHost
+    #    map :navy => :dark_blue
+    #    default :gray
+    #  end
+    #  
+    #  MyColorHost.default  # loads and returns the Gray plugin
+    def default id = nil
+      if id
+        id = validate_id id
+        raise "The default plugin can't be named \"default\"." if id == :default
+        plugin_hash[:default] = id
+      else
+        load :default
+      end
+    end
+    
+    # Every plugin must register itself for +id+ by calling register_for,
+    # which calls this method.
+    #
+    # See Plugin#register_for.
+    def register plugin, id
+      plugin_hash[validate_id(id)] = plugin
+    end
+    
+    # A Hash of plugion_id => Plugin pairs.
+    def plugin_hash
+      @plugin_hash ||= (@plugin_hash = make_plugin_hash).tap { load_plugin_map }
+    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').to_sym
+      end
+    end
+    
+    # Returns an array of all Plugins.
+    # 
+    # Note: This loads all plugins using load_all.
+    def all_plugins
+      load_all
+      plugin_hash.values.grep(Class)
+    end
+    
+    # Loads the map file (see map).
+    #
+    # This is done automatically when plugin_path is called.
+    def load_plugin_map
+      mapfile = path_to '_map'
+      if File.exist? mapfile
+        require mapfile
+        true
+      else
+        false
+      end
+    end
+    
+  protected
+    
+    # Return a plugin hash that automatically loads plugins.
+    def make_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?(:default)
+            h[:default]
+          else
+            raise PluginNotFound, '%p could not load plugin %p: %s' % [self, id, boom]
+          end
+        else
+          # Plugin should have registered by now
+          if h.has_key? id
+            h[id]
+          else
+            raise PluginNotFound, "No #{self.name} plugin for #{id.inspect} found in #{path}."
+          end
+        end
+      end
+    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 valid plugin ID String, or returns +nil+.
+    #
+    # Raises +ArgumentError+ for all other objects, or if the
+    # given String includes non-alphanumeric characters (\W).
+    def validate_id id
+      case id
+      when Symbol
+        id.to_s
+      when String
+        if id[/\w+/] == id
+          id.downcase
+        else
+          raise ArgumentError, "Invalid id given: #{id}"
+        end
+      else
+        raise ArgumentError, "Symbol or String expected, but #{id.class} given."
+      end
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,72 @@
+module CodeRay
+  
+  # = WordList
+  # 
+  # <b>A Hash subclass designed for mapping word lists to token types.</b>
+  # 
+  # A WordList is a Hash with some additional features.
+  # It is intended to be used for keyword recognition.
+  #
+  # WordList is optimized to be used in Scanners,
+  # typically to decide whether a given ident is a special token.
+  #
+  # For case insensitive words use WordList::CaseIgnoring.
+  #
+  # Example:
+  #
+  #  # define word arrays
+  #  RESERVED_WORDS = %w[
+  #    asm break case continue default do else
+  #  ]
+  #  
+  #  PREDEFINED_TYPES = %w[
+  #    int long short char void
+  #  ]
+  #  
+  #  # make a WordList
+  #  IDENT_KIND = WordList.new(:ident).
+  #    add(RESERVED_WORDS, :reserved).
+  #    add(PREDEFINED_TYPES, :predefined_type)
+  #  
+  #  ...
+  #  
+  #  def scan_tokens tokens, options
+  #    ...
+  #    
+  #    elsif scan(/[A-Za-z_][A-Za-z_0-9]*/)
+  #      # use it
+  #      kind = IDENT_KIND[match]
+  #      ...
+  class WordList < Hash
+    
+    # Create a new WordList with +default+ as default value.
+    def initialize default = false
+      super default
+    end
+    
+    # Add words to the list and associate them with +value+.
+    # 
+    # Returns +self+, so you can concat add calls.
+    def add words, value = true
+      words.each { |word| self[word] = value }
+      self
+    end
+    
+  end
+  
+  
+  # A CaseIgnoring WordList is like a WordList, only that
+  # keys are compared case-insensitively (normalizing keys using +downcase+).
+  class WordList::CaseIgnoring < WordList
+    
+    def [] key
+      super key.downcase
+    end
+    
+    def []= key, value
+      super key.downcase, value
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,24 @@
+module CodeRay
+module Scanners
+  
+  map \
+    :'c++'       => :cpp,
+    :cplusplus   => :cpp,
+    :ecmascript  => :java_script,
+    :ecma_script => :java_script,
+    :rhtml       => :erb,
+    :eruby       => :erb,
+    :irb         => :ruby,
+    :javascript  => :java_script,
+    :js          => :java_script,
+    :pascal      => :delphi,
+    :patch       => :diff,
+    :plain       => :text,
+    :plaintext   => :text,
+    :xhtml       => :html,
+    :yml         => :yaml
+  
+  default :text
+  
+end
+end

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

@@ -0,0 +1,189 @@
+module CodeRay
+module Scanners
+  
+  # Scanner for C.
+  class C < Scanner
+
+    register_for :c
+    file_extension 'c'
+    
+    KEYWORDS = [
+      'asm', 'break', 'case', 'continue', 'default', 'do',
+      'else', 'enum', 'for', 'goto', 'if', 'return',
+      'sizeof', 'struct', 'switch', 'typedef', 'union', 'while',
+      'restrict',  # added in C99
+    ]  # :nodoc:
+
+    PREDEFINED_TYPES = [
+      'int', 'long', 'short', 'char',
+      'signed', 'unsigned', 'float', 'double',
+      'bool', 'complex',  # added in C99
+    ]  # :nodoc:
+
+    PREDEFINED_CONSTANTS = [
+      'EOF', 'NULL',
+      'true', 'false',  # added in C99
+    ]  # :nodoc:
+    DIRECTIVES = [
+      'auto', 'extern', 'register', 'static', 'void',
+      'const', 'volatile',  # added in C89
+      'inline',  # added in C99
+    ]  # :nodoc:
+
+    IDENT_KIND = WordList.new(:ident).
+      add(KEYWORDS, :keyword).
+      add(PREDEFINED_TYPES, :predefined_type).
+      add(DIRECTIVES, :directive).
+      add(PREDEFINED_CONSTANTS, :predefined_constant)  # :nodoc:
+
+    ESCAPE = / [rbfntv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x  # :nodoc:
+    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x  # :nodoc:
+    
+  protected
+    
+    def scan_tokens encoder, options
+
+      state = :initial
+      label_expected = true
+      case_expected = false
+      label_expected_before_preproc_line = nil
+      in_preproc_line = false
+
+      until eos?
+
+        case state
+
+        when :initial
+
+          if match = scan(/ \s+ | \\\n /x)
+            if in_preproc_line && match != "\\\n" && match.index(?\n)
+              in_preproc_line = false
+              label_expected = label_expected_before_preproc_line
+            end
+            encoder.text_token match, :space
+
+          elsif match = scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
+            encoder.text_token match, :comment
+
+          elsif match = scan(/ [-+*=<>?:;,!&^|()\[\]{}~%]+ | \/=? | \.(?!\d) /x)
+            label_expected = match =~ /[;\{\}]/
+            if case_expected
+              label_expected = true if match == ':'
+              case_expected = false
+            end
+            encoder.text_token match, :operator
+
+          elsif match = scan(/ [A-Za-z_][A-Za-z_0-9]* /x)
+            kind = IDENT_KIND[match]
+            if kind == :ident && label_expected && !in_preproc_line && scan(/:(?!:)/)
+              kind = :label
+              match << matched
+            else
+              label_expected = false
+              if kind == :keyword
+                case match
+                when 'case', 'default'
+                  case_expected = true
+                end
+              end
+            end
+            encoder.text_token match, kind
+
+          elsif match = scan(/L?"/)
+            encoder.begin_group :string
+            if match[0] == ?L
+              encoder.text_token 'L', :modifier
+              match = '"'
+            end
+            encoder.text_token match, :delimiter
+            state = :string
+
+          elsif match = scan(/ \# \s* if \s* 0 /x)
+            match << scan_until(/ ^\# (?:elif|else|endif) .*? $ | \z /xm) unless eos?
+            encoder.text_token match, :comment
+
+          elsif match = scan(/#[ \t]*(\w*)/)
+            encoder.text_token match, :preprocessor
+            in_preproc_line = true
+            label_expected_before_preproc_line = label_expected
+            state = :include_expected if self[1] == 'include'
+
+          elsif match = scan(/ L?' (?: [^\'\n\\] | \\ #{ESCAPE} )? '? /ox)
+            label_expected = false
+            encoder.text_token match, :char
+
+          elsif match = scan(/\$/)
+            encoder.text_token match, :ident
+          
+          elsif match = scan(/0[xX][0-9A-Fa-f]+/)
+            label_expected = false
+            encoder.text_token match, :hex
+
+          elsif match = scan(/(?:0[0-7]+)(?![89.eEfF])/)
+            label_expected = false
+            encoder.text_token match, :octal
+
+          elsif match = scan(/(?:\d+)(?![.eEfF])L?L?/)
+            label_expected = false
+            encoder.text_token match, :integer
+
+          elsif match = scan(/\d[fF]?|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
+            label_expected = false
+            encoder.text_token match, :float
+
+          else
+            encoder.text_token getch, :error
+
+          end
+
+        when :string
+          if match = scan(/[^\\\n"]+/)
+            encoder.text_token match, :content
+          elsif match = scan(/"/)
+            encoder.text_token match, :delimiter
+            encoder.end_group :string
+            state = :initial
+            label_expected = false
+          elsif match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
+            encoder.text_token match, :char
+          elsif match = scan(/ \\ | $ /x)
+            encoder.end_group :string
+            encoder.text_token match, :error unless match.empty?
+            state = :initial
+            label_expected = false
+          else
+            raise_inspect "else case \" reached; %p not handled." % peek(1), encoder
+          end
+
+        when :include_expected
+          if match = scan(/<[^>\n]+>?|"[^"\n\\]*(?:\\.[^"\n\\]*)*"?/)
+            encoder.text_token match, :include
+            state = :initial
+
+          elsif match = scan(/\s+/)
+            encoder.text_token match, :space
+            state = :initial if match.index ?\n
+
+          else
+            state = :initial
+
+          end
+
+        else
+          raise_inspect 'Unknown state', encoder
+
+        end
+
+      end
+
+      if state == :string
+        encoder.end_group :string
+      end
+
+      encoder
+    end
+
+  end
+
+end
+end