rouge 3.0.0 → 3.18.0

data/lib/rouge/lexers/q.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     class Q < RegexLexer
@@ -34,23 +36,23 @@ module Rouge
 
       state :root do
         # q allows a file to start with a shebang
-        rule /#!(.*?)$/, Comment::Preproc, :top
-        rule //, Text, :top
+        rule %r/#!(.*?)$/, Comment::Preproc, :top
+        rule %r//, Text, :top
       end
 
       state :top do
         # indented lines at the top of the file are ignored by q
-        rule /^[ \t\r]+.*$/, Comment::Special
-        rule /\n+/, Text
-        rule //, Text, :base
+        rule %r/^[ \t\r]+.*$/, Comment::Special
+        rule %r/\n+/, Text
+        rule %r//, Text, :base
       end
 
       state :base do
-        rule /\n+/m, Text
+        rule %r/\n+/m, Text
         rule(/^.\)/, Keyword::Declaration)
 
         # Identifiers, word operators, etc.
-        rule /#{identifier}/ do |m|
+        rule %r/#{identifier}/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
           elsif self.class.word_operators.include? m[0]
@@ -65,7 +67,7 @@ module Rouge
         end
 
         # White space and comments
-        rule(%r{[ \t\r]\/.*$}, Comment::Single)
+        rule(%r{\s+/.*}, Comment::Single)
         rule(/[ \t\r]+/, Text::Whitespace)
         rule(%r{^/$.*?^\\$}m, Comment::Multiline)
         rule(%r{^\/[^\n]*$(\n[^\S\n]+.*$)*}, Comment::Multiline)
@@ -100,7 +102,7 @@ module Rouge
         rule(%r{(`:[:a-z0-9._\/]*|`(?:[a-z0-9.][:a-z0-9._]*)?)}i, Str::Symbol)
         rule(/(?:<=|>=|<>|::)|[?:$%&|@._#*^\-+~,!><=]:?/, Operator)
 
-        rule /[{}\[\]();]/, Punctuation
+        rule %r/[{}\[\]();]/, Punctuation
 
         # commands
         rule(/\\.*\n/, Text)
@@ -108,14 +110,15 @@ module Rouge
       end
 
       state :string do
-        rule(/"/, Str, :pop!)
-        rule /\\([\\nr]|[01][0-7]{2})/, Str::Escape
-        rule /[^\\"\n]+/, Str
-        rule /\\/, Str # stray backslash
+        rule %r/\\"/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\nr]|[01][0-7]{2})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\/, Str # stray backslash
       end
 
       state :bottom do
-        rule /.*\z/m, Comment::Multiline
+        rule %r/.*\z/m, Comment::Multiline
       end
     end
   end

data/lib/rouge/lexers/qml.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -16,57 +17,57 @@ module Rouge
       id_with_dots = /[$a-zA-Z_][a-zA-Z0-9_.]*/
 
       prepend :root do
-        rule /(#{id_with_dots})(\s*)({)/ do
+        rule %r/(#{id_with_dots})(\s*)({)/ do
           groups Keyword::Type, Text, Punctuation
           push :type_block
         end
-        rule /(#{id_with_dots})(\s+)(on)(\s+)(#{id_with_dots})(\s*)({)/ do
+        rule %r/(#{id_with_dots})(\s+)(on)(\s+)(#{id_with_dots})(\s*)({)/ do
           groups Keyword::Type, Text, Keyword, Text, Name::Label, Text, Punctuation
           push :type_block
         end
 
-        rule /[{]/, Punctuation, :push
+        rule %r/[{]/, Punctuation, :push
       end
 
       state :type_block do
-        rule /(id)(\s*)(:)(\s*)(#{id_with_dots})/ do
+        rule %r/(id)(\s*)(:)(\s*)(#{id_with_dots})/ do
           groups Name::Label, Text, Punctuation, Text, Keyword::Declaration
         end
 
-        rule /(#{id_with_dots})(\s*)(:)/ do
+        rule %r/(#{id_with_dots})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
           push :expr_start
         end
 
-        rule /(signal)(\s+)(#{id_with_dots})/ do
+        rule %r/(signal)(\s+)(#{id_with_dots})/ do
           groups Keyword::Declaration, Text, Name::Label
           push :signal
         end
 
-        rule /(property)(\s+)(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(:?)/ do
+        rule %r/(property)(\s+)(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(:?)/ do
           groups Keyword::Declaration, Text, Keyword::Type, Text, Name::Label, Text, Punctuation
           push :expr_start
         end
 
-        rule /[}]/, Punctuation, :pop!
+        rule %r/[}]/, Punctuation, :pop!
         mixin :root
       end
 
       state :signal do
         mixin :comments_and_whitespace
-        rule /\(/ do
+        rule %r/\(/ do
           token Punctuation
           goto :signal_args
         end
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :signal_args do
         mixin :comments_and_whitespace
-        rule /(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(,?)/ do
+        rule %r/(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(,?)/ do
           groups Keyword::Type, Text, Name, Text, Punctuation
         end
-        rule /\)/ , Punctuation, :pop!
+        rule %r/\)/ , Punctuation, :pop!
       end
     end
   end

data/lib/rouge/lexers/r.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -48,27 +49,26 @@ module Rouge
       end
 
       state :root do
-        rule /#'.*?$/, Comment::Doc
-        rule /#.*?$/, Comment::Single
-        rule /\s+/m, Text::Whitespace
+        rule %r/#'.*?$/, Comment::Doc
+        rule %r/#.*?$/, Comment::Single
+        rule %r/\s+/m, Text::Whitespace
 
-        rule /`[^`]+?`/, Name
-        rule /'(\\.|.)*?'/m, Str::Single
-        rule /"(\\.|.)*?"/m, Str::Double
+        rule %r/`[^`]+?`/, Name
+        rule %r/'(\\.|.)*?'/m, Str::Single
+        rule %r/"(\\.|.)*?"/m, Str::Double
 
-        rule /%[^%]*?%/, Operator
+        rule %r/%[^%]*?%/, Operator
 
-        rule /0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?/, Num::Hex
-        rule /[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?[Li]?/,
-          Num
+        rule %r/0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?/, Num::Hex
+        rule %r/[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?[Li]?/, Num
 
         # Only recognize built-in functions when they are actually used as a
         # function call, i.e. followed by an opening parenthesis.
         # `Name::Builtin` would be more logical, but is usually not
         # highlighted specifically; thus use `Name::Function`.
-        rule /\b(?<!.)(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
+        rule %r/\b(?<!.)(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
 
-        rule /[a-zA-Z.]([a-zA-Z_][\w.]*)?/ do |m|
+        rule %r/(?:(?:[[:alpha:]]|[.][._[:alpha:]])[._[:alnum:]]*)|[.]/ do |m|
           if KEYWORDS.include? m[0]
             token Keyword
           elsif KEYWORD_CONSTANTS.include? m[0]
@@ -80,7 +80,7 @@ module Rouge
           end
         end
 
-        rule /[\[\]{}();,]/, Punctuation
+        rule %r/[\[\]{}();,]/, Punctuation
 
         rule %r([-<>?*+^/!=~$@:%&|]), Operator
       end

data/lib/rouge/lexers/racket.rb

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     class Racket < RegexLexer
@@ -485,43 +487,66 @@ module Rouge
 
       state :root do
         # comments
-        rule /;.*$/, Comment::Single
-        rule /\s+/m, Text
+        rule %r/;.*$/, Comment::Single
+        rule %r/#!.*/, Comment::Single
+        rule %r/#\|/, Comment::Multiline, :block_comment
+        rule %r/#;/, Comment::Multiline, :sexp_comment
+        rule %r/\s+/m, Text
 
-        rule /[+-]inf[.][f0]/, Num::Float
-        rule /[+-]nan[.]0/, Num::Float
-        rule /[-]min[.]0/, Num::Float
-        rule /[+]max[.]0/, Num::Float
+        rule %r/[+-]inf[.][f0]/, Num::Float
+        rule %r/[+-]nan[.]0/, Num::Float
+        rule %r/[-]min[.]0/, Num::Float
+        rule %r/[+]max[.]0/, Num::Float
 
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+/, Num::Integer
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
 
-        rule /#:#{id}+/, Name::Tag  # keyword
+        rule %r/#:#{id}+/, Name::Tag  # keyword
 
-        rule /#b[01]+/, Num::Bin
-        rule /#o[0-7]+/, Num::Oct
-        rule /#d[0-9]+/, Num::Integer
-        rule /#x[0-9a-f]+/i, Num::Hex
-        rule /#[ei][\d.]+/, Num::Other
+        rule %r/#b[01]+/, Num::Bin
+        rule %r/#o[0-7]+/, Num::Oct
+        rule %r/#d[0-9]+/, Num::Integer
+        rule %r/#x[0-9a-f]+/i, Num::Hex
+        rule %r/#[ei][\d.]+/, Num::Other
 
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /['`]#{id}/i, Str::Symbol
-        rule /#\\([()\/'"._!\$%& ?=+-]{1}|[a-z0-9]+)/i,
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/['`]#{id}/i, Str::Symbol
+        rule %r/#\\([()\/'"._!\$%& ?=+-]{1}|[a-z0-9]+)/i,
           Str::Char
-        rule /#t|#f/, Name::Constant
-        rule /(?:'|#|`|,@|,|\.)/, Operator
+        rule %r/#t(rue)?|#f(alse)?/i, Name::Constant
+        rule %r/(?:'|#|`|,@|,|\.)/, Operator
 
-        rule /(['#])(\s*)(\()/m do
+        rule %r/(['#])(\s*)(\()/m do
           groups Str::Symbol, Text, Punctuation
         end
 
         # () [] {} are all permitted as like pairs
-        rule /\(|\[|\{/, Punctuation, :command
-        rule /\)|\]|\}/, Punctuation
+        rule %r/\(|\[|\{/, Punctuation, :command
+        rule %r/\)|\]|\}/, Punctuation
 
         rule id, Name::Variable
       end
 
+      state :block_comment do
+        rule %r/[^|#]+/, Comment::Multiline
+        rule %r/\|#/, Comment::Multiline, :pop!
+        rule %r/#\|/, Comment::Multiline, :block_comment
+        rule %r/[|#]/, Comment::Multiline
+      end
+
+      state :sexp_comment do
+        rule %r/[({\[]/, Comment::Multiline, :sexp_comment_inner
+        rule %r/"(?:\\"|[^"])*?"/, Comment::Multiline, :pop!
+        rule %r/[^\s]+/, Comment::Multiline, :pop!
+        rule(//) { pop! }
+      end
+
+      state :sexp_comment_inner do
+        rule %r/[^(){}\[\]]+/, Comment::Multiline
+        rule %r/[)}\]]/, Comment::Multiline, :pop!
+        rule %r/[({\[]/, Comment::Multiline, :sexp_comment_inner
+      end
+
       state :command do
         rule id, Name::Function do |m|
           if self.class.keywords.include? m[0]

data/lib/rouge/lexers/reasonml.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'ocaml/common.rb'
+
+    class ReasonML < OCamlCommon
+      title "ReasonML"
+      desc 'New syntax on top of OCaml ecosystem (reasonml.github.io)'
+      tag 'reasonml'
+      filenames '*.re', '*.rei'
+      mimetypes 'text/x-reasonml'
+
+      def self.keywords
+        @keywords ||= super + Set.new(%w(
+          switch
+        ))
+      end
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule %r/#{@@upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+        rule %r/`#{@@id}/, Name::Tag
+        rule @@upper_id, Name::Class
+        rule %r/[\/][*](?![\/])/, Comment, :comment
+        rule @@id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule %r/[(){}\[\];]+/, Punctuation
+        rule @@operator, Operator
+
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/0x\h[\h_]*/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/\d[\d_]*/, Num::Integer
+
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[^'\/]'/, Str::Char
+        rule %r/'/, Keyword
+        rule %r/"/, Str::Double, :string
+        rule %r/[~?]#{@@id}/, Name::Variable
+      end
+
+      state :comment do
+        rule %r|[^/*)]+|, Comment
+        rule %r|[/][*]|, Comment, :push
+        rule %r|[*][/]|, Comment, :pop!
+        rule %r|[*/]|, Comment
+      end
+    end
+  end
+end

data/lib/rouge/lexers/rego.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+    module Lexers
+        class Rego < RegexLexer
+            title "Rego"
+            desc "The Rego open-policy-agent (OPA) policy language (openpolicyagent.org)"
+            tag 'rego'
+            filenames '*.rego'
+
+            state :basic do
+              rule %r/\s+/, Text
+              rule %r/#.*/, Comment::Single
+      
+              rule %r/[\[\](){}|.,;!]/, Punctuation
+      
+              rule %r/"[^"]*"/, Str::Double
+      
+              rule %r/-?\d+\.\d+([eE][+-]?\d+)?/, Num::Float
+              rule %r/-?\d+([eE][+-]?\d+)?/, Num
+
+              rule %r/\\u[0-9a-fA-F]{4}/, Num::Hex
+              rule %r/\\["\/bfnrt]/, Str::Escape
+            end
+      
+            state :atoms do
+              rule %r/(true|false|null)/, Keyword::Constant
+              rule %r/[[:word:]]*/, Str::Symbol
+            end
+      
+            state :operators do
+              rule %r/(=|!=|>=|<=|>|<|\+|-|\*|%|\/|\||&|:=)/, Operator
+              rule %r/(default|not|package|import|as|with|else|some)/, Operator
+              rule %r/[\/:?@^~]+/, Operator
+            end
+      
+            state :root do
+              mixin :basic
+              mixin :operators
+              mixin :atoms
+            end
+        end
+    end
+end

data/lib/rouge/lexers/robot_framework.rb

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class RobotFramework < RegexLexer
+      tag 'robot_framework'
+      aliases 'robot', 'robot-framework'
+
+      title "Robot Framework"
+      desc 'Robot Framework is a generic open source automation testing framework (robotframework.org)'
+
+      filenames '*.robot'
+      mimetypes 'text/x-robot'
+
+      def initialize(opts = {})
+        super(opts)
+        @col = 0
+        @next = nil
+        @is_template = false
+      end
+
+      def self.settings_with_keywords
+        @settings_with_keywords ||= Set.new [
+          "library", "resource", "setup", "teardown", "template", "suite setup",
+          "suite teardown", "task setup", "task teardown", "task template",
+          "test setup", "test teardown", "test template", "variables"
+        ]
+      end
+      
+      def self.settings_with_args
+        @settings_with_args ||= Set.new [
+          "arguments", "default tags", "documentation", "force tags",
+          "metadata", "return", "tags", "timeout", "task timeout",
+          "test timeout"
+        ]
+      end
+
+      id = %r/(?:\\|[^|$@&% \t\n])+(?: (?:\\.|[^|$@&% \t\n])+)*/
+      bdd = %r/(?:Given|When|Then|And|But) /i
+      sep = %r/ +\| +|[ ]{2,}|\t+/
+
+      start do
+        push :prior_text
+      end
+
+      state :prior_text do
+        rule %r/^[^*].*/, Text
+        rule(//) { pop! }
+      end
+
+      # Mixins
+
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+      end
+
+      state :section_include do
+        mixin :end_section
+        mixin :sep
+        mixin :newline
+      end
+
+      state :end_section do
+        rule(/(?=^(?:\| )?\*)/) { pop! }
+      end
+
+      state :return do
+        rule(//) { pop! }
+      end
+
+      state :sep do
+        rule %r/\| /, Text::Whitespace
+
+        rule sep do
+          token Text::Whitespace
+          @col = @col + 1
+          if @next
+            push @next
+          elsif @is_template
+            push :args
+          elsif @col == 1
+            @next = :keyword
+            push :keyword
+          else
+            push :args
+          end
+          push :cell_start
+        end
+
+        rule %r/\.\.\. */ do
+          token Text::Whitespace
+          @col = @col + 1
+          push :args
+        end
+        
+        rule %r/ ?\|/, Text::Whitespace
+      end
+
+      state :newline do
+        rule %r/\n/ do
+          token Text::Whitespace
+          @col = 0
+          @next = nil
+          push :cell_start
+        end
+      end
+
+      # States
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/^(?:\| )?\*[* ]*([A-Z]+(?: [A-Z]+)?).*/i do |m|
+          token Generic::Heading, m[0]
+          case m[1].chomp("s").downcase
+          when "setting" then push :section_settings
+          when "test case" then push :section_tests
+          when "task" then push :section_tasks
+          when "keyword" then push :section_keywords
+          when "variable" then push :section_variables
+          end
+        end
+      end
+
+      state :section_settings do
+        mixin :section_include
+
+        rule %r/([A-Z]+(?: [A-Z]+)?)(:?)/i do |m|
+          match = m[1].downcase
+          @next = if self.class.settings_with_keywords.include? match
+                    :keyword
+                  elsif self.class.settings_with_args.include? match
+                    :args
+                  end
+          groups Name::Builtin::Pseudo, Punctuation
+        end
+      end
+
+      state :section_tests do
+        mixin :section_include
+        
+        rule %r/[$@&%{}]+/, Name::Label
+        rule %r/( )(?![ |])/, Name::Label
+
+        rule id do
+          @is_template = false
+          token Name::Label
+        end
+      end
+
+      state :section_tasks do
+        mixin :section_tests
+      end
+
+      state :section_keywords do
+        mixin :section_include
+  
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          push :var
+        end
+        
+        rule %r/[$@&%{}]+/, Name::Label
+        rule %r/( )(?![ |])/, Name::Label
+        
+        rule id, Name::Label
+      end
+
+      state :section_variables do
+        mixin :section_include
+
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :args
+          push :var
+        end
+      end
+
+      state :cell_start do
+        rule %r/#.*/, Comment
+        mixin :return
+      end
+
+      state :keyword do
+        rule %r/(\[)([A-Z]+(?: [A-Z]+)?)(\])/i do |m|
+          groups Punctuation, Name::Builtin::Pseudo, Punctuation
+          
+          match = m[2].downcase
+          @is_template = true if match == "template"
+          if self.class.settings_with_keywords.include? match
+            @next = :keyword
+          elsif self.class.settings_with_args.include? match
+            @next = :args
+          end
+
+          pop!
+        end
+
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :keyword unless @next.nil?
+          push :var
+        end
+
+        rule %r/FOR/i do
+          token Name::Function
+          @next = :keyword unless @next.nil?
+        end
+
+        rule %r/( )(?![ |])/, Name::Function
+
+        rule bdd, Name::Builtin
+        rule id do
+          token Name::Function
+          @next = nil
+        end
+
+        mixin :return
+      end
+
+      state :args do
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :keyword unless @next.nil?
+          push :var
+        end
+
+        rule %r/[$@&%]+/, Str
+        rule %r/( )(?![ |])/, Str
+        rule id, Str
+        
+        mixin :return
+      end
+
+      state :var do
+        rule %r/(\})( )(=)/ do
+          groups Name::Variable, Text::Whitespace, Punctuation
+          pop!
+        end
+        rule %r/[$@&%]\{/, Name::Variable, :var
+        rule %r/[{\[]/, Name::Variable, :var
+        rule %r/[}\]]/, Name::Variable, :pop!
+        rule %r/[^$@&%{}\[\]]+/, Name::Variable
+        rule %r/\}\[/, Name::Variable
+      end
+    end
+  end
+end