rouge 3.18.0

data/lib/rouge/lexers/eex.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class EEX < TemplateLexer
+      title "EEX"
+      desc "Embedded Elixir"
+
+      tag 'eex'
+      aliases 'leex'
+
+      filenames '*.eex', '*.leex'
+
+      def initialize(opts={})
+        @elixir_lexer = Elixir.new(opts)
+
+        super(opts)
+      end
+
+      start do
+        parent.reset!
+        @elixir_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|<%/
+      close = /%%>|%>/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :elixir
+
+        rule %r/.+?(?=#{open})|.+/mo do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/mo, Comment
+      end
+
+      state :elixir do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/mo do
+          delegate @elixir_lexer
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/eiffel.rb

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Eiffel < RegexLexer
+      title "Eiffel"
+      desc "Eiffel programming language"
+
+      tag 'eiffel'
+      filenames '*.e'
+      mimetypes 'text/x-eiffel'
+
+      LanguageKeywords = %w(
+        across agent alias all and attached as assign attribute check
+        class convert create debug deferred detachable do else elseif end
+        ensure expanded export external feature from frozen if implies  inherit
+        inspect invariant like local loop not note obsolete old once or
+        Precursor redefine rename require rescue retry select separate
+        some then undefine until variant Void when xor
+      )
+
+      BooleanConstants = %w(True False)
+
+      LanguageVariables = %w(Current Result)
+
+      SimpleString = /(?:[^"%\b\f\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)+?/
+
+      state :root do
+        rule %r/"\[/, Str::Other, :aligned_verbatim_string
+        rule %r/"\{/, Str::Other, :non_aligned_verbatim_string
+        rule %r/"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
+        rule %r/--.*/, Comment::Single
+        rule %r/'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
+
+        rule %r/(?:#{LanguageKeywords.join('|')})\b/, Keyword
+        rule %r/(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
+        rule %r/(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
+
+        rule %r/\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
+        rule %r/\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
+        rule %r/\b0[bB][01](?:_*[01])*\b/, Num::Bin
+        rule %r/\d(?:_*\d)*/, Num::Integer
+        rule %r/(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
+
+        rule %r/:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
+        rule %r/\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
+
+        rule %r/[A-Z][\dA-Z_]*/, Name::Class
+        rule %r/[A-Za-z][\dA-Za-z_]*/, Name
+        rule %r/\s+/, Text
+      end
+
+      state :aligned_verbatim_string do
+        rule %r/]"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+
+      state :non_aligned_verbatim_string do
+        rule %r/}"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/elixir.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # Direct port of pygments Lexer.
+    # See: https://bitbucket.org/birkenfeld/pygments-main/src/7304e4759ae65343d89a51359ca538912519cc31/pygments/lexers/functional.py?at=default#cl-2362
+    class Elixir < RegexLexer
+      title "Elixir"
+      desc "Elixir language (elixir-lang.org)"
+
+      tag 'elixir'
+      aliases 'elixir', 'exs'
+
+      filenames '*.ex', '*.exs'
+
+      mimetypes 'text/x-elixir', 'application/x-elixir'
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/#.*$/, Comment::Single
+        rule %r{\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|
+             defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|
+             defexception|defguardp?|defstruct|exit|raise|throw|after|rescue|catch|else)\b(?![?!])|
+             (?<!\.)\b(do|\-\>)\b}x, Keyword
+        rule %r/\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, Keyword::Namespace
+        rule %r/(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
+        rule %r{%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|
+             <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s])\?|
+             (?<=[\s])!+|&(&&?|(?!\d))|\|\||\^|\*|\+|\-|/|
+             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.|~~~}x, Operator
+        rule %r{(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|
+             <=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|
+             \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, Str::Symbol
+        rule %r/:"/, Str::Symbol, :interpoling_symbol
+        rule %r/\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
+        rule %r/\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
+        rule %r/[a-zA-Z_!]\w*[!\?]?/, Name
+        rule %r{::|[%(){};,/\|:\\\[\]]}, Punctuation
+        rule %r/@[a-zA-Z_]\w*|&\d/, Name::Variable
+        rule %r{\b\d(_?\d)*(\.(?![^\d\s])(_?\d)+)([eE][-+]?\d(_?\d)*)?\b}, Num::Float
+        rule %r{\b0x[0-9A-Fa-f](_?[0-9A-Fa-f])*\b}, Num::Hex
+        rule %r{\b0o[0-7](_?[0-7])*\b}, Num::Oct
+        rule %r{\b0b[01](_?[01])*\b}, Num::Bin
+        rule %r{\b\d(_?\d)*\b}, Num::Integer
+
+        mixin :strings
+        mixin :sigil_strings
+      end
+
+      state :strings do
+        rule %r/(%[A-Ba-z])?"""(?:.|\n)*?"""/, Str::Doc
+        rule %r/'''(?:.|\n)*?'''/, Str::Doc
+        rule %r/"/, Str::Double, :dqs
+        rule %r/'/, Str::Single, :sqs
+        rule %r{(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b[^x0MC])|(\\[MC]-)+\w|[^\s\\])}, Str::Other
+      end
+
+      state :dqs do
+        mixin :escapes
+        mixin :interpoling
+        rule %r/[^#"\\]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[#\\]/, Str::Double
+      end
+
+      state :sqs do
+        mixin :escapes
+        mixin :interpoling
+        rule %r/[^#'\\]+/, Str::Single
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[#\\]/, Str::Single
+      end
+
+      state :interpoling do
+        rule %r/#\{/, Str::Interpol, :interpoling_string
+      end
+
+      state :interpoling_string do
+        rule %r/\}/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      state :escapes do
+        rule %r/\\x\h{2}/, Str::Escape
+        rule %r/\\u\{?\d+\}?/, Str::Escape
+        rule %r/\\[\\abdefnrstv0"']/, Str::Escape
+      end
+
+      state :interpoling_symbol do
+        rule %r/"/, Str::Symbol, :pop!
+        mixin :interpoling
+        rule %r/[^#"]+/, Str::Symbol
+      end
+
+      state :sigil_strings do
+        # ~-sigiled strings
+        # ~(abc), ~[abc], ~<abc>, ~|abc|, ~r/abc/, etc
+        # Cribbed and adjusted from Ruby lexer
+        delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
+        # Match a-z for custom sigils too
+        sigil_opens = Regexp.union(delimiter_map.keys + %w(| / ' "))
+        rule %r/~([A-Za-z])?(#{sigil_opens})/ do |m|
+          open = Regexp.escape(m[2])
+          close = Regexp.escape(delimiter_map[m[2]] || m[2])
+          interp = /[SRCW]/ === m[1]
+          toktype = Str::Other
+
+          puts "    open: #{open.inspect}" if @debug
+          puts "    close: #{close.inspect}" if @debug
+
+          # regexes
+          if 'Rr'.include? m[1]
+            toktype = Str::Regex
+            push :regex_flags
+          end
+
+          if 'Ww'.include? m[1]
+            push :list_flags
+          end
+
+          token toktype
+
+          push do
+            rule %r/#{close}/, toktype, :pop!
+
+            if interp
+              mixin :interpoling
+              rule %r/#/, toktype
+            else
+              rule %r/[\\#]/, toktype
+            end
+
+            uniq_chars = "#{open}#{close}".squeeze
+            rule %r/[^##{uniq_chars}\\]+/m, toktype
+          end
+        end
+      end
+
+      state :regex_flags do
+        rule %r/[fgimrsux]*/, Str::Regex, :pop!
+      end
+
+      state :list_flags do
+        rule %r/[csa]?/, Str::Other, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/elm.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Elm < RegexLexer
+      title "Elm"
+      desc "The Elm programming language (http://elm-lang.org/)"
+
+      tag 'elm'
+      filenames '*.elm'
+      mimetypes 'text/x-elm'
+
+      # Keywords are logically grouped by lines
+      keywords = %w(
+        module exposing port
+        import as
+        type alias
+        if then else
+        case of
+        let in
+      )
+
+      state :root do
+        # Whitespaces
+        rule %r/\s+/m, Text
+        # Single line comments
+        rule %r/--.*/, Comment::Single
+        # Multiline comments
+        rule %r/{-/, Comment::Multiline, :multiline_comment
+
+        # Keywords
+        rule %r/\b(#{keywords.join('|')})\b/, Keyword
+
+        # Variable or a function
+        rule %r/[a-z]\w*/, Name
+        # Underscore is a name for a variable, when it won't be used later
+        rule %r/_/, Name
+        # Type
+        rule %r/[A-Z]\w*/, Keyword::Type
+
+        # Two symbol operators: -> :: // .. && || ++ |> <| << >> == /= <= >=
+        rule %r/(->|::|\/\/|\.\.|&&|\|\||\+\+|\|>|<\||>>|<<|==|\/=|<=|>=)/, Operator
+        # One symbol operators: + - / * % = < > ^ | !
+        rule %r/[+-\/*%=<>^\|!]/, Operator
+        # Lambda operator
+        rule %r/\\/, Operator
+        # Not standard Elm operators, but these symbols can be used for custom inflix operators. We need to highlight them as operators as well.
+        rule %r/[@\#$&~?]/, Operator
+
+        # Single, double quotes, and triple double quotes
+        rule %r/"""/, Str, :multiline_string
+        rule %r/'(\\.|.)'/, Str::Char
+        rule %r/"/, Str, :double_quote
+
+        # Numbers
+        rule %r/0x[\da-f]+/i, Num::Hex
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/\d+\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule %r/\d+/, Num::Integer
+
+        # Punctuation: [ ] ( ) , ; ` { } :
+        rule %r/[\[\](),;`{}:]/, Punctuation
+      end
+
+      # Multiline and nested commenting
+      state :multiline_comment do
+        rule %r/-}/, Comment::Multiline, :pop!
+        rule %r/{-/, Comment::Multiline, :multiline_comment
+        rule %r/[^-{}]+/, Comment::Multiline
+        rule %r/[-{}]/, Comment::Multiline
+      end
+
+      # Double quotes
+      state :double_quote do
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/\\"/, Str::Escape
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      # Multiple line string with tripple double quotes, e.g. """ multi """
+      state :multiline_string do
+        rule %r/\s*"""/, Str, :pop!
+        rule %r/.*/, Str
+        rule %r/\s*/, Str
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/epp.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class EPP < TemplateLexer
+      title "EPP"
+      desc "Embedded Puppet template files"
+
+      tag 'epp'
+
+      filenames '*.epp'
+
+      def initialize(opts={})
+        super(opts)
+        @parent = lexer_option(:parent) { PlainText.new(opts) }
+        @puppet_lexer = Puppet.new(opts)
+      end
+
+      start do
+        parent.reset!
+        @puppet_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|(<%-|<%)(\s*\|)?/
+      close = /%%>|(\|\s*)?(-%>|%>)/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :puppet
+
+        rule %r/.+?(?=#{open})|.+/m do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/m, Comment
+      end
+
+      state :puppet do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/m do
+          delegate @puppet_lexer
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/erb.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ERB < TemplateLexer
+      title "ERB"
+      desc "Embedded ruby template files"
+
+      tag 'erb'
+      aliases 'eruby', 'rhtml'
+
+      filenames '*.erb', '*.erubis', '*.rhtml', '*.eruby'
+
+      def initialize(opts={})
+        @ruby_lexer = Ruby.new(opts)
+
+        super(opts)
+      end
+
+      start do
+        parent.reset!
+        @ruby_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|<%-|<%/
+      close = /%%>|-%>|%>/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :ruby
+
+        rule %r/.+?(?=#{open})|.+/m do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/m, Comment
+      end
+
+      state :ruby do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/m do
+          delegate @ruby_lexer
+        end
+      end
+    end
+  end
+end