rouge 3.3.0 → 3.8.0

data/lib/rouge/lexers/vue.rb

@@ -36,21 +36,21 @@ module Rouge
       start { @js.reset! }
 
       prepend :root do
-        rule /(<)(\s*)(template)/ do
+        rule %r/(<)(\s*)(template)/ do
           groups Name::Tag, Text, Keyword
           @lang = HTML
           push :template
           push :lang_tag
         end
 
-        rule /(<)(\s*)(style)/ do
+        rule %r/(<)(\s*)(style)/ do
           groups Name::Tag, Text, Keyword
           @lang = CSS
           push :style
           push :lang_tag
         end
 
-        rule /(<)(\s*)(script)/ do
+        rule %r/(<)(\s*)(script)/ do
           groups Name::Tag, Text, Keyword
           @lang = Javascript
           push :script
@@ -59,7 +59,7 @@ module Rouge
       end
 
       state :style do
-        rule /(<\s*\/\s*)(style)(\s*>)/ do
+        rule %r/(<\s*\/\s*)(style)(\s*>)/ do
           groups Name::Tag, Keyword, Name::Tag
           pop!
         end
@@ -69,7 +69,7 @@ module Rouge
       end
 
       state :script do
-        rule /(<\s*\/\s*)(script)(\s*>)/ do
+        rule %r/(<\s*\/\s*)(script)(\s*>)/ do
           groups Name::Tag, Keyword, Name::Tag
           pop!
         end
@@ -79,7 +79,7 @@ module Rouge
       end
 
       state :lang_tag do
-        rule /(lang\s*=)(\s*)("(?:\\.|[^\\])*?"|'(\\.|[^\\])*?'|[^\s>]+)/ do |m|
+        rule %r/(lang\s*=)(\s*)("(?:\\.|[^\\])*?"|'(\\.|[^\\])*?'|[^\s>]+)/ do |m|
           groups Name::Attribute, Text, Str
           @lang = lookup_lang(m[3])
         end
@@ -93,7 +93,7 @@ module Rouge
           pop!
         end
 
-        rule /{{/ do
+        rule %r/{{/ do
           token Str::Interpol
           push :template_interpol
           @js.reset!
@@ -103,8 +103,8 @@ module Rouge
       end
 
       state :template_interpol do
-        rule /}}/, Str::Interpol, :pop!
-        rule /}/, Error
+        rule %r/}}/, Str::Interpol, :pop!
+        rule %r/}/, Error
         mixin :template_interpol_inner
       end
 

data/lib/rouge/lexers/wollok.rb

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*- # 
+# -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
 module Rouge
@@ -7,7 +7,7 @@ module Rouge
       title 'Wollok'
       desc 'Wollok lang'
       tag 'wollok'
-      filenames *%w(*.wlk *.wtest *.wpgm)
+      filenames '*.wlk', '*.wtest', '*.wpgm'
 
       keywords = %w(new super return if else var const override constructor)
 
@@ -17,23 +17,23 @@ module Rouge
       entities = []
 
       state :whitespaces_and_comments do
-        rule /\s+/m, Text::Whitespace
-        rule /$+/m, Text::Whitespace
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/$+/m, Text::Whitespace
         rule %r(//.*$), Comment::Single
         rule %r(/\*(.|\s)*?\*/)m, Comment::Multiline
       end
 
       state :root do
         mixin :whitespaces_and_comments
-        rule /(import)(.+$)/ do
+        rule %r/(import)(.+$)/ do
           groups Keyword::Reserved, Text
         end
-        rule /(class|object|mixin)/, Keyword::Reserved, :foo
-        rule /test|program/, Keyword::Reserved #, :chunk_naming
-        rule /(package)(\s+)(#{entity_name})/ do
+        rule %r/(class|object|mixin)/, Keyword::Reserved, :foo
+        rule %r/test|program/, Keyword::Reserved #, :chunk_naming
+        rule %r/(package)(\s+)(#{entity_name})/ do
           groups Keyword::Reserved, Text::Whitespace, Name::Class
         end
-        rule /{|}/, Text
+        rule %r/{|}/, Text
         mixin :keywords
         mixin :symbols
         mixin :objects
@@ -41,13 +41,13 @@ module Rouge
 
       state :foo do
         mixin :whitespaces_and_comments
-        rule /inherits|mixed|with|and/, Keyword::Reserved
-        rule /#{entity_name}(?=\s*{)/ do |m|
+        rule %r/inherits|mixed|with|and/, Keyword::Reserved
+        rule %r/#{entity_name}(?=\s*{)/ do |m|
           token Name::Class
           entities << m[0]
           pop!
         end
-        rule /#{entity_name}/ do |m|
+        rule %r/#{entity_name}/ do |m|
           token Name::Class
           entities << m[0]
         end
@@ -58,9 +58,9 @@ module Rouge
           /#{expressions.map { |keyword| "#{keyword}\\b" }.join('|')}/
         end
 
-        rule /self\b/, Name::Builtin::Pseudo
+        rule %r/self\b/, Name::Builtin::Pseudo
         rule any(keywords), Keyword::Reserved
-        rule /(method)(\s+)(#{variable_naming})/ do
+        rule %r/(method)(\s+)(#{variable_naming})/ do
           groups Keyword::Reserved, Text::Whitespace, Text
         end
       end
@@ -74,30 +74,30 @@ module Rouge
             token Keyword::Variable
           end
         end
-        rule /\.#{entity_name}/, Text
+        rule %r/\.#{entity_name}/, Text
         mixin :literals
       end
 
       state :literals do
         mixin :whitespaces_and_comments
-        rule /[0-9]+\.?[0-9]*/, Literal::Number
-        rule /"[^"]*"/m, Literal::String
-        rule /\[|\#{/, Punctuation, :lists
+        rule %r/[0-9]+\.?[0-9]*/, Literal::Number
+        rule %r/"[^"]*"/m, Literal::String
+        rule %r/\[|\#{/, Punctuation, :lists
       end
 
       state :lists do
-        rule /,/, Punctuation
-        rule /]|}/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/]|}/, Punctuation, :pop!
         mixin :objects
       end
 
       state :symbols do
-        rule /\+\+|--|\+=|-=|\*\*|!/, Operator
-        rule /\+|-|\*|\/|%/, Operator
-        rule /<=|=>|===|==|<|>/, Operator
-        rule /and\b|or\b|not\b/, Operator
-        rule /\(|\)|=/, Text
-        rule /,/, Punctuation
+        rule %r/\+\+|--|\+=|-=|\*\*|!/, Operator
+        rule %r/\+|-|\*|\/|%/, Operator
+        rule %r/<=|=>|===|==|<|>/, Operator
+        rule %r/and\b|or\b|not\b/, Operator
+        rule %r/\(|\)|=/, Text
+        rule %r/,/, Punctuation
       end
     end
   end

data/lib/rouge/lexers/xml.rb

@@ -7,14 +7,10 @@ module Rouge
       title "XML"
       desc %q(<desc for="this-lexer">XML</desc>)
       tag 'xml'
-      filenames *%w(*.xml *.xsl *.rss *.xslt *.xsd *.wsdl *.svg)
-      mimetypes *%w(
-        text/xml
-        application/xml
-        image/svg+xml
-        application/rss+xml
-        application/atom+xml
-      )
+      filenames '*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl', '*.svg',
+                '*.plist'
+      mimetypes 'text/xml', 'application/xml', 'image/svg+xml',
+                'application/rss+xml', 'application/atom+xml'
 
       def self.detect?(text)
         return false if text.doctype?(/html/)
@@ -23,12 +19,12 @@ module Rouge
       end
 
       state :root do
-        rule /[^<&]+/, Text
-        rule /&\S*?;/, Name::Entity
-        rule /<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
-        rule /<!--/, Comment, :comment
-        rule /<\?.*?\?>/, Comment::Preproc
-        rule /<![^>]*>/, Comment::Preproc
+        rule %r/[^<&]+/, Text
+        rule %r/&\S*?;/, Name::Entity
+        rule %r/<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
+        rule %r/<!--/, Comment, :comment
+        rule %r/<\?.*?\?>/, Comment::Preproc
+        rule %r/<![^>]*>/, Comment::Preproc
 
         # open tags
         rule %r(<\s*[\w:.-]+)m, Name::Tag, :tag
@@ -38,20 +34,20 @@ module Rouge
       end
 
       state :comment do
-        rule /[^-]+/m, Comment
-        rule /-->/, Comment, :pop!
-        rule /-/, Comment
+        rule %r/[^-]+/m, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
       end
 
       state :tag do
-        rule /\s+/m, Text
-        rule /[\w.:-]+\s*=/m, Name::Attribute, :attr
+        rule %r/\s+/m, Text
+        rule %r/[\w.:-]+\s*=/m, Name::Attribute, :attr
         rule %r(/?\s*>), Name::Tag, :pop!
       end
 
       state :attr do
-        rule /\s+/m, Text
-        rule /".*?"|'.*?'|[^\s>]+/m, Str, :pop!
+        rule %r/\s+/m, Text
+        rule %r/".*?"|'.*?'|[^\s>]+/m, Str, :pop!
       end
     end
   end

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