RubyGems - xaiml - Versions diffs - 0.1.3 → 0.1.4 - Mend

xaiml 0.1.3 → 0.1.4

Files changed (780) hide show

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/scanners/scanner.rb DELETED Viewed

@@ -1,337 +0,0 @@
-# encoding: utf-8
-module CodeRay
-  module Scanners
-    # = 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 StandardError
-      # The default options for all scanner classes.
-      #
-      # Define @default_options for subclasses.
-      DEFAULT_OPTIONS = { }
-      KINDS_NOT_LOC = [:comment, :doctype, :docstring]
-      attr_accessor :state
-      class << self
-        # Normalizes the given code into a string with UNIX newlines, in the
-        # scanner's internal encoding, with invalid and undefined charachters
-        # replaced by placeholders. Always returns a new object.
-        def normalize code
-          # original = code
-          code = code.to_s unless code.is_a? ::String
-          return code if code.empty?
-          if code.respond_to? :encoding
-            code = encode_with_encoding code, self.encoding
-          else
-            code = to_unix code
-          end
-          # code = code.dup if code.eql? original
-          code
-        end
-        # The typical filename suffix for this scanner's language.
-        def file_extension extension = lang
-          @file_extension ||= extension.to_s
-        end
-        # The encoding used internally by this scanner.
-        def encoding name = 'UTF-8'
-          @encoding ||= defined?(Encoding.find) && Encoding.find(name)
-        end
-        # The lang of this Scanner class, which is equal to its Plugin ID.
-        def lang
-          @plugin_id
-        end
-      protected
-        def encode_with_encoding code, target_encoding
-          if code.encoding == target_encoding
-            if code.valid_encoding?
-              return to_unix(code)
-            else
-              source_encoding = guess_encoding code
-            end
-          else
-            source_encoding = code.encoding
-          end
-          # print "encode_with_encoding from #{source_encoding} to #{target_encoding}"
-          code.encode target_encoding, source_encoding, :universal_newline => true, :undef => :replace, :invalid => :replace
-        end
-        def to_unix code
-          code.index(?\r) ? code.gsub(/\r\n?/, "\n") : code
-        end
-        def guess_encoding s
-          #:nocov:
-          IO.popen("file -b --mime -", "w+") do |file|
-            file.write s[0, 1024]
-            file.close_write
-            begin
-              Encoding.find file.gets[/charset=([-\w]+)/, 1]
-            rescue ArgumentError
-              Encoding::BINARY
-            end
-          end
-          #:nocov:
-        end
-      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.)
-      #
-      # Else, a Tokens object is used.
-      def initialize code = '', options = {}
-        if self.class == Scanner
-          raise NotImplementedError, "I am only the basic Scanner class. I can't scan anything. :( Use my subclasses."
-        end
-        @options = self.class::DEFAULT_OPTIONS.merge options
-        super self.class.normalize(code)
-        @tokens = options[:tokens] || Tokens.new
-        @tokens.scanner = self if @tokens.respond_to? :scanner=
-        setup
-      end
-      # Sets back the scanner. Subclasses should redefine the reset_instance
-      # method instead of this one.
-      def reset
-        super
-        reset_instance
-      end
-      # Set a new string to be scanned.
-      def string= code
-        code = self.class.normalize(code)
-        super code
-        reset_instance
-      end
-      # the Plugin ID for this scanner
-      def lang
-        self.class.lang
-      end
-      # the default file extension for this scanner
-      def file_extension
-        self.class.file_extension
-      end
-      # Scan the code and returns all tokens in a Tokens object.
-      def tokenize source = nil, options = {}
-        options = @options.merge(options)
-        set_tokens_from_options options
-        set_string_from_source source
-        begin
-          scan_tokens @tokens, options
-        rescue => e
-          message = "Error in %s#scan_tokens, initial state was: %p" % [self.class, defined?(state) && state]
-          raise_inspect e.message, @tokens, message, 30, e.backtrace
-        end
-        @cached_tokens = @tokens
-        if source.is_a? Array
-          @tokens.split_into_parts(*source.map { |part| part.size })
-        else
-          @tokens
-        end
-      end
-      # Cache the result of tokenize.
-      def tokens
-        @cached_tokens ||= tokenize
-      end
-      # Traverse the tokens.
-      def each &block
-        tokens.each(&block)
-      end
-      include Enumerable
-      # The current line position of the scanner, starting with 1.
-      # See also: #column.
-      #
-      # Beware, this is implemented inefficiently. It should be used
-      # for debugging only.
-      def line pos = self.pos
-        return 1 if pos <= 0
-        binary_string[0...pos].count("\n") + 1
-      end
-      # The current column position of the scanner, starting with 1.
-      # See also: #line.
-      def column pos = self.pos
-        return 1 if pos <= 0
-        pos - (binary_string.rindex(?\n, pos - 1) || -1)
-      end
-      # The string in binary encoding.
-      #
-      # To be used with #pos, which is the index of the byte the scanner
-      # will scan next.
-      def binary_string
-        @binary_string ||=
-          if string.respond_to?(:bytesize) && string.bytesize != string.size
-            #:nocov:
-            string.dup.force_encoding('binary')
-            #:nocov:
-          else
-            string
-          end
-      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  # :doc:
-      end
-      def set_string_from_source source
-        case source
-        when Array
-          self.string = self.class.normalize(source.join)
-        when nil
-          reset
-        else
-          self.string = self.class.normalize(source)
-        end
-      end
-      def set_tokens_from_options options
-        @tokens = options[:tokens] || @tokens || Tokens.new
-        @tokens.scanner = self if @tokens.respond_to? :scanner=
-      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  # :doc:
-        raise NotImplementedError, "#{self.class}#scan_tokens not implemented."
-      end
-      # Resets the scanner.
-      def reset_instance
-        @tokens.clear if @tokens.respond_to?(:clear) && !@options[:keep_tokens]
-        @cached_tokens = nil
-        @binary_string = nil if defined? @binary_string
-      end
-      SCAN_ERROR_MESSAGE = <<-MESSAGE
-***ERROR in %s: %s (after %s tokens)
-tokens:
-%s
-%s
-surrounding code:
-%p  ~~  %p
-***ERROR***
-      MESSAGE
-      def raise_inspect_arguments message, tokens, state, ambit
-        return File.basename(caller[0]),
-          message,
-          tokens_size(tokens),
-          tokens_last(tokens, 10).map(&:inspect).join("\n"),
-          scanner_state_info(state),
-          binary_string[pos - ambit, ambit],
-          binary_string[pos, ambit]
-      end
-      SCANNER_STATE_INFO = <<-INFO
-current line: %d  column: %d  pos: %d
-matched: %p  state: %p
-bol?: %p,  eos?: %p
-      INFO
-      def scanner_state_info state
-        SCANNER_STATE_INFO % [
-          line, column, pos,
-          matched, state || 'No state given!',
-          bol?, eos?,
-        ]
-      end
-      # Scanner error with additional status information
-      def raise_inspect message, tokens, state = self.state, ambit = 30, backtrace = caller
-        raise ScanError, SCAN_ERROR_MESSAGE % raise_inspect_arguments(message, tokens, state, ambit), backtrace
-      end
-      def tokens_size tokens
-        tokens.size if tokens.respond_to?(:size)
-      end
-      def tokens_last tokens, n
-        tokens.respond_to?(:last) ? tokens.last(n) : []
-      end
-      # Shorthand for scan_until(/\z/).
-      # This method also avoids a JRuby 1.9 mode bug.
-      def scan_rest
-        rest = self.rest
-        terminate
-        rest
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/scanners/sql.rb DELETED Viewed

@@ -1,169 +0,0 @@
-module CodeRay
-module Scanners
-  # by Josh Goebel
-  class SQL < Scanner
-    register_for :sql
-    KEYWORDS = %w(
-      all and any as before begin between by case check collate
-      each else end exists
-      for foreign from full group having if in inner is join
-      like not of on or order outer over references
-      then to union using values when where
-      left right distinct
-    )
-    OBJECTS = %w(
-      database databases table tables column columns fields index constraint
-      constraints transaction function procedure row key view trigger
-    )
-    COMMANDS = %w(
-      add alter comment create delete drop grant insert into select update set
-      show prompt begin commit rollback replace truncate
-    )
-    PREDEFINED_TYPES = %w(
-      char varchar varchar2 enum binary text tinytext mediumtext
-      longtext blob tinyblob mediumblob longblob timestamp
-      date time datetime year double decimal float int
-      integer tinyint mediumint bigint smallint unsigned bit
-      bool boolean hex bin oct
-    )
-    PREDEFINED_FUNCTIONS = %w( sum cast substring abs pi count min max avg now )
-    DIRECTIVES = %w(
-      auto_increment unique default charset initially deferred
-      deferrable cascade immediate read write asc desc after
-      primary foreign return engine
-    )
-    PREDEFINED_CONSTANTS = %w( null true false )
-    IDENT_KIND = WordList::CaseIgnoring.new(:ident).
-      add(KEYWORDS, :keyword).
-      add(OBJECTS, :type).
-      add(COMMANDS, :class).
-      add(PREDEFINED_TYPES, :predefined_type).
-      add(PREDEFINED_CONSTANTS, :predefined_constant).
-      add(PREDEFINED_FUNCTIONS, :predefined).
-      add(DIRECTIVES, :directive)
-    ESCAPE = / [rbfntv\n\\\/'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} | . /mx
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
-    STRING_PREFIXES = /[xnb]|_\w+/i
-    STRING_CONTENT_PATTERN = {
-      '"' => / (?: [^\\"] | "" )+ /x,
-      "'" => / (?: [^\\'] | '' )+ /x,
-      '`' => / (?: [^\\`] | `` )+ /x,
-    }
-    def scan_tokens encoder, options
-      state = :initial
-      string_type = nil
-      string_content = ''
-      name_expected = false
-      until eos?
-        if state == :initial
-          if match = scan(/ \s+ | \\\n /x)
-            encoder.text_token match, :space
-          elsif match = scan(/(?:--\s?|#).*/)
-            encoder.text_token match, :comment
-          elsif match = scan(%r( /\* (!)? (?: .*? \*/ | .* ) )mx)
-            encoder.text_token match, self[1] ? :directive : :comment
-          elsif match = scan(/ [*\/=<>:;,!&^|()\[\]{}~%] | [-+\.](?!\d) /x)
-            name_expected = true if match == '.' && check(/[A-Za-z_]/)
-            encoder.text_token match, :operator
-          elsif match = scan(/(#{STRING_PREFIXES})?([`"'])/o)
-            prefix = self[1]
-            string_type = self[2]
-            encoder.begin_group :string
-            encoder.text_token prefix, :modifier if prefix
-            match = string_type
-            state = :string
-            encoder.text_token match, :delimiter
-          elsif match = scan(/ @? [A-Za-z_][A-Za-z_0-9\$]* /x)
-            encoder.text_token match, name_expected ? :ident : (match[0] == ?@ ? :variable : IDENT_KIND[match])
-            name_expected = false
-          elsif match = scan(/0[xX][0-9A-Fa-f]+/)
-            encoder.text_token match, :hex
-          elsif match = scan(/0[0-7]+(?![89.eEfF])/)
-            encoder.text_token match, :octal
-          elsif match = scan(/[-+]?(?>\d+)(?![.eEfF])/)
-            encoder.text_token match, :integer
-          elsif match = scan(/[-+]?(?:\d[fF]|\d*\.\d+(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+)/)
-            encoder.text_token match, :float
-          elsif match = scan(/\\N/)
-            encoder.text_token match, :predefined_constant
-          else
-            encoder.text_token getch, :error
-          end
-        elsif state == :string
-          if match = scan(STRING_CONTENT_PATTERN[string_type])
-            encoder.text_token match, :content
-          elsif match = scan(/["'`]/)
-            if string_type == match
-              if peek(1) == string_type  # doubling means escape
-                encoder.text_token match + getch, :content
-              else
-                encoder.text_token match, :delimiter
-                encoder.end_group :string
-                state = :initial
-                string_type = nil
-              end
-            else
-              encoder.text_token match, :content
-            end
-          elsif match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            encoder.text_token match, :char
-          elsif match = scan(/ \\ . /mox)
-            encoder.text_token match, :content
-          elsif match = scan(/ \\ | $ /x)
-            encoder.text_token match, :error unless match.empty?
-            encoder.end_group :string
-            state = :initial
-          else
-            raise "else case \" reached; %p not handled." % peek(1), encoder
-          end
-        else
-          raise 'else-case reached', encoder
-        end
-      end
-      if state == :string
-        encoder.end_group state
-      end
-      encoder
-    end
-  end
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/scanners/taskpaper.rb DELETED Viewed

@@ -1,36 +0,0 @@
-module CodeRay
-module Scanners
-  class Taskpaper < Scanner
-    register_for :taskpaper
-    file_extension 'taskpaper'
-  protected
-    def scan_tokens encoder, options
-      until eos?
-        if match = scan(/\S.*:.*$/)                  # project
-          encoder.text_token(match, :namespace)
-        elsif match = scan(/-.+@done.*/)             # completed task
-          encoder.text_token(match, :done)
-        elsif match = scan(/-(?:[^@\n]+|@(?!due))*/) # task
-          encoder.text_token(match, :plain)
-        elsif match = scan(/@due.*/)                 # comment
-          encoder.text_token(match, :important)
-        elsif match = scan(/.+/)                     # comment
-          encoder.text_token(match, :comment)
-        elsif match = scan(/\s+/)                    # space
-          encoder.text_token(match, :space)
-        else                                         # other
-          encoder.text_token getch, :error
-        end
-      end
-      encoder
-    end
-  end
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/scanners/text.rb DELETED Viewed

@@ -1,26 +0,0 @@
-module CodeRay
-  module Scanners
-    # Scanner for plain text.
-    #
-    # Yields just one token of the kind :plain.
-    #
-    # Alias: +plaintext+, +plain+
-    class Text < Scanner
-      register_for :text
-      title 'Plain text'
-      KINDS_NOT_LOC = [:plain]  # :nodoc:
-    protected
-      def scan_tokens encoder, options
-        encoder.text_token string, :plain
-        encoder
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/coderay-1.1.2/lib/coderay/scanners/xml.rb DELETED Viewed

@@ -1,17 +0,0 @@
-module CodeRay
-module Scanners
-  load :html
-  # Scanner for XML.
-  #
-  # Currently this is the same scanner as Scanners::HTML.
-  class XML < HTML
-    register_for :xml
-    file_extension 'xml'
-  end
-end
-end