rouge-alda 3.3.0

data/lib/rouge/lexers/ini.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class INI < RegexLexer
+      title "INI"
+      desc 'the INI configuration format'
+      tag 'ini'
+
+      # TODO add more here
+      filenames '*.ini', '*.INI', '*.gitconfig'
+      mimetypes 'text/x-ini'
+
+      identifier = /[\w\-.]+/
+
+      state :basic do
+        rule /[;#].*?\n/, Comment
+        rule /\s+/, Text
+        rule /\\\n/, Str::Escape
+      end
+
+      state :root do
+        mixin :basic
+
+        rule /(#{identifier})(\s*)(=)/ do
+          groups Name::Property, Text, Punctuation
+          push :value
+        end
+
+        rule /\[.*?\]/, Name::Namespace
+      end
+
+      state :value do
+        rule /\n/, Text, :pop!
+        mixin :basic
+        rule /"/, Str, :dq
+        rule /'.*?'/, Str
+        mixin :esc_str
+        rule /[^\\\n]+/, Str
+      end
+
+      state :dq do
+        rule /"/, Str, :pop!
+        mixin :esc_str
+        rule /[^\\"]+/m, Str
+      end
+
+      state :esc_str do
+        rule /\\./m, Str::Escape
+      end
+    end
+  end
+end

data/lib/rouge/lexers/io.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class IO < RegexLexer
+      tag 'io'
+      title "Io"
+      desc 'The IO programming language (http://iolanguage.com)'
+      mimetypes 'text/x-iosrc'
+      filenames '*.io'
+
+      def self.detect?(text)
+        return true if text.shebang? 'io'
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(nil false true)
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          args call clone do doFile doString else elseif for if list
+          method return super then
+        )
+      end
+
+      state :root do
+        rule /\s+/m, Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(#.*?\n), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+        rule %r(/[+]), Comment::Multiline, :nested_comment
+
+        rule /"(\\\\|\\"|[^"])*"/, Str
+
+        rule %r(:?:=), Keyword
+        rule /[()]/, Punctuation
+
+        rule %r([-=;,*+><!/|^.%&\[\]{}]), Operator
+
+        rule /[A-Z]\w*/, Name::Class
+
+        rule /[a-z_]\w*/ do |m|
+          name = m[0]
+
+          if self.class.constants.include? name
+            token Keyword::Constant
+          elsif self.class.builtins.include? name
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, Num::Float
+        rule /\d+/, Num::Integer
+
+        rule /@@?/, Keyword
+      end
+
+      state :nested_comment do
+        rule %r([^/+]+)m, Comment::Multiline
+        rule %r(/[+]), Comment::Multiline, :nested_comment
+        rule %r([+]/), Comment::Multiline, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/irb.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'console.rb'
+
+    class IRBLexer < ConsoleLexer
+      tag 'irb'
+      aliases 'pry'
+
+      desc 'Shell sessions in IRB or Pry'
+
+      # unlike the superclass, we do not accept any options
+      @option_docs = {}
+
+      def output_lexer
+        @output_lexer ||= IRBOutputLexer.new(@options)
+      end
+
+      def lang_lexer
+        @lang_lexer ||= Ruby.new(@options)
+      end
+
+      def prompt_regex
+        /^.*?(irb|pry).*?[>"*]/
+      end
+
+      def allow_comments?
+        true
+      end
+    end
+
+    load_lexer 'ruby.rb'
+    class IRBOutputLexer < Ruby
+      tag 'irb_output'
+
+      start do
+        push :stdout
+      end
+
+      state :has_irb_output do
+        rule %r(=>), Punctuation, :pop!
+        rule /.+?(\n|$)/, Generic::Output
+      end
+
+      state :irb_error do
+        rule /.+?(\n|$)/, Generic::Error
+        mixin :has_irb_output
+      end
+
+      state :stdout do
+        rule /\w+?(Error|Exception):.+?(\n|$)/, Generic::Error, :irb_error
+        mixin :has_irb_output
+      end
+
+      prepend :root do
+        rule /#</, Keyword::Type, :irb_object
+      end
+
+      state :irb_object do
+        rule />/, Keyword::Type, :pop!
+        mixin :root
+      end
+    end
+  end
+end

data/lib/rouge/lexers/java.rb

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Java < RegexLexer
+      title "Java"
+      desc "The Java programming language (java.com)"
+
+      tag 'java'
+      filenames '*.java'
+      mimetypes 'text/x-java'
+
+      keywords = %w(
+        assert break case catch continue default do else finally for
+        if goto instanceof new return switch this throw try while
+      )
+
+      declarations = %w(
+        abstract const enum extends final implements native private protected
+        public static strictfp super synchronized throws transient volatile
+      )
+
+      types = %w(boolean byte char double float int long short var void)
+
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      state :root do
+        rule /[^\S\n]+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        # keywords: go before method names to avoid lexing "throw new XYZ"
+        # as a method signature
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+
+        rule %r(
+          (\s*(?:[a-zA-Z_][a-zA-Z0-9_.\[\]<>]*\s+)+?) # return arguments
+          ([a-zA-Z_][a-zA-Z0-9_]*)                  # method name
+          (\s*)(\()                                 # signature start
+        )mx do |m|
+          # TODO: do this better, this shouldn't need a delegation
+          delegate Java, m[1]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Operator, m[4]
+        end
+
+        rule /@#{id}/, Name::Decorator
+        rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule /(?:#{types.join('|')})\b/, Keyword::Type
+        rule /package\b/, Keyword::Namespace
+        rule /(?:true|false|null)\b/, Keyword::Constant
+        rule /(?:class|interface)\b/, Keyword::Declaration, :class
+        rule /import\b/, Keyword::Namespace, :import
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
+        rule /(\.)(#{id})/ do
+          groups Operator, Name::Attribute
+        end
+
+        rule /#{id}:/, Name::Label
+        rule /\$?#{id}/, Name
+        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+
+        digit = /[0-9]_+[0-9]|[0-9]/
+        bin_digit = /[01]_+[01]|[01]/
+        oct_digit = /[0-7]_+[0-7]|[0-7]/
+        hex_digit = /[0-9a-f]_+[0-9a-f]|[0-9a-f]/i
+        rule /#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
+        rule /0b#{bin_digit}+/i, Num::Bin
+        rule /0x#{hex_digit}+/i, Num::Hex
+        rule /0#{oct_digit}+/, Num::Oct
+        rule /#{digit}+L?/, Num::Integer
+        rule /\n/, Text
+      end
+
+      state :class do
+        rule /\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :import do
+        rule /\s+/m, Text
+        rule /[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/javascript.rb

@@ -0,0 +1,283 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # IMPORTANT NOTICE:
+    #
+    # Please do not copy this lexer and open a pull request
+    # for a new language. It will not get merged, you will
+    # be unhappy, and kittens will cry.
+    #
+    class Javascript < RegexLexer
+      title "JavaScript"
+      desc "JavaScript, the browser scripting language"
+
+      tag 'javascript'
+      aliases 'js'
+      filenames '*.js', '*.mjs'
+      mimetypes 'application/javascript', 'application/x-javascript',
+                'text/javascript', 'text/x-javascript'
+
+      def self.detect?(text)
+        return 1 if text.shebang?('node')
+        return 1 if text.shebang?('jsc')
+        # TODO: rhino, spidermonkey, etc
+      end
+
+      state :multiline_comment do
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^*/]+), Comment::Multiline
+        rule %r([*/]), Comment::Multiline
+      end
+
+      state :comments_and_whitespace do
+        rule /\s+/, Text
+        rule /<!--/, Comment # really...?
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*]), Comment::Multiline, :multiline_comment
+      end
+
+      state :expr_start do
+        mixin :comments_and_whitespace
+
+        rule %r(/) do
+          token Str::Regex
+          goto :regex
+        end
+
+        rule /[{]/ do
+          token Punctuation
+          goto :object
+        end
+
+        rule //, Text, :pop!
+      end
+
+      state :regex do
+        rule %r(/) do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r([^/]\n), Error, :pop!
+
+        rule /\n/, Error, :pop!
+        rule /\[\^/, Str::Escape, :regex_group
+        rule /\[/, Str::Escape, :regex_group
+        rule /\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule /[{][\d,]+[}]/, Str::Escape
+        rule /[()?]/, Str::Escape
+        rule /./, Str::Regex
+      end
+
+      state :regex_end do
+        rule /[gim]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        # specially highlight / in a group to indicate that it doesn't
+        # close the regex
+        rule /\//, Str::Escape
+
+        rule %r([^/]\n) do
+          token Error
+          pop! 2
+        end
+
+        rule /\]/, Str::Escape, :pop!
+        rule /\\./, Str::Escape
+        rule /./, Str::Regex
+      end
+
+      state :bad_regex do
+        rule /[^\n]+/, Error, :pop!
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          for in of while do break return continue switch case default
+          if else throw try catch finally new delete typeof instanceof
+          void this yield import export from as async super this
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          var let const with function class
+          extends constructor get set
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          abstract boolean byte char debugger double enum
+          final float goto implements int interface
+          long native package private protected public short static
+          synchronized throws transient volatile
+          eval arguments await
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null NaN Infinity undefined)
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          Array Boolean Date Error Function Math netscape
+          Number Object Packages RegExp String sun decodeURI
+          decodeURIComponent encodeURI encodeURIComponent
+          Error eval isFinite isNaN parseFloat parseInt
+          document window navigator self global
+          Promise Set Map WeakSet WeakMap Symbol Proxy Reflect
+          Int8Array Uint8Array Uint8ClampedArray
+          Int16Array Uint16Array Uint16ClampedArray
+          Int32Array Uint32Array Uint32ClampedArray
+          Float32Array Float64Array DataView ArrayBuffer
+        )
+      end
+
+      def self.id_regex
+        /[$a-z_][a-z0-9_]*/io
+      end
+
+      id = self.id_regex
+
+      state :root do
+        rule /\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule %r((?<=\n)(?=\s|/|<!--)), Text, :expr_start
+        mixin :comments_and_whitespace
+        rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
+               | !== )x,
+          Operator, :expr_start
+        rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start
+        rule /[(\[,]/, Punctuation, :expr_start
+        rule /;/, Punctuation, :statement
+        rule /[)\].]/, Punctuation
+
+        rule /`/ do
+          token Str::Double
+          push :template_string
+        end
+
+        rule /[?]/ do
+          token Punctuation
+          push :ternary
+          push :expr_start
+        end
+
+        rule /(\@)(\w+)?/ do
+          groups Punctuation, Name::Decorator
+          push :expr_start
+        end
+
+        rule /[{}]/, Punctuation, :statement
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+            push :expr_start
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :expr_start
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule /0x[0-9a-fA-F]+/i, Num::Hex
+        rule /0o[0-7][0-7_]*/i, Num::Oct
+        rule /0b[01][01_]*/i, Num::Bin
+        rule /[0-9]+/, Num::Integer
+
+        rule /"/, Str::Double, :dq
+        rule /'/, Str::Single, :sq
+        rule /:/, Punctuation
+      end
+
+      state :dq do
+        rule /[^\\"]+/, Str::Double
+        rule /\\n/, Str::Escape
+        rule /\\"/, Str::Escape
+        rule /"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        rule /[^\\']+/, Str::Single
+        rule /\\'/, Str::Escape
+        rule /'/, Str::Single, :pop!
+      end
+
+      # braced parts that aren't object literals
+      state :statement do
+        rule /case\b/ do
+          token Keyword
+          goto :expr_start
+        end
+
+        rule /(#{id})(\s*)(:)/ do
+          groups Name::Label, Text, Punctuation
+        end
+
+        rule /[{}]/, Punctuation
+
+        mixin :expr_start
+      end
+
+      # object literals
+      state :object do
+        mixin :comments_and_whitespace
+
+        rule /[{]/ do
+          token Punctuation
+          push
+        end
+
+        rule /[}]/ do
+          token Punctuation
+          goto :statement
+        end
+
+        rule /(#{id})(\s*)(:)/ do
+          groups Name::Attribute, Text, Punctuation
+          push :expr_start
+        end
+
+        rule /:/, Punctuation
+        mixin :root
+      end
+
+      # ternary expressions, where <id>: is not a label!
+      state :ternary do
+        rule /:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
+        mixin :root
+      end
+
+      # template strings
+      state :template_string do
+        rule /\${/, Punctuation, :template_string_expr
+        rule /`/, Str::Double, :pop!
+        rule /(\\\\|\\[\$`]|[^\$`]|\$(?!{))*/, Str::Double
+      end
+
+      state :template_string_expr do
+        rule /}/, Punctuation, :pop!
+        mixin :root
+      end
+    end
+  end
+end

data/lib/rouge/lexers/jinja.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Jinja < TemplateLexer
+      title "Jinja"
+      desc "Django/Jinja template engine (jinja.pocoo.org)"
+
+      tag 'jinja'
+      aliases 'django'
+
+      mimetypes 'application/x-django-templating', 'application/x-jinja',
+                'text/html+django', 'text/html+jinja'
+
+      def self.keywords
+        @@keywords ||= %w(as context do else extends from ignore missing
+                          import include reversed recursive scoped
+                          autoescape endautoescape block endblock call endcall
+                          filter endfilter for endfor if endif macro endmacro
+                          set endset trans endtrans with endwith without)
+      end
+
+      def self.tests
+        @@tests ||= %w(callable defined divisibleby equalto escaped even iterable
+                       lower mapping none number odd sameas sequence string
+                       undefined upper)
+      end
+
+      def self.pseudo_keywords
+        @@pseudo_keywords ||= %w(true false none True False None)
+      end
+
+      def self.word_operators
+        @@word_operators ||= %w(is in and or not)
+      end
+
+      state :root do
+        # Comments
+        rule /{#/, Comment, :comment
+
+        # Statements
+        rule /\{\%/ do
+          token Comment::Preproc
+          push :statement
+        end
+
+        # Expressions
+        rule /\{\{/ do
+          token Comment::Preproc
+          push :expression
+        end
+
+        rule(/(.+?)(?=\\|{{|{%|{#)/m) { delegate parent }
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :filter do
+        # Filters are called like variable|foo(arg1, ...)
+        rule /(\|)(\w+)/ do
+          groups Operator, Name::Function
+        end
+      end
+
+      state :function do
+        rule /(\w+)(\()/ do
+          groups Name::Function, Punctuation
+        end
+      end
+
+      state :text do
+        rule /\s+/m, Text
+      end
+
+      state :literal do
+        # Strings
+        rule /"(\\.|.)*?"/, Str::Double
+        rule /'(\\.|.)*?'/, Str::Single
+
+        # Numbers
+        rule /\d+(?=}\s)/, Num
+
+        # Arithmetic operators (+, -, *, **, //, /)
+        # TODO : implement modulo (%)
+        rule /(\+|\-|\*|\/\/?|\*\*?|=)/, Operator
+
+        # Comparisons operators (<=, <, >=, >, ==, ===, !=)
+        rule /(<=?|>=?|===?|!=)/, Operator
+
+        # Punctuation (the comma, [], ())
+        rule /,/,  Punctuation
+        rule /\[/, Punctuation
+        rule /\]/, Punctuation
+        rule /\(/, Punctuation
+        rule /\)/, Punctuation
+      end
+
+      state :comment do
+        rule(/[^{#]+/m) { token Comment }
+        rule(/#}/) { token Comment; pop! }
+      end
+
+      state :expression do
+        rule /\w+\.?/m, Name::Variable
+
+        mixin :filter
+        mixin :function
+        mixin :literal
+        mixin :text
+
+        rule /%}|}}/, Comment::Preproc, :pop!
+      end
+
+      state :statement do
+        rule /(\w+\.?)/ do |m|
+          if self.class.keywords.include?(m[0])
+            groups Keyword
+          elsif self.class.pseudo_keywords.include?(m[0])
+            groups Keyword::Pseudo
+          elsif self.class.word_operators.include?(m[0])
+            groups Operator::Word
+          elsif self.class.tests.include?(m[0])
+            groups Name::Builtin
+          else
+            groups Name::Variable
+          end
+        end
+
+        mixin :filter
+        mixin :function
+        mixin :literal
+        mixin :text
+
+        rule /\%\}/, Comment::Preproc, :pop!
+      end
+    end
+  end
+end