rouge 3.17.0

data/lib/rouge/lexers/sml.rb

@@ -0,0 +1,345 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class SML < RegexLexer
+      title "SML"
+      desc 'Standard ML'
+      tag 'sml'
+      aliases 'ml'
+      filenames '*.sml', '*.sig', '*.fun'
+
+      mimetypes 'text/x-standardml', 'application/x-standardml'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abstype and andalso as case datatype do else end exception
+          fn fun handle if in infix infixr let local nonfix of op open
+          orelse raise rec then type val with withtype while
+          eqtype functor include sharing sig signature struct structure
+          where
+        )
+      end
+
+      def self.symbolic_reserved
+        @symbolic_reserved ||= Set.new %w(: | = => -> # :>)
+      end
+
+      id = /[\w']+/i
+      symbol = %r([!%&$#/:<=>?@\\~`^|*+-]+)
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r/[(][*]/, Comment, :comment
+      end
+
+      state :delimiters do
+        rule %r/[(\[{]/, Punctuation, :main
+        rule %r/[)\]}]/, Punctuation, :pop!
+
+        rule %r/\b(let|if|local)\b(?!')/ do
+          token Keyword::Reserved
+          push; push
+        end
+
+        rule %r/\b(struct|sig|while)\b(?!')/ do
+          token Keyword::Reserved
+          push
+        end
+
+        rule %r/\b(do|else|end|in|then)\b(?!')/, Keyword::Reserved, :pop!
+      end
+
+      def token_for_id_with_dot(id)
+        if self.class.keywords.include? id
+          Error
+        else
+          Name::Namespace
+        end
+      end
+
+      def token_for_final_id(id)
+        if self.class.keywords.include? id or self.class.symbolic_reserved.include? id
+          Error
+        else
+          Name
+        end
+      end
+
+      def token_for_id(id)
+        if self.class.keywords.include? id
+          Keyword::Reserved
+        elsif self.class.symbolic_reserved.include? id
+          Punctuation
+        else
+          Name
+        end
+      end
+
+      state :core do
+        rule %r/[()\[\]{},;_]|[.][.][.]/, Punctuation
+        rule %r/#"/, Str::Char, :char
+        rule %r/"/, Str::Double, :string
+        rule %r/~?0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/0wx[0-9a-fA-F]+/, Num::Hex
+        rule %r/0w\d+/, Num::Integer
+        rule %r/~?\d+([.]\d+)?[eE]~?\d+/, Num::Float
+        rule %r/~?\d+[.]\d+/, Num::Float
+        rule %r/~?\d+/, Num::Integer
+
+        rule %r/#\s*[1-9][0-9]*/, Name::Label
+        rule %r/#\s*#{id}/, Name::Label
+        rule %r/#\s+#{symbol}/, Name::Label
+
+        rule %r/\b(datatype|abstype)\b(?!')/, Keyword::Reserved, :dname
+        rule(/(?=\bexception\b(?!'))/) { push :ename }
+        rule %r/\b(functor|include|open|signature|structure)\b(?!')/,
+          Keyword::Reserved, :sname
+        rule %r/\b(type|eqtype)\b(?!')/, Keyword::Reserved, :tname
+
+        rule %r/'#{id}/, Name::Decorator
+        rule %r/(#{id})([.])/ do |m|
+          groups(token_for_id_with_dot(m[1]), Punctuation)
+          push :dotted
+        end
+
+        rule id do |m|
+          token token_for_id(m[0])
+        end
+
+        rule symbol do |m|
+          token token_for_id(m[0])
+        end
+      end
+
+      state :dotted do
+        rule %r/(#{id})([.])/ do |m|
+          groups(token_for_id_with_dot(m[1]), Punctuation)
+        end
+
+        rule id do |m|
+          token token_for_id(m[0])
+          pop!
+        end
+
+        rule symbol do |m|
+          token token_for_id(m[0])
+          pop!
+        end
+      end
+
+      state :root do
+        rule %r/#!.*?\n/, Comment::Preproc
+        rule(//) { push :main }
+      end
+
+      state :main do
+        mixin :whitespace
+
+        rule %r/\b(val|and)\b(?!')/, Keyword::Reserved, :vname
+        rule %r/\b(fun)\b(?!')/ do
+          token Keyword::Reserved
+          goto :main_fun
+          push :fname
+        end
+
+        mixin :delimiters
+        mixin :core
+      end
+
+      state :main_fun do
+        mixin :whitespace
+        rule %r/\b(fun|and)\b(?!')/, Keyword::Reserved, :fname
+        rule %r/\bval\b(?!')/ do
+          token Keyword::Reserved
+          goto :main
+          push :vname
+        end
+
+        rule %r/[|]/, Punctuation, :fname
+        rule %r/\b(case|handle)\b(?!')/ do
+          token Keyword::Reserved
+          goto :main
+        end
+
+        mixin :delimiters
+        mixin :core
+      end
+
+      state :has_escapes do
+        rule %r/\\[\\"abtnvfr]/, Str::Escape
+        rule %r/\\\^[\x40-\x5e]/, Str::Escape
+        rule %r/\\[0-9]{3}/, Str::Escape
+        rule %r/\\u\h{4}/, Str::Escape
+        rule %r/\\\s+\\/, Str::Interpol
+      end
+
+      state :string do
+        rule %r/[^"\\]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        mixin :has_escapes
+      end
+
+      state :char do
+        rule %r/[^"\\]+/, Str::Char
+        rule %r/"/, Str::Char, :pop!
+        mixin :has_escapes
+      end
+
+      state :breakout do
+        rule %r/(?=\b(#{SML.keywords.to_a.join('|')})\b(?!'))/ do
+          pop!
+        end
+      end
+
+      state :sname do
+        mixin :whitespace
+        mixin :breakout
+        rule id, Name::Namespace
+        rule(//) { pop! }
+      end
+
+      state :has_annotations do
+        rule %r/'[\w']*/, Name::Decorator
+        rule %r/[(]/, Punctuation, :tyvarseq
+      end
+
+      state :fname do
+        mixin :whitespace
+        mixin :has_annotations
+
+        rule id, Name::Function, :pop!
+        rule symbol, Name::Function, :pop!
+      end
+
+      state :vname do
+        mixin :whitespace
+        mixin :has_annotations
+
+        rule %r/(#{id})(\s*)(=(?!#{symbol}))/m do
+          groups Name::Variable, Text, Punctuation
+          pop!
+        end
+
+        rule %r/(#{symbol})(\s*)(=(?!#{symbol}))/m do
+          groups Name::Variable, Text, Punctuation
+        end
+
+        rule id, Name::Variable, :pop!
+        rule symbol, Name::Variable, :pop!
+
+        rule(//) { pop! }
+      end
+
+      state :tname do
+        mixin :whitespace
+        mixin :breakout
+        mixin :has_annotations
+
+        rule %r/'[\w']*/, Name::Decorator
+        rule %r/[(]/, Punctuation, :tyvarseq
+
+        rule %r(=(?!#{symbol})) do
+          token Punctuation
+          goto :typbind
+        end
+
+        rule id, Keyword::Type
+        rule symbol, Keyword::Type
+      end
+
+      state :typbind do
+        mixin :whitespace
+
+        rule %r/\b(and)\b(?!')/ do
+          token Keyword::Reserved
+          goto :tname
+        end
+
+        mixin :breakout
+        mixin :core
+      end
+
+      state :dname do
+        mixin :whitespace
+        mixin :breakout
+        mixin :has_annotations
+
+        rule %r/(=)(\s*)(datatype)\b/ do
+          groups Punctuation, Text, Keyword::Reserved
+          pop!
+        end
+
+        rule %r(=(?!#{symbol})) do
+          token Punctuation
+          goto :datbind
+          push :datcon
+        end
+
+        rule id, Keyword::Type
+        rule symbol, Keyword::Type
+      end
+
+      state :datbind do
+        mixin :whitespace
+        rule %r/\b(and)\b(?!')/ do
+          token Keyword::Reserved; goto :dname
+        end
+        rule %r/\b(withtype)\b(?!')/ do
+          token Keyword::Reserved; goto :tname
+        end
+        rule %r/\bof\b(?!')/, Keyword::Reserved
+        rule %r/([|])(\s*)(#{id})/ do
+          groups(Punctuation, Text, Name::Class)
+        end
+
+        rule %r/([|])(\s+)(#{symbol})/ do
+          groups(Punctuation, Text, Name::Class)
+        end
+
+        mixin :breakout
+        mixin :core
+      end
+
+      state :ename do
+        mixin :whitespace
+        rule %r/(exception|and)(\s+)(#{id})/ do
+          groups Keyword::Reserved, Text, Name::Class
+        end
+
+        rule %r/(exception|and)(\s*)(#{symbol})/ do
+          groups Keyword::Reserved, Text, Name::Class
+        end
+
+        rule %r/\b(of)\b(?!')/, Keyword::Reserved
+        mixin :breakout
+        mixin :core
+      end
+
+      state :datcon do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+        rule symbol, Name::Class, :pop!
+      end
+
+      state :tyvarseq do
+        mixin :whitespace
+        rule %r/'[\w']*/, Name::Decorator
+        rule id, Name
+        rule %r/,/, Punctuation
+        rule %r/[)]/, Punctuation, :pop!
+        rule symbol, Name
+      end
+
+      state :comment do
+        rule %r/[^(*)]+/, Comment::Multiline
+        rule %r/[(][*]/ do
+          token Comment::Multiline; push
+        end
+        rule %r/[*][)]/, Comment::Multiline, :pop!
+        rule %r/[(*)]/, Comment::Multiline
+      end
+    end
+  end
+end

data/lib/rouge/lexers/sparql.rb

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class SPARQL < RegexLexer
+      title "SPARQL"
+      desc "Semantic Query Language, for RDF data"
+      tag 'sparql'
+      filenames '*.rq'
+      mimetypes 'application/sparql-query'
+
+      def self.builtins
+        @builtins = Set.new %w[
+          ABS AVG BNODE BOUND CEIL COALESCE CONCAT CONTAINS COUNT DATATYPE DAY
+          ENCODE_FOR_URI FLOOR GROUP_CONCAT HOURS IF IRI isBLANK isIRI
+          isLITERAL isNUMERIC isURI LANG LANGMATCHES LCASE MAX MD5 MIN MINUTES
+          MONTH NOW RAND REGEX REPLACE ROUND SAMETERM SAMPLE SECONDS SEPARATOR
+          SHA1 SHA256 SHA384 SHA512 STR STRAFTER STRBEFORE STRDT STRENDS
+          STRLANG STRLEN STRSTARTS STRUUID SUBSTR SUM TIMEZONE TZ UCASE URI
+          UUID YEAR
+        ]
+      end
+
+      def self.keywords
+        @keywords = Set.new %w[
+          ADD ALL AS ASC ASK BASE BIND BINDINGS BY CLEAR CONSTRUCT COPY CREATE
+          DATA DEFAULT DELETE DESC DESCRIBE DISTINCT DROP EXISTS FILTER FROM
+          GRAPH GROUP BY HAVING IN INSERT LIMIT LOAD MINUS MOVE NAMED NOT
+          OFFSET OPTIONAL ORDER PREFIX SELECT REDUCED SERVICE SILENT TO UNDEF
+          UNION USING VALUES WHERE WITH
+        ]
+      end
+
+      state :root do
+        rule %r(\s+)m, Text::Whitespace
+        rule %r(#.*), Comment::Single
+        
+        rule %r("""), Str::Double, :string_double_literal
+        rule %r("), Str::Double, :string_double
+        rule %r('''), Str::Single, :string_single_literal
+        rule %r('), Str::Single, :string_single
+       
+        rule %r([$?]\w+), Name::Variable
+        rule %r((\w*:)(\w+)?) do |m|
+          token Name::Namespace, m[1]
+          token Str::Symbol, m[2]
+        end
+        rule %r(<[^>]*>), Name::Namespace
+        rule %r(true|false)i, Keyword::Constant
+        
+        rule %r([A-Z]\w+\b)i do |m|
+          if self.class.builtins.include? m[0].upcase
+            token Name::Builtin
+          elsif self.class.keywords.include? m[0].upcase
+            token Keyword
+          else
+            token Error
+          end
+        end
+
+        rule %r([+\-]?(?:\d+\.\d*|\.\d+)(?:[e][+\-]?[0-9]+)?)i, Num::Float
+        rule %r([+\-]?\d+), Num::Integer
+        rule %r([\]\[(){}.,;=]), Punctuation
+        rule %r([/?*+=!<>]|&&|\|\||\^\^), Operator
+      end
+
+      state :string_double_common do
+        mixin :string_escapes
+        rule %r(\\), Str::Double
+        rule %r([^"\\]+), Str::Double
+      end
+
+      state :string_double do
+        rule %r(") do
+          token Str::Double
+          goto :string_end
+        end
+        mixin :string_double_common
+      end
+
+      state :string_double_literal do
+        rule %r(""") do
+          token Str::Double
+          goto :string_end
+        end
+        rule %r("), Str::Double
+        mixin :string_double_common
+      end
+
+      state :string_single_common do
+        mixin :string_escapes
+        rule %r(\\), Str::Single
+        rule %r([^'\\]+), Str::Single
+      end
+
+      state :string_single do
+        rule %r(') do
+          token Str::Single
+          goto :string_end
+        end
+        mixin :string_single_common
+      end
+      
+      state :string_single_literal do
+        rule %r(''') do
+          token Str::Single
+          goto :string_end
+        end
+        rule %r('), Str::Single
+        mixin :string_single_common
+      end
+
+      state :string_escapes do
+        rule %r(\\[tbnrf"'\\]), Str::Escape
+        rule %r(\\u\h{4}), Str::Escape
+        rule %r(\\U\h{8}), Str::Escape
+      end
+
+      state :string_end do
+        rule %r((@)([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)) do
+          groups Operator, Name::Property
+        end
+        rule %r(\^\^), Operator
+        rule(//) { pop! }
+      end
+    end
+  end
+end