rouge 3.7.0 → 3.11.1

data/lib/rouge/lexers/msgtrans.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class MsgTrans < RegexLexer
+      title "MessageTrans"
+      desc "RISC OS message translator messages file"
+      tag 'msgtrans'
+      filenames 'Messages', 'Message[0-9]', 'Message[1-9][0-9]', 'Message[1-9][0-9][0-9]'
+
+      state :root do
+        rule %r/^#[^\n]*/, Comment
+        rule %r/[^\t\n\r ,):?\/]+/, Name::Variable
+        rule %r/[\n\/?]/, Operator
+        rule %r/:/, Operator, :value
+      end
+
+      state :value do
+        rule %r/\n/, Text, :pop!
+        rule %r/%[0-3%]/, Operator
+        rule %r/[^\n%]/, Literal::String
+      end
+    end
+  end
+end

data/lib/rouge/lexers/perl.rb

@@ -127,7 +127,7 @@ module Rouge
         rule %r/(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
         rule %r/(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
         rule %r/(q|qq|qw|qr|qx)</, Str::Other, :lt_string
-        rule %r/(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
+        rule %r/(q|qq|qw|qr|qx)(\W)(.|\n)*?\2/, Str::Other
 
         rule %r/package\s+/, Keyword, :modulename
         rule %r/sub\s+/, Keyword, :funcname

data/lib/rouge/lexers/plain_text.rb

@@ -9,7 +9,7 @@ module Rouge
 
       tag 'plaintext'
       aliases 'text'
-      filenames '*.txt'
+      filenames '*.txt', 'Messages'
       mimetypes 'text/plain'
 
       attr_reader :token

data/lib/rouge/lexers/puppet.rb

@@ -59,7 +59,7 @@ module Rouge
         rule cap_id, Name::Class
 
         rule %r/[+=|~-]>|<[|~-]/, Punctuation
-        rule %r/[:}();\[\]]/, Punctuation
+        rule %r/[|:}();\[\]]/, Punctuation
 
         # HACK for case statements and selectors
         rule %r/{/, Punctuation, :regex_allowed
@@ -68,7 +68,7 @@ module Rouge
         rule %r/(in|and|or)\b/, Operator::Word
         rule %r/[=!<>]=/, Operator
         rule %r/[=!]~/, Operator, :regex_allowed
-        rule %r([=<>!+*/-]), Operator
+        rule %r([.=<>!+*/-]), Operator
 
         rule %r/(class|include)(\s*)(#{qualname})/ do
           groups Keyword, Text, Name::Class

data/lib/rouge/lexers/q.rb

@@ -67,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)

data/lib/rouge/lexers/r.rb

@@ -60,8 +60,7 @@ module Rouge
         rule %r/%[^%]*?%/, Operator
 
         rule %r/0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?/, Num::Hex
-        rule %r/[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?[Li]?/,
-          Num
+        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.
@@ -69,7 +68,7 @@ module Rouge
         # highlighted specifically; thus use `Name::Function`.
         rule %r/\b(?<!.)(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
 
-        rule %r/[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]

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

data/lib/rouge/lexers/sed.rb

@@ -141,7 +141,7 @@ module Rouge
         end
 
         # alternate regex rage delimiters
-        rule %r((\\)(.)(\\.|.)*?(\2)) do |m|
+        rule %r((\\)(.)((?:\\.|.)*?)(\2)) do |m|
           token addr_tok, m[1] + m[2]
           delegate regex, m[3]
           token addr_tok, m[4]

data/lib/rouge/lexers/shell.rb

@@ -9,10 +9,12 @@ module Rouge
 
       tag 'shell'
       aliases 'bash', 'zsh', 'ksh', 'sh'
-      filenames '*.sh', '*.bash', '*.zsh', '*.ksh',
-                '.bashrc', '.zshrc', '.kshrc', '.profile', 'APKBUILD', 'PKGBUILD'
+      filenames '*.sh', '*.bash', '*.zsh', '*.ksh', '.bashrc', '.zshrc',
+                '.kshrc', '.profile', 'APKBUILD', 'PKGBUILD', '*.ebuild',
+                '*.eclass', '*.exheres-0', '*.exlib'
 
-      mimetypes 'application/x-sh', 'application/x-shellscript'
+      mimetypes 'application/x-sh', 'application/x-shellscript', 'text/x-sh',
+                'text/x-shellscript'
 
       def self.detect?(text)
         return true if text.shebang?(/(ba|z|k)?sh/)

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