rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/actionscript.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -12,7 +13,7 @@ module Rouge
       mimetypes 'application/x-actionscript'
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/\*.*?\*/)m, Comment::Multiline
       end
@@ -25,9 +26,9 @@ module Rouge
           goto :regex
         end
 
-        rule /[{]/, Punctuation, :object
+        rule %r/[{]/, Punctuation, :object
 
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :regex do
@@ -38,38 +39,38 @@ module Rouge
 
         rule %r([^/]\n), Error, :pop!
 
-        rule /\n/, Error, :pop!
-        rule /\[\^/, Str::Escape, :regex_group
-        rule /\[/, Str::Escape, :regex_group
-        rule /\\./, Str::Escape
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
         rule %r{[(][?][:=<!]}, Str::Escape
-        rule /[{][\d,]+[}]/, Str::Escape
-        rule /[()?]/, Str::Escape
-        rule /./, Str::Regex
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :regex_end do
-        rule /[gim]+/, Str::Regex, :pop!
+        rule %r/[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(/), Str::Escape
 
         rule %r([^/]\n) do
           token Error
           pop! 2
         end
 
-        rule /\]/, Str::Escape, :pop!
-        rule /\\./, Str::Escape
-        rule /./, Str::Regex
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :bad_regex do
-        rule /[^\n]+/, Error, :pop!
+        rule %r/[^\n]+/, Error, :pop!
       end
 
       def self.keywords
@@ -108,25 +109,25 @@ module Rouge
       id = /[$a-zA-Z_][a-zA-Z0-9_]*/
 
       state :root do
-        rule /\A\s*#!.*?\n/m, Comment::Preproc, :statement
-        rule /\n/, Text, :statement
+        rule %r/\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule %r/\n/, Text, :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 %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
 
-        rule /[?]/ do
+        rule %r/[?]/ do
           token Punctuation
           push :ternary
           push :expr_start
         end
 
-        rule /[{}]/, Punctuation, :statement
+        rule %r/[{}]/, Punctuation, :statement
 
         rule id do |m|
           if self.class.keywords.include? m[0]
@@ -146,20 +147,20 @@ module Rouge
           end
         end
 
-        rule /\-?[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
-        rule /0x[0-9a-fA-F]+/, Num::Hex
-        rule /\-?[0-9]+/, Num::Integer
-        rule /"(\\\\|\\"|[^"])*"/, Str::Double
-        rule /'(\\\\|\\'|[^'])*'/, Str::Single
+        rule %r/\-?[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/\-?[0-9]+/, Num::Integer
+        rule %r/"(\\\\|\\"|[^"])*"/, Str::Double
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
       end
 
       # braced parts that aren't object literals
       state :statement do
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
         end
 
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         mixin :expr_start
       end
@@ -167,23 +168,23 @@ module Rouge
       # object literals
       state :object do
         mixin :comments_and_whitespace
-        rule /[}]/ do
+        rule %r/[}]/ do
           token Punctuation
           goto :statement
         end
 
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Attribute, Text, Punctuation
           push :expr_start
         end
 
-        rule /:/, Punctuation
+        rule %r/:/, Punctuation
         mixin :root
       end
 
       # ternary expressions, where <id>: is not a label!
       state :ternary do
-        rule /:/ do
+        rule %r/:/ do
           token Punctuation
           goto :expr_start
         end

data/lib/rouge/lexers/ada.rb

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Ada < RegexLexer
+      tag 'ada'
+      filenames '*.ada', '*.ads', '*.adb', '*.gpr'
+      mimetypes 'text/x-ada'
+
+      title 'Ada'
+      desc 'The Ada 2012 programming language'
+
+      # Ada identifiers are Unicode with underscores only allowed as separators.
+      ID = /\b[[:alpha:]](?:\p{Pc}?[[:alnum:]])*\b/
+
+      # Numerals can also contain underscores.
+      NUM = /\d(_?\d)*/
+      XNUM = /\h(_?\h)*/
+      EXP = /(E[-+]?#{NUM})?/i
+
+      # Return a hash mapping lower-case identifiers to token classes.
+      def self.idents
+        @idents ||= Hash.new(Name).tap do |h|
+          %w(
+            abort abstract accept access aliased all array at begin body
+            case constant declare delay delta digits do else elsif end
+            exception exit for generic goto if in interface is limited
+            loop new null of others out overriding pragma private
+            protected raise range record renames requeue return reverse
+            select separate some synchronized tagged task terminate then
+            until use when while with
+          ).each {|w| h[w] = Keyword}
+
+          %w(abs and mod not or rem xor).each {|w| h[w] = Operator::Word}
+
+          %w(
+            entry function package procedure subtype type
+          ).each {|w| h[w] = Keyword::Declaration}
+
+          %w(
+            boolean character constraint_error duration float integer
+            natural positive long_float long_integer long_long_float
+            long_long_integer program_error short_float short_integer
+            short_short_integer storage_error string tasking_error
+            wide_character wide_string wide_wide_character
+            wide_wide_string
+          ).each {|w| h[w] = Name::Builtin}
+        end
+      end
+
+      state :whitespace do
+        rule %r{\s+}m, Text
+        rule %r{--.*$}, Comment::Single
+      end
+
+      state :dquote_string do
+        rule %r{[^"\n]+}, Literal::String::Double
+        rule %r{""}, Literal::String::Escape
+        rule %r{"}, Literal::String::Double, :pop!
+        rule %r{\n}, Error, :pop!
+      end
+
+      state :attr do
+        mixin :whitespace
+        rule ID, Name::Attribute, :pop!
+        rule %r{}, Text, :pop!
+      end
+
+      # Handle a dotted name immediately following a declaration keyword.
+      state :decl_name do
+        mixin :whitespace
+        rule %r{body\b}i, Keyword::Declaration  # package body Foo.Bar is...
+        rule %r{(#{ID})(\.)} do
+          groups Name::Namespace, Punctuation
+        end
+        # function "<=" (Left, Right: Type) is ...
+        rule %r{#{ID}|"(and|or|xor|/?=|<=?|>=?|\+|–|&\|/|mod|rem|\*?\*|abs|not)"},
+             Name::Function, :pop!
+        rule %r{}, Text, :pop!
+      end
+
+      # Handle a sequence of library unit names: with Ada.Foo, Ada.Bar;
+      #
+      # There's a chance we entered this state mistakenly since 'with'
+      # has multiple other uses in Ada (none of which are likely to
+      # appear at the beginning of a line). Try to bail as soon as
+      # possible if we see something suspicious like keywords.
+      #
+      # See ada_spec.rb for some examples.
+      state :libunit_name do
+        mixin :whitespace
+
+        rule ID do |m|
+          t = self.class.idents[m[0].downcase]
+          if t <= Name
+            # Convert all kinds of Name to namespaces in this context.
+            token Name::Namespace
+          else
+            # Yikes, we're not supposed to get a keyword in a library unit name!
+            # We probably entered this state by mistake, so try to fix it.
+            token t
+            if t == Keyword::Declaration
+              goto :decl_name
+            else
+              pop!
+            end
+          end
+        end
+
+        rule %r{[.,]}, Punctuation
+        rule %r{}, Text, :pop!
+      end
+
+      state :root do
+        mixin :whitespace
+
+        # String literals.
+        rule %r{'.'}, Literal::String::Char
+        rule %r{"[^"\n]*}, Literal::String::Double, :dquote_string
+
+        # Real literals.
+        rule %r{#{NUM}\.#{NUM}#{EXP}}, Literal::Number::Float
+        rule %r{#{NUM}##{XNUM}\.#{XNUM}##{EXP}}, Literal::Number::Float
+
+        # Integer literals.
+        rule %r{2#[01](_?[01])*##{EXP}}, Literal::Number::Bin
+        rule %r{8#[0-7](_?[0-7])*##{EXP}}, Literal::Number::Oct
+        rule %r{16##{XNUM}*##{EXP}}, Literal::Number::Hex
+        rule %r{#{NUM}##{XNUM}##{EXP}}, Literal::Number::Integer
+        rule %r{#{NUM}#\w+#}, Error
+        rule %r{#{NUM}#{EXP}}, Literal::Number::Integer
+
+        # Special constructs.
+        rule %r{'}, Punctuation, :attr
+        rule %r{<<#{ID}>>}, Name::Label
+
+        # Context clauses are tricky because the 'with' keyword is used
+        # for many purposes. Detect at beginning of the line only.
+        rule %r{^(?:(limited)(\s+))?(?:(private)(\s+))?(with)\b}i do
+          groups Keyword::Namespace, Text, Keyword::Namespace, Text, Keyword::Namespace
+          push :libunit_name
+        end
+
+        # Operators and punctuation characters.
+        rule %r{[+*/&<=>|]|-|=>|\.\.|\*\*|[:></]=|<<|>>|<>}, Operator
+        rule %r{[.,:;()]}, Punctuation
+
+        rule ID do |m|
+          t = self.class.idents[m[0].downcase]
+          token t
+          if t == Keyword::Declaration
+            push :decl_name
+          end
+        end
+
+        # Flag word-like things that don't match the ID pattern.
+        rule %r{\b(\p{Pc}|[[alpha]])\p{Word}*}, Error
+      end
+    end
+  end
+end

data/lib/rouge/lexers/apache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module Rouge
@@ -9,14 +11,10 @@ module Rouge
       mimetypes 'text/x-httpd-conf', 'text/x-apache-conf'
       filenames '.htaccess', 'httpd.conf'
 
-      class << self
-        attr_reader :keywords
-      end
-      # Load Apache keywords from separate YML file
-      @keywords = ::YAML.load_file(Pathname.new(__FILE__).dirname.join('apache/keywords.yml')).tap do |h|
-        h.each do |k,v|
-          h[k] = Set.new v
-        end
+      # self-modifying method that loads the keywords file
+      def self.keywords
+        load File.join(Lexers::BASE_DIR, 'apache/keywords.rb')
+        keywords
       end
 
       def name_for_token(token, kwtype, tktype)
@@ -28,19 +26,19 @@ module Rouge
       end
 
       state :whitespace do
-        rule /\#.*/, Comment
-        rule /\s+/m, Text
+        rule %r/\#.*/, Comment
+        rule %r/\s+/m, Text
       end
 
       state :root do
         mixin :whitespace
 
-        rule /(<\/?)(\w+)/ do |m|
+        rule %r/(<\/?)(\w+)/ do |m|
           groups Punctuation, name_for_token(m[2].downcase, :sections, Name::Label)
           push :section
         end
 
-        rule /\w+/ do |m|
+        rule %r/\w+/ do |m|
           token name_for_token(m[0].downcase, :directives, Name::Class)
           push :directive
         end
@@ -48,7 +46,7 @@ module Rouge
 
       state :section do
         # Match section arguments
-        rule /([^>]+)?(>(?:\r\n?|\n)?)/ do |m|
+        rule %r/([^>]+)?(>(?:\r\n?|\n)?)/ do
           groups Literal::String::Regex, Punctuation
           pop!
         end
@@ -58,11 +56,11 @@ module Rouge
 
       state :directive do
         # Match value literals and other directive arguments
-        rule /\r\n?|\n/, Text, :pop!
+        rule %r/\r\n?|\n/, Text, :pop!
 
         mixin :whitespace
 
-        rule /\S+/ do |m|
+        rule %r/\S+/ do |m|
           token name_for_token(m[0], :values, Literal::String::Symbol)
         end
       end

data/lib/rouge/lexers/apache/keywords.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# automatically generated by `rake builtins:apache`
+module Rouge
+  module Lexers
+    def Apache.keywords
+      @keywords ||= {}.tap do |h|
+        h[:sections] = Set.new ["directory", "directorymatch", "files", "filesmatch", "ifdefine", "ifmodule", "limit", "limitexcept", "location", "locationmatch", "proxy", "proxymatch", "virtualhost"]
+        h[:directives] = Set.new ["acceptfilter", "acceptmutex", "acceptpathinfo", "accessconfig", "accessfilename", "action", "addalt", "addaltbyencoding", "addaltbytype", "addcharset", "adddefaultcharset", "adddescription", "addencoding", "addhandler", "addicon", "addiconbyencoding", "addiconbytype", "addinputfilter", "addlanguage", "addmodule", "addmoduleinfo", "addoutputfilter", "addoutputfilterbytype", "addtype", "agentlog", "alias", "aliasmatch", "allow", "allowconnect", "allowencodedslashes", "allowmethods", "allowoverride", "allowoverridelist", "anonymous", "anonymous_authoritative", "anonymous_logemail", "anonymous_mustgiveemail", "anonymous_nouserid", "anonymous_verifyemail", "assignuserid", "authauthoritative", "authdbauthoritative", "authdbgroupfile", "authdbmauthoritative", "asyncrequestworkerfactor", "authbasicauthoritative", "authbasicfake", "authbasicprovider", "authbasicusedigestalgorithm", "authdbduserpwquery", "authdbduserrealmquery", "authdbmgroupfile", "authdbmtype", "authdbmuserfile", "authdbuserfile", "authdigestalgorithm", "authdigestdomain", "authdigestfile", "authdigestgroupfile", "authdigestnccheck", "authdigestnonceformat", "authdigestnoncelifetime", "authdigestprovider", "authdigestqop", "authdigestshmemsize", "authformauthoritative", "authformbody", "authformdisablenostore", "authformfakebasicauth", "authformlocation", "authformloginrequiredlocation", "authformloginsuccesslocation", "authformlogoutlocation", "authformmethod", "authformmimetype", "authformpassword", "authformprovider", "authformsitepassphrase", "authformsize", "authformusername", "authgroupfile", "authldapauthoritative", "authldapauthorizeprefix", "authldapbindauthoritative", "authldapbinddn", "authldapbindpassword", "authldapcharsetconfig", "authldapcompareasuser", "authldapcomparednonserver", "authldapdereferencealiases", "authldapenabled", "authldapfrontpagehack", "authldapgroupattribute", "authldapgroupattributeisdn", "authldapinitialbindasuser", "authldapinitialbindpattern", "authldapmaxsubgroupdepth", "authldapremoteuserattribute", "authldapremoteuserisdn", "authldapsearchasuser", "authldapsubgroupattribute", "authldapsubgroupclass", "authldapurl", "authmerging", "authname", "authncachecontext", "authncacheenable", "authncacheprovidefor", "authncachesocache", "authncachetimeout", "authnzfcgicheckauthnprovider", "authnzfcgidefineprovider", "authtype", "authuserfile", "authzdbdlogintoreferer", "authzdbdquery", "authzdbdredirectquery", "authzdbmtype", "authzsendforbiddenonfailure", "balancergrowth", "balancerinherit", "balancermember", "balancerpersist", "bindaddress", "browsermatch", "browsermatchnocase", "bs2000account", "bufferedlogs", "buffersize", "cachedefaultexpire", "cachedetailheader", "cachedirlength", "cachedirlevels", "cachedisable", "cacheenable", "cacheexpirycheck", "cachefile", "cacheforcecompletion", "cachegcclean", "cachegcdaily", "cachegcinterval", "cachegcmemusage", "cachegcunused", "cacheheader", "cacheignorecachecontrol", "cacheignoreheaders", "cacheignorenolastmod", "cacheignorequerystring", "cacheignoreurlsessionidentifiers", "cachekeybaseurl", "cachelastmodifiedfactor", "cachelock", "cachelockmaxage", "cachelockpath", "cachemaxexpire", "cachemaxfilesize", "cacheminexpire", "cacheminfilesize", "cachenegotiateddocs", "cachequickhandler", "cachereadsize", "cachereadtime", "cacheroot", "cachesize", "cachetimemargin", "cachesocache", "cachesocachemaxsize", "cachesocachemaxtime", "cachesocachemintime", "cachesocachereadsize", "cachesocachereadtime", "cachestaleonerror", "cachestoreexpired", "cachestorenostore", "cachestoreprivate", "cgidscripttimeout", "cgimapextension", "cgipassauth", "charsetdefault", "charsetoptions", "charsetsourceenc", "checkcaseonly", "checkspelling", "childperuserid", "clearmodulelist", "chrootdir", "contentdigest", "cookiedomain", "cookieexpires", "cookielog", "cookiename", "cookiestyle", "cookietracking", "coredumpdirectory", "customlog", "dav", "davdepthinfinity", "davgenericlockdb", "davlockdb", "davmintimeout", "dbdexptime", "dbdinitsql", "dbdkeep", "dbdmax", "dbdmin", "dbdparams", "dbdpersist", "dbdpreparesql", "dbdriver", "defaulticon", "defaultlanguage", "defaultmode", "defaultruntimedir", "defaulttype", "define", "deflatebuffersize", "deflatecompressionlevel", "deflatefilternote", "deflateinflatelimitrequestbody", "deflateinflateratioburst", "deflateinflateratiolimit", "deflatememlevel", "deflatewindowsize", "deny", "directorycheckhandler", "directoryindex", "directoryindexredirect", "directoryslash", "doctitle", "doctrailer", "documentroot", "dtraceprivileges", "dumpioinput", "dumpiooutput", "enableexceptionhook", "enablemmap", "enablesendfile", "error", "errordocument", "errorlog", "errorlogformat", "example", "expiresactive", "expiresbytype", "expiresdefault", "extendedstatus", "extfilterdefine", "extfilteroptions", "fallbackresource", "fancyindexing", "fileetag", "filterchain", "filterdeclare", "filterprotocol", "filterprovider", "filtertrace", "forcelanguagepriority", "forcetype", "forensiclog", "globallog", "gprofdir", "gracefulshutdowntimeout", "group", "h2direct", "h2keepalivetimeout", "h2maxsessionstreams", "h2maxworkeridleseconds", "h2maxworkers", "h2minworkers", "h2moderntlsonly", "h2push", "h2pushdiarysize", "h2pushpriority", "h2serializeheaders", "h2sessionextrafiles", "h2streammaxmemsize", "h2streamtimeout", "h2timeout", "h2tlscooldownsecs", "h2tlswarmupsize", "h2upgrade", "h2windowsize", "header", "headername", "headprefix", "headsuffix", "hidesys", "hideurl", "heartbeataddress", "heartbeatlisten", "heartbeatmaxservers", "heartbeatstorage", "heartbeatstorage", "hostnamelookups", "htmldir", "httplogfile", "identitycheck", "identitychecktimeout", "imapbase", "imapdefault", "imapmenu", "include", "includeoptional", "indexheadinsert", "indexignore", "indexignorereset", "indexoptions", "indexorderdefault", "indexstylesheet", "inputsed", "isapiappendlogtoerrors", "isapiappendlogtoquery", "isapicachefile", "isapifakeasync", "isapilognotsupported", "isapireadaheadbuffer", "keepalive", "keepalivetimeout", "keptbodysize", "languagepriority", "lasturls", "ldapcacheentries", "ldapcachettl", "ldapconnectionpoolttl", "ldapconnectiontimeout", "ldaplibrarydebug", "ldapopcacheentries", "ldapopcachettl", "ldapreferralhoplimit", "ldapreferrals", "ldapretries", "ldapretrydelay", "ldapsharedcachefile", "ldapsharedcachesize", "ldaptimeout", "ldaptrustedca", "ldaptrustedcatype", "ldaptrustedclientcert", "ldaptrustedglobalcert", "ldaptrustedmode", "ldapverifyservercert", "limitinternalrecursion", "limitrequestbody", "limitrequestfields", "limitrequestfieldsize", "limitrequestline", "limitxmlrequestbody", "listen", "listenbacklog", "listencoresbucketsratio", "loadfile", "loadmodule", "lockfile", "logformat", "logiotrackttfb", "loglevel", "logmessage", "luaauthzprovider", "luacodecache", "luahookaccesschecker", "luahookauthchecker", "luahookcheckuserid", "luahookfixups", "luahookinsertfilter", "luahooklog", "luahookmaptostorage", "luahooktranslatename", "luahooktypechecker", "luainherit", "luainputfilter", "luamaphandler", "luaoutputfilter", "luapackagecpath", "luapackagepath", "luaquickhandler", "luaroot", "luascope", "maxclients", "maxconnectionsperchild", "maxkeepaliverequests", "maxmemfree", "maxrequestsperchild", "maxrequestsperthread", "maxrangeoverlaps", "maxrangereversals", "maxranges", "maxrequestworkers", "maxspareservers", "maxsparethreads", "maxthreads", "maxthreadsperchild", "mcachemaxobjectcount", "mcachemaxobjectsize", "mcachemaxstreamingbuffer", "mcacheminobjectsize", "mcacheremovalalgorithm", "mcachesize", "memcacheconnttl", "mergetrailers", "metadir", "metafiles", "metasuffix", "mimemagicfile", "minspareservers", "minsparethreads", "mmapfile", "modemstandard", "modmimeusepathinfo", "multiviewsmatch", "mutex", "namevirtualhost", "nocache", "noproxy", "numservers", "nwssltrustedcerts", "nwsslupgradeable", "options", "order", "outputsed", "passenv", "pidfile", "port", "privatedir", "privilegesmode", "protocol", "protocolecho", "protocols", "protocolshonororder", "proxyaddheaders", "proxybadheader", "proxyblock", "proxydomain", "proxyerroroverride", "proxyexpressdbmfile", "proxyexpressdbmtype", "proxyexpressenable", "proxyftpdircharset", "proxyftpescapewildcards", "proxyftplistonwildcard", "proxyhtmlbufsize", "proxyhtmlcharsetout", "proxyhtmldoctype", "proxyhtmlenable", "proxyhtmlevents", "proxyhtmlextended", "proxyhtmlfixups", "proxyhtmlinterp", "proxyhtmllinks", "proxyhtmlmeta", "proxyhtmlstripcomments", "proxyhtmlurlmap", "proxyiobuffersize", "proxymaxforwards", "proxypass", "proxypassinherit", "proxypassinterpolateenv", "proxypassmatch", "proxypassreverse", "proxypassreversecookiedomain", "proxypassreversecookiepath", "proxypreservehost", "proxyreceivebuffersize", "proxyremote", "proxyremotematch", "proxyrequests", "proxyscgiinternalredirect", "proxyscgisendfile", "proxyset", "proxysourceaddress", "proxystatus", "proxytimeout", "proxyvia", "qualifyredirecturl", "readmename", "receivebuffersize", "redirect", "redirectmatch", "redirectpermanent", "redirecttemp", "refererignore", "refererlog", "reflectorheader", "remoteipheader", "remoteipinternalproxy", "remoteipinternalproxylist", "remoteipproxiesheader", "remoteiptrustedproxy", "remoteiptrustedproxylist", "removecharset", "removeencoding", "removehandler", "removeinputfilter", "removelanguage", "removeoutputfilter", "removetype", "requestheader", "requestreadtimeout", "require", "resourceconfig", "rewritebase", "rewritecond", "rewriteengine", "rewritelock", "rewritelog", "rewriteloglevel", "rewritemap", "rewriteoptions", "rewriterule", "rlimitcpu", "rlimitmem", "rlimitnproc", "satisfy", "scoreboardfile", "script", "scriptalias", "scriptaliasmatch", "scriptinterpretersource", "scriptlog", "scriptlogbuffer", "scriptloglength", "scriptsock", "securelisten", "seerequesttail", "sendbuffersize", "serveradmin", "serveralias", "serverlimit", "servername", "serverpath", "serverroot", "serversignature", "servertokens", "servertype", "session", "sessioncookiename", "sessioncookiename2", "sessioncookieremove", "sessioncryptocipher", "sessioncryptodriver", "sessioncryptopassphrase", "sessioncryptopassphrasefile", "sessiondbdcookiename", "sessiondbdcookiename2", "sessiondbdcookieremove", "sessiondbddeletelabel", "sessiondbdinsertlabel", "sessiondbdperuser", "sessiondbdselectlabel", "sessiondbdupdatelabel", "sessionenv", "sessionexclude", "sessionheader", "sessioninclude", "sessionmaxage", "setenv", "setenvif", "setenvifexpr", "setenvifnocase", "sethandler", "setinputfilter", "setoutputfilter", "ssiendtag", "ssierrormsg", "ssietag", "ssilastmodified", "ssilegacyexprparser", "ssistarttag", "ssitimeformat", "ssiundefinedecho", "sslcacertificatefile", "sslcacertificatepath", "sslcadnrequestfile", "sslcadnrequestpath", "sslcarevocationcheck", "sslcarevocationfile", "sslcarevocationpath", "sslcertificatechainfile", "sslcertificatefile", "sslcertificatekeyfile", "sslciphersuite", "sslcompression", "sslcryptodevice", "sslengine", "sslfips", "sslhonorcipherorder", "sslinsecurerenegotiation", "sslmutex", "sslocspdefaultresponder", "sslocspenable", "sslocspoverrideresponder", "sslocspproxyurl", "sslocsprespondertimeout", "sslocspresponsemaxage", "sslocspresponsetimeskew", "sslocspuserequestnonce", "sslopensslconfcmd", "ssloptions", "sslpassphrasedialog", "sslprotocol", "sslproxycacertificatefile", "sslproxycacertificatepath", "sslproxycarevocationcheck", "sslproxycarevocationfile", "sslproxycarevocationpath", "sslproxycheckpeercn", "sslproxycheckpeerexpire", "sslproxycheckpeername", "sslproxyciphersuite", "sslproxyengine", "sslproxymachinecertificatechainfile", "sslproxymachinecertificatefile", "sslproxymachinecertificatepath", "sslproxyprotocol", "sslproxyverify", "sslproxyverifydepth", "sslrandomseed", "sslrenegbuffersize", "sslrequire", "sslrequiressl", "sslsessioncache", "sslsessioncachetimeout", "sslsessionticketkeyfile", "sslsessiontickets", "sslsrpunknownuserseed", "sslsrpverifierfile", "sslstaplingcache", "sslstaplingerrorcachetimeout", "sslstaplingfaketrylater", "sslstaplingforceurl", "sslstaplingrespondertimeout", "sslstaplingresponsemaxage", "sslstaplingresponsetimeskew", "sslstaplingreturnrespondererrors", "sslstaplingstandardcachetimeout", "sslstrictsnivhostcheck", "sslusername", "sslusestapling", "sslverifyclient", "sslverifydepth", "startservers", "startthreads", "substitute", "substituteinheritbefore", "substitutemaxlinelength", "suexec", "suexecusergroup", "threadlimit", "threadsperchild", "threadstacksize", "timeout", "topsites", "topurls", "traceenable", "transferlog", "typesconfig", "undefine", "undefmacro", "unsetenv", "use", "usecanonicalname", "usecanonicalphysicalport", "user", "userdir", "vhostcgimode", "vhostcgiprivs", "vhostgroup", "vhostprivs", "vhostsecure", "vhostuser", "virtualdocumentroot", "virtualdocumentrootip", "virtualscriptalias", "virtualscriptaliasip", "win32disableacceptex", "watchdoginterval", "xbithack", "xml2encalias", "xml2encdefault", "xml2startparse"]
+        h[:values] = Set.new ["add", "All", "allow", "any", "append", "AuthConfig", "Basic", "CONNECT", "DELETE", "deny", "Digest", "double", "downgrade-1.0", "email", "env", "error", "ExecCGI", "FancyIndexing", "FileInfo", "FollowSymLinks", "force-response-1.0", "formatted", "from", "full", "Full", "GET", "gone", "group", "IconsAreLinks", "Includes", "IncludesNOEXEC", "Indexes", "inetd", "inherit", "Limit", "map", "Minimal", "MultiViews", "mutual-failure", "nocontent", "nokeepalive", "none", "None", "off", "on", "Options", "OPTIONS", "OS", "permanent", "POST", "PUT", "referer", "ScanHTMLTitles", "seeother", "semi-formatted", "set", "standalone", "SuppressDescription", "SuppressLastModified", "SuppressSize", "SymLinksIfOwnerMatch", "temporary", "unformatted", "unset", "URL", "user", "valid-user"]
+      end
+    end
+  end
+end

data/lib/rouge/lexers/apex.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Apex < RegexLexer
+      title "Apex"
+      desc "The Apex programming language (provided by salesforce)"
+
+      tag 'apex'
+      filenames '*.cls'
+      mimetypes 'text/x-apex'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          assert break case catch continue default do else finally for if goto
+          instanceof new return switch this throw try while insert update
+          delete
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          abstract const enum extends final implements native private protected
+          public static super synchronized throws transient volatile with
+          sharing without inherited virtual global testmethod
+        )
+      end
+
+      def self.soql
+        @soql ||= Set.new %w(
+          SELECT FROM WHERE UPDATE LIKE TYPEOF END USING SCOPE WITH DATA
+          CATEGORY GROUP BY ROLLUP CUBE HAVING ORDER BY ASC DESC NULLS FIRST
+          LAST LIMIT OFFSET FOR VIEW REFERENCE UPDATE TRACKING VIEWSTAT OR AND
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          String boolean byte char double float int long short var void
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      id = /[a-z_][a-z0-9_]*/i
+
+      state :root do
+        rule %r/\s+/m, Text
+        
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/import\b/, Keyword::Namespace, :import
+
+        rule %r/([@$.]?)(#{id})([:(]?)/io do |m|
+          if self.class.keywords.include? m[0].downcase
+            token Keyword
+          elsif self.class.soql.include? m[0].upcase
+            token Keyword
+          elsif self.class.declarations.include? m[0].downcase
+            token Keyword::Declaration
+          elsif self.class.types.include? m[0].downcase
+            token Keyword::Type
+          elsif self.class.constants.include? m[0].downcase
+            token Keyword::Constant
+          elsif 'package'.casecmp m[0]
+            token Keyword::Namespace
+          elsif m[1] == "@"
+            token Name::Decorator
+          elsif m[3] == ":"
+            groups Operator, Name::Label, Punctuation
+          elsif m[3] == "("
+            groups Operator, Name::Function, Punctuation
+          elsif m[1] == "."
+            groups Operator, Name::Property, Punctuation
+          else
+            token Name
+          end
+        end
+
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
+
+        digit = /[0-9]_+[0-9]|[0-9]/
+        rule %r/#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
+        rule %r/0b(?:[01]_+[01]|[01])+/i, Num::Bin
+        rule %r/0x(?:\h_+\h|\h)+/i, Num::Hex
+        rule %r/0(?:[0-7]_+[0-7]|[0-7])+/, Num::Oct
+        rule %r/#{digit}+L?/, Num::Integer
+
+        rule %r/[-+\/*~^!%&<>|=.?]/, Operator
+        rule %r/[\[\](){},:;]/, Punctuation;
+      end
+
+      state :class do
+        rule %r/\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r/\s+/m, Text
+        rule %r/[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+      end
+
+      state :escape do
+        rule %r/\\[btnfr\\"']/, Str::Escape
+      end
+
+      state :dq do
+        mixin :escape
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        mixin :escape
+        rule %r/[^\\']+/, Str::Double
+        rule %r/'/, Str::Double, :pop!
+      end
+    end
+  end
+end