rouge 3.2.0 → 3.18.0

data/lib/rouge/lexers/xojo.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Xojo < RegexLexer
+      title "Xojo"
+      desc "Xojo"
+      tag 'xojo'
+      aliases 'realbasic'
+      filenames '*.xojo_code', '*.xojo_window', '*.xojo_toolbar', '*.xojo_menu', '*.xojo_image', '*.rbbas', '*.rbfrm', '*.rbmnu', '*.rbres', '*.rbtbar'
+
+      keywords = %w(
+          addhandler aggregates array asc assigns attributes begin break
+          byref byval call case catch class const continue char ctype declare
+          delegate dim do downto each else elseif end enum event exception
+          exit extends false finally for function global goto if
+          implements inherits interface lib loop mod module
+          new next nil object of optional paramarray
+          private property protected public raise raiseevent rect redim
+          removehandler return select shared soft static step sub super
+          then to true try until using uend uhile
+        )
+
+      keywords_type = %w(
+          boolean cfstringref cgfloat cstring curency date double int8 int16
+          int32 int64 integer ostype pstring ptr short single
+          single string structure variant uinteger uint8 uint16 uint32 uint64
+          ushort windowptr wstring
+        )
+
+      operator_words = %w(
+          addressof weakaddressof and as in is isa mod not or xor
+        )
+
+      state :root do
+        rule %r/\s+/, Text::Whitespace
+
+        rule %r/rem\b.*?$/i, Comment::Single
+        rule %r([//'].*$), Comment::Single
+        rule %r/\#tag Note.*?\#tag EndNote/mi, Comment::Preproc
+        rule %r/\s*[#].*$/x, Comment::Preproc
+
+        rule %r/".*?"/, Literal::String::Double
+        rule %r/[(){}!#,:]/, Punctuation
+
+        rule %r/\b(?:#{keywords.join('|')})\b/i, Keyword
+        rule %r/\b(?:#{keywords_type.join('|')})\b/i, Keyword::Declaration
+
+        rule %r/\b(?:#{operator_words.join('|')})\b/i, Operator
+        rule %r/[+-]?(\d+\.\d*|\d*\.\d+)/i, Literal::Number::Float
+        rule %r/[+-]?\d+/, Literal::Number::Integer
+        rule %r/&[CH][0-9a-f]+/i, Literal::Number::Hex
+        rule %r/&O[0-7]+/i, Literal::Number::Oct
+
+        rule %r/\b[\w\.]+\b/i, Text
+        rule(%r(<=|>=|<>|[=><\+\-\*\/\\]), Operator)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/xpath.rb

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class XPath < RegexLexer
+      title 'XPath'
+      desc 'XML Path Language (XPath) 3.1'
+      tag 'xpath'
+      filenames '*.xpath'
+
+      # Terminal literals:
+      # https://www.w3.org/TR/xpath-31/#terminal-symbols
+      def self.digits
+        @digits ||= %r/[0-9]+/
+      end
+
+      def self.decimalLiteral
+        @decimalLiteral ||= %r/\.#{digits}|#{digits}\.[0-9]*/
+      end
+
+      def self.doubleLiteral
+        @doubleLiteral ||= %r/(\.#{digits})|#{digits}(\.[0-9]*)?[eE][+-]?#{digits}/
+      end
+
+      def self.stringLiteral
+        @stringLiteral ||= %r/("(("")|[^"])*")|('(('')|[^'])*')/
+      end
+
+      def self.ncName
+        @ncName ||= %r/[a-z_][a-z_\-.0-9]*/i
+      end
+
+      def self.qName
+        @qName ||= %r/(?:#{ncName})(?::#{ncName})?/
+      end
+
+      def self.uriQName
+        @uriQName ||= %r/Q\{[^{}]*\}#{ncName}/
+      end
+
+      def self.eqName
+        @eqName ||= %r/(?:#{uriQName}|#{qName})/
+      end
+
+      def self.commentStart
+        @commentStart ||= %r/\(:/
+      end
+
+      def self.openParen
+        @openParen ||= %r/\((?!:)/
+      end
+
+      # Terminal symbols:
+      # https://www.w3.org/TR/xpath-30/#id-terminal-delimitation
+      def self.kindTest
+        @kindTest ||= Regexp.union %w(
+          element attribute schema-element schema-attribute
+          comment text node document-node namespace-node
+        )
+      end
+
+      def self.kindTestForPI
+        @kindTestForPI ||= Regexp.union %w(processing-instruction)
+      end
+
+      def self.axes
+        @axes ||= Regexp.union %w(
+          child descendant attribute self descendant-or-self
+          following-sibling following namespace
+          parent ancestor preceding-sibling preceding ancestor-or-self
+        )
+      end
+
+      def self.operators
+        @operators ||= Regexp.union %w(, => = := : >= >> > <= << < - * != + // / || |)
+      end
+
+      def self.keywords
+        @keywords ||= Regexp.union %w(let for some every if then else return in satisfies)
+      end
+
+      def self.word_operators
+        @word_operators ||= Regexp.union %w(
+          and or eq ge gt le lt ne is
+          div mod idiv
+          intersect except union
+          to
+        )
+      end
+
+      def self.constructorTypes
+        @constructorTypes ||= Regexp.union %w(function array map empty-sequence)
+      end
+
+      # Mixin states:
+
+      state :commentsAndWhitespace do
+        rule XPath.commentStart, Comment, :comment
+        rule %r/\s+/m, Text::Whitespace
+      end
+
+      # Lexical states:
+      # https://www.w3.org/TR/xquery-xpath-parsing/#XPath-lexical-states
+      # https://lists.w3.org/Archives/Public/public-qt-comments/2004Aug/0127.html
+      # https://www.w3.org/TR/xpath-30/#id-revision-log
+      # https://www.w3.org/TR/xpath-31/#id-revision-log
+
+      state :root do
+        mixin :commentsAndWhitespace
+
+        # Literals
+        rule XPath.doubleLiteral, Num::Float
+        rule XPath.decimalLiteral, Num::Float
+        rule XPath.digits, Num
+        rule XPath.stringLiteral, Literal::String
+
+        # Variables
+        rule %r/\$/, Name::Variable, :varname
+
+        # Operators
+        rule XPath.operators, Operator
+        rule %r/#{XPath.word_operators}\b/, Operator::Word
+        rule %r/#{XPath.keywords}\b/, Keyword
+        rule %r/[?,{}()\[\]]/, Punctuation
+
+        # Functions
+        rule %r/(function)(\s*)(#{XPath.openParen})/ do # function declaration
+          groups Keyword, Text::Whitespace, Punctuation
+        end
+        rule %r/(map|array|empty-sequence)/, Keyword # constructors
+        rule %r/(#{XPath.kindTest})(\s*)(#{XPath.openParen})/ do  # kindtest
+          groups Keyword, Text::Whitespace, Punctuation
+          push :kindtest
+        end
+        rule %r/(#{XPath.kindTestForPI})(\s*)(#{XPath.openParen})/ do # processing instruction kindtest
+          groups Keyword, Text::Whitespace, Punctuation
+          push :kindtestforpi
+        end
+        rule %r/(#{XPath.eqName})(\s*)(#{XPath.openParen})/ do # function call
+          groups Name::Function, Text::Whitespace, Punctuation
+        end
+        rule %r/(#{XPath.eqName})(\s*)(#)(\s*)(\d+)/ do # namedFunctionRef
+          groups Name::Function, Text::Whitespace, Name::Function, Text::Whitespace, Name::Function
+        end
+
+        # Type commands
+        rule %r/(cast|castable)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          push :singletype
+        end
+        rule %r/(treat)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          push :itemtype
+        end
+        rule %r/(instance)(\s+)(of)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          push :itemtype
+        end
+        rule %r/(as)\b/ do
+          token Keyword
+          push :itemtype
+        end
+
+        # Paths
+        rule %r/(#{XPath.ncName})(\s*)(:)(\s*)(\*)/ do
+          groups Name::Tag, Text::Whitespace, Punctuation, Text::Whitespace, Operator
+        end
+        rule %r/(\*)(\s*)(:)(\s*)(#{XPath.ncName})/ do
+          groups Operator, Text::Whitespace, Punctuation, Text::Whitespace, Name::Tag
+        end
+        rule %r/(#{XPath.axes})(\s*)(::)/ do
+          groups Keyword, Text::Whitespace, Operator
+        end
+        rule %r/\.\.|\.|\*/, Operator
+        rule %r/@/, Name::Attribute, :attrname
+        rule XPath.eqName, Name::Tag
+      end
+
+      state :singletype do
+        mixin :commentsAndWhitespace
+
+        # Type name
+        rule XPath.eqName do
+          token Keyword::Type
+          pop!
+        end
+      end
+
+      state :itemtype do
+        mixin :commentsAndWhitespace
+
+        # Type tests
+        rule %r/(#{XPath.kindTest})(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+          # go to kindtest then occurrenceindicator
+          goto :occurrenceindicator
+          push :kindtest
+        end
+        rule %r/(#{XPath.kindTestForPI})(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+          # go to kindtestforpi then occurrenceindicator
+          goto :occurrenceindicator
+          push :kindtestforpi
+        end
+        rule %r/(item)(\s*)(#{XPath.openParen})(\s*)(\))/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation, Text::Whitespace, Punctuation
+          goto :occurrenceindicator
+        end
+        rule %r/(#{XPath.constructorTypes})(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+        end
+
+        # Type commands
+        rule %r/(cast|castable)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          goto :singletype
+        end
+        rule %r/(treat)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          goto :itemtype
+        end
+        rule %r/(instance)(\s+)(of)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          goto :itemtype
+        end
+        rule %r/(as)\b/, Keyword
+
+        # Operators
+        rule XPath.operators do
+          token Operator
+          pop!
+        end
+        rule %r/#{XPath.word_operators}\b/ do
+          token Operator::Word
+          pop!
+        end
+        rule %r/#{XPath.keywords}\b/ do
+          token Keyword
+          pop!
+        end
+        rule %r/[\[),]/ do
+          token Punctuation
+          pop!
+        end
+
+        # Other types (e.g. xs:double)
+        rule XPath.eqName do
+          token Keyword::Type
+          goto :occurrenceindicator
+        end
+      end
+
+      # For pseudo-parameters for the KindTest productions
+      state :kindtest do
+        mixin :commentsAndWhitespace
+
+        # Pseudo-parameters:
+        rule %r/[?*]/, Operator
+        rule %r/,/, Punctuation
+        rule %r/(element|schema-element)(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+          push :kindtest
+        end
+        rule XPath.eqName, Name::Tag
+
+        # End of pseudo-parameters
+        rule %r/\)/, Punctuation, :pop!
+      end
+
+      # Similar to :kindtest, but recognizes NCNames instead of EQNames
+      state :kindtestforpi do
+        mixin :commentsAndWhitespace
+
+        # Pseudo-parameters
+        rule XPath.ncName, Name
+        rule XPath.stringLiteral, Literal::String
+
+        # End of pseudo-parameters
+        rule %r/\)/, Punctuation, :pop!
+      end
+
+      state :occurrenceindicator do
+        mixin :commentsAndWhitespace
+
+        # Occurrence indicator
+        rule %r/[?*+]/ do
+          token Operator
+          pop!
+        end
+
+        # Otherwise, lex it in root state:
+        rule %r/(?![?*+])/ do
+          pop!
+        end
+      end
+
+      state :varname do
+        mixin :commentsAndWhitespace
+
+        # Function call
+        rule %r/(#{XPath.eqName})(\s*)(#{XPath.openParen})/ do
+          groups Name::Variable, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # Variable name
+        rule XPath.eqName, Name::Variable, :pop!
+      end
+
+      state :attrname do
+        mixin :commentsAndWhitespace
+
+        # Attribute name
+        rule XPath.eqName, Name::Attribute, :pop!
+        rule %r/\*/, Operator, :pop!
+      end
+
+      state :comment do
+        # Comment end
+        rule %r/:\)/, Comment, :pop!
+
+        # Nested comment
+        rule XPath.commentStart, Comment, :comment
+
+        # Comment contents
+        rule %r/[^:(]+/m, Comment
+        rule %r/[:(]/, Comment
+      end
+    end
+  end
+end

data/lib/rouge/lexers/xquery.rb

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'xpath.rb'
+    class XQuery < XPath
+      title 'XQuery'
+      desc 'XQuery 3.1: An XML Query Language'
+      tag 'xquery'
+      filenames '*.xquery', '*.xq'
+      mimetypes 'application/xquery'
+
+      def self.keywords
+        @keywords ||= Regexp.union super, Regexp.union(%w(
+          xquery encoding version declare module
+          namespace copy-namespaces boundary-space construction
+          default collation base-uri preserve strip
+          ordering ordered unordered order empty greatest least
+          preserve no-preserve inherit no-inherit
+          decimal-format decimal-separator grouping-separator
+          infinity minus-sign NaN percent per-mille
+          zero-digit digit pattern-separator exponent-separator
+          import schema at element option
+          function external context item
+          typeswitch switch case
+          try catch
+          validate lax strict type
+          document element attribute text comment processing-instruction
+          for let where order group by return
+          allowing tumbling stable sliding window
+          start end only when previous next count collation
+          ascending descending
+        ))
+      end
+
+      # Mixin states:
+
+      state :tags do
+        rule %r/<#{XPath.qName}/, Name::Tag, :start_tag
+        rule %r/<!--/, Comment, :xml_comment
+        rule %r/<\?.*?\?>/, Comment::Preproc
+        rule %r/<!\[CDATA\[.*?\]\]>/, Comment::Preproc
+        rule %r/&\S*?;/, Name::Entity
+      end
+
+      # Lexical states:
+
+      prepend :root do
+        mixin :tags
+
+        rule %r/\{/, Punctuation
+        rule %r/\}`?/ do
+          token Punctuation
+          if stack.length > 1
+            pop!
+          end
+        end
+
+        rule %r/(namespace)(\s+)(#{XPath.ncName})/ do
+          groups Keyword, Text::Whitespace, Name::Namespace
+        end
+
+        rule %r/(#{XQuery.keywords})\b/, Keyword
+        rule %r/;/, Punctuation
+        rule %r/%/, Keyword::Declaration, :annotation
+
+        rule %r/(\(#)(\s*)(#{XPath.eqName})/ do
+          groups Comment::Preproc, Text::Whitespace, Name::Tag
+          push :pragma
+        end
+
+        rule %r/``\[/, Str, :str_constructor
+      end
+
+      state :annotation do
+        mixin :commentsAndWhitespace
+        rule XPath.eqName, Keyword::Declaration, :pop!
+      end
+
+      state :pragma do
+        mixin :commentsAndWhitespace
+        rule %r/#\)/, Comment::Preproc, :pop!
+        rule %r/./, Comment::Preproc
+      end
+
+      # https://www.w3.org/TR/xquery-31/#id-string-constructors
+      state :str_constructor do
+        rule %r/`\{/, Punctuation, :root
+        rule %r/\]``/, Str, :pop!
+        rule %r/[^`\]]+/m, Str
+        rule %r/[`\]]/, Str
+      end
+
+      state :xml_comment do
+        rule %r/[^-]+/m, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
+      end
+
+      state :start_tag do
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/([\w.:-]+\s*=)(")/m do
+          groups Name::Attribute, Str
+          push :quot_attr
+        end
+        rule %r/([\w.:-]+\s*=)(')/m do
+          groups Name::Attribute, Str
+          push :apos_attr
+        end
+        rule %r/>/, Name::Tag, :tag_content
+        rule %r(/>), Name::Tag, :pop!
+      end
+
+      state :quot_attr do
+        rule %r/"/, Str, :pop!
+        rule %r/\{\{/, Str
+        rule %r/\{/, Punctuation, :root
+        rule %r/[^"{>]+/m, Str
+      end
+
+      state :apos_attr do
+        rule %r/'/, Str, :pop!
+        rule %r/\{\{/, Str
+        rule %r/\{/, Punctuation, :root
+        rule %r/[^'{>]+/m, Str
+      end
+
+      state :tag_content do
+        rule %r/\s+/m, Text::Whitespace
+        mixin :tags
+
+        rule %r/(\{\{|\}\})/, Text
+        rule %r/\{/, Punctuation, :root
+
+        rule %r/[^{}<&]/, Text
+
+        rule %r(</#{XPath.qName}(\s*)>) do
+          token Name::Tag
+          pop! 2 # pop self and tag_start
+        end
+      end
+    end
+  end
+end