rouge 3.3.0 → 3.8.0

data/lib/rouge/lexers/cfscript.rb

@@ -37,30 +37,30 @@ module Rouge
 
       state :root do
         mixin :comments_and_whitespace
-        rule /(?:#{operators.join('|')}|does not contain|greater than(?: or equal to)?|less than(?: or equal to)?)\b/i, Operator, :expr_start
+        rule %r/(?:#{operators.join('|')}|does not contain|greater than(?: or equal to)?|less than(?: or equal to)?)\b/i, Operator, :expr_start
         rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start
 
-        rule /[(\[,]/, Punctuation, :expr_start
-        rule /;/, Punctuation, :statement
-        rule /[)\].]/, Punctuation
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
 
-        rule /[?]/ do
+        rule %r/[?]/ do
           token Punctuation
           push :ternary
           push :expr_start
         end
 
-        rule /[{}]/, Punctuation, :statement
+        rule %r/[{}]/, Punctuation, :statement
 
-        rule /(?:#{constants.join('|')})\b/, Name::Constant
-        rule /(?:true|false|null)\b/, Keyword::Constant
-        rule /import\b/, Keyword::Namespace, :import
-        rule /(#{dotted_id})(\s*)(:)(\s*)/ do
+        rule %r/(?:#{constants.join('|')})\b/, Name::Constant
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/import\b/, Keyword::Namespace, :import
+        rule %r/(#{dotted_id})(\s*)(:)(\s*)/ do
           groups Name, Text, Punctuation, Text
           push :expr_start
         end
 
-        rule /([A-Za-z_$][\w.]*)(\s*)(\()/ do |m|
+        rule %r/([A-Za-z_$][\w.]*)(\s*)(\()/ do |m|
           if self.class.keywords.include? m[1]
             token Keyword, m[1]
             token Text, m[2]
@@ -87,17 +87,17 @@ module Rouge
           end
         end
 
-        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
-        rule /0x[0-9a-fA-F]+/, Num::Hex
-        rule /[0-9]+/, Num::Integer
-        rule /"(\\\\|\\"|[^"])*"/, Str::Double
-        rule /'(\\\\|\\'|[^'])*'/, Str::Single
+        rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\\\|\\"|[^"])*"/, Str::Double
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
 
       end
 
       # same as java, broken out
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/\*.*?\*/)m, Comment::Multiline
       end
@@ -105,14 +105,14 @@ module Rouge
       state :expr_start do
         mixin :comments_and_whitespace
 
-        rule /[{]/, Punctuation, :object
+        rule %r/[{]/, Punctuation, :object
 
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :statement do
 
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         mixin :expr_start
       end
@@ -120,23 +120,23 @@ module Rouge
       # object literals
       state :object do
         mixin :comments_and_whitespace
-        rule /[}]/ do
+        rule %r/[}]/ do
           token Punctuation
           push :expr_start
         end
 
-        rule /(#{dotted_id})(\s*)(:)/ do
+        rule %r/(#{dotted_id})(\s*)(:)/ do
           groups Name::Other, Text, Punctuation
           push :expr_start
         end
 
-        rule /:/, Punctuation
+        rule %r/:/, Punctuation
         mixin :root
       end
 
       # ternary expressions, where <dotted_id>: is not a label!
       state :ternary do
-        rule /:/ do
+        rule %r/:/ do
           token Punctuation
           goto :expr_start
         end
@@ -145,8 +145,8 @@ module Rouge
       end
 
       state :import do
-        rule /\s+/m, Text
-        rule /[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+        rule %r/\s+/m, Text
+        rule %r/[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
       end
 
     end

data/lib/rouge/lexers/clojure.rb

@@ -74,22 +74,22 @@ module Rouge
       end
 
       state :root do
-        rule /;.*?$/, Comment::Single
-        rule /\s+/m, Text::Whitespace
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/m, Text::Whitespace
 
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+/, Num::Integer
-        rule /0x-?[0-9a-fA-F]+/, Num::Hex
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
+        rule %r/0x-?[0-9a-fA-F]+/, Num::Hex
 
-        rule /"(\\.|[^"])*"/, Str
-        rule /'#{keyword}/, Str::Symbol
-        rule /::?#{keyword}/, Name::Constant
-        rule /\\(.|[a-z]+)/i, Str::Char
+        rule %r/"(\\.|[^"])*"/, Str
+        rule %r/'#{keyword}/, Str::Symbol
+        rule %r/::?#{keyword}/, Name::Constant
+        rule %r/\\(.|[a-z]+)/i, Str::Char
 
 
-        rule /~@|[`\'#^~&@]/, Operator
+        rule %r/~@|[`\'#^~&@]/, Operator
 
-        rule /(\()(\s*)(#{identifier})/m do |m|
+        rule %r/(\()(\s*)(#{identifier})/m do |m|
           token Punctuation, m[1]
           token Text::Whitespace, m[2]
           token(name_token(m[3]) || Name::Function, m[3])
@@ -100,13 +100,13 @@ module Rouge
         end
 
         # vectors
-        rule /[\[\]]/, Punctuation
+        rule %r/[\[\]]/, Punctuation
 
         # maps
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         # parentheses
-        rule /[()]/, Punctuation
+        rule %r/[()]/, Punctuation
       end
     end
   end

data/lib/rouge/lexers/cmake.rb

@@ -125,23 +125,23 @@ module Rouge
       ]
 
       state :default do
-        rule /\r\n?|\n/ do
+        rule %r/\r\n?|\n/ do
           token STATES_MAP[state.name.to_sym]
         end
-        rule /./ do
+        rule %r/./ do
           token STATES_MAP[state.name.to_sym]
         end
       end
 
       state :variable_interpolation do
-        rule /\$\{/ do
+        rule %r/\$\{/ do
           token Str::Interpol
           push :variable_reference
         end
       end
 
       state :bracket_close do
-        rule /\]=*\]/ do |m|
+        rule %r/\]=*\]/ do |m|
           token STATES_MAP[state.name.to_sym]
           goto :root if m[0].length == @bracket_len
         end
@@ -150,27 +150,27 @@ module Rouge
       state :root do
         mixin :variable_interpolation
 
-        rule /#{SPACE}/, Text
-        rule /[()]/, Punctuation
+        rule %r/#{SPACE}/, Text
+        rule %r/[()]/, Punctuation
 
-        rule /##{BRACKET_OPEN}/ do |m|
+        rule %r/##{BRACKET_OPEN}/ do |m|
           token Comment::Multiline
           @bracket_len = m[0].length - 1 # decount '#'
           goto :bracket_comment
         end
-        rule /#{BRACKET_OPEN}/ do |m|
+        rule %r/#{BRACKET_OPEN}/ do |m|
           token Str::Double
           @bracket_len = m[0].length
           goto :bracket_string
         end
 
-        rule /"/, Str::Double, :quoted_argument
+        rule %r/"/, Str::Double, :quoted_argument
 
-        rule /([A-Za-z_][A-Za-z0-9_]*)(#{SPACE}*)(\()/ do |m|
+        rule %r/([A-Za-z_][A-Za-z0-9_]*)(#{SPACE}*)(\()/ do |m|
           groups BUILTIN_COMMANDS.include?(m[1]) ? Name::Builtin : Name::Function, Text, Punctuation
         end
 
-        rule /#.*/, Comment::Single
+        rule %r/#.*/, Comment::Single
 
         mixin :default
       end
@@ -189,7 +189,7 @@ module Rouge
       state :variable_reference do
         mixin :variable_interpolation
 
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
 
         mixin :default
       end
@@ -197,8 +197,8 @@ module Rouge
       state :quoted_argument do
         mixin :variable_interpolation
 
-        rule /"/, Str::Double, :root
-        rule /\\[()#" \\$@^trn;]/, Str::Escape
+        rule %r/"/, Str::Double, :root
+        rule %r/\\[()#" \\$@^trn;]/, Str::Escape
 
         mixin :default
       end

data/lib/rouge/lexers/cmhg.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class CMHG < RegexLexer
+      title "CMHG"
+      desc "RISC OS C module header generator source file"
+      tag 'cmhg'
+      filenames '*.cmhg'
+
+      def self.preproc_keyword
+        @preproc_keyword ||= %w(
+          define elif else endif error if ifdef ifndef include line pragma undef warning
+        )
+      end
+
+      state :root do
+        rule %r/;[^\n]*/, Comment
+        rule %r/^([ \t]*)(#[ \t]*(?:(?:#{CMHG.preproc_keyword.join('|')})(?:[ \t].*)?)?)(?=\n)/ do
+          groups Text, Comment::Preproc
+        end
+        rule %r/[-a-z]+:/, Keyword::Declaration
+        rule %r/[a-z_]\w+/i, Name::Entity
+        rule %r/"[^"]*"/, Literal::String
+        rule %r/(?:&|0x)\h+/, Literal::Number::Hex
+        rule %r/\d+/, Literal::Number
+        rule %r/[,\/()]/, Punctuation
+        rule %r/[ \t]+/, Text
+        rule %r/\n+/, Text
+      end
+    end
+  end
+end

data/lib/rouge/lexers/coffeescript.rb

@@ -18,9 +18,17 @@ module Rouge
 
       def self.keywords
         @keywords ||= Set.new %w(
-          for in of while break return continue switch when then if else
-          throw try catch finally new delete typeof instanceof super
-          extends this class by
+          for by while until loop break continue return
+          switch when then if else do yield throw try catch finally await
+          new delete typeof instanceof super extends this class
+          import export debugger
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          case function var void with const let enum
+          native implements interface package private protected public static
         )
       end
 
@@ -42,9 +50,9 @@ module Rouge
       id = /[$a-zA-Z_][a-zA-Z0-9_]*/
 
       state :comments_and_whitespace do
-        rule /\s+/m, Text
-        rule /###\s*\n.*?###/m, Comment::Multiline
-        rule /#.*$/, Comment::Single
+        rule %r/\s+/m, Text
+        rule %r/###[^#].*?###/m, Comment::Multiline
+        rule %r/#.*$/, Comment::Single
       end
 
       state :multiline_regex do
@@ -77,25 +85,25 @@ module Rouge
         rule(%r(^(?=\s|/|<!--))) { push :slash_starts_regex }
         mixin :comments_and_whitespace
         rule %r(
-          [+][+]|--|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|[?]|:|=|
-          [|][|]|\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*`%&|^/])=?
+          [+][+]|--|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\bin\b|\bof\b|
+          [?]|:|=|[|][|]|\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*`%&|^/])=?
         )x, Operator, :slash_starts_regex
 
-        rule /[-=]>/, Name::Function
+        rule %r/[-=]>/, Name::Function
 
-        rule /(@)([ \t]*)(#{id})/ do
+        rule %r/(@)([ \t]*)(#{id})/ do
           groups Name::Variable::Instance, Text, Name::Attribute
           push :slash_starts_regex
         end
 
-        rule /([.])([ \t]*)(#{id})/ do
+        rule %r/([.])([ \t]*)(#{id})/ do
           groups Punctuation, Text, Name::Attribute
           push :slash_starts_regex
         end
 
-        rule /#{id}(?=\s*:)/, Name::Attribute, :slash_starts_regex
+        rule %r/#{id}(?=\s*:)/, Name::Attribute, :slash_starts_regex
 
-        rule /#{id}/ do |m|
+        rule %r/#{id}/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
           elsif self.class.constants.include? m[0]
@@ -109,65 +117,65 @@ module Rouge
           push :slash_starts_regex
         end
 
-        rule /[{(\[;,]/, Punctuation, :slash_starts_regex
-        rule /[})\].]/, Punctuation
+        rule %r/[{(\[;,]/, Punctuation, :slash_starts_regex
+        rule %r/[})\].]/, Punctuation
 
-        rule /\d+[.]\d+([eE]\d+)?[fd]?/, Num::Float
-        rule /0x[0-9a-fA-F]+/, Num::Hex
-        rule /\d+/, Num::Integer
-        rule /"""/, Str, :tdqs
-        rule /'''/, Str, :tsqs
-        rule /"/, Str, :dqs
-        rule /'/, Str, :sqs
+        rule %r/\d+[.]\d+([eE]\d+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/\d+/, Num::Integer
+        rule %r/"""/, Str, :tdqs
+        rule %r/'''/, Str, :tsqs
+        rule %r/"/, Str, :dqs
+        rule %r/'/, Str, :sqs
       end
 
       state :strings do
         # all coffeescript strings are multi-line
-        rule /[^#\\'"]+/m, Str
+        rule %r/[^#\\'"]+/m, Str
 
-        rule /\\./, Str::Escape
-        rule /#/, Str
+        rule %r/\\./, Str::Escape
+        rule %r/#/, Str
       end
 
       state :double_strings do
-        rule /'/, Str
+        rule %r/'/, Str
         mixin :has_interpolation
         mixin :strings
       end
 
       state :single_strings do
-        rule /"/, Str
+        rule %r/"/, Str
         mixin :strings
       end
 
       state :interpolation do
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
         mixin :root
       end
 
       state :has_interpolation do
-        rule /[#][{]/, Str::Interpol, :interpolation
+        rule %r/[#][{]/, Str::Interpol, :interpolation
       end
 
       state :dqs do
-        rule /"/, Str, :pop!
+        rule %r/"/, Str, :pop!
         mixin :double_strings
       end
 
       state :tdqs do
-        rule /"""/, Str, :pop!
-        rule /"/, Str
+        rule %r/"""/, Str, :pop!
+        rule %r/"/, Str
         mixin :double_strings
       end
 
       state :sqs do
-        rule /'/, Str, :pop!
+        rule %r/'/, Str, :pop!
         mixin :single_strings
       end
 
       state :tsqs do
-        rule /'''/, Str, :pop!
-        rule /'/, Str
+        rule %r/'''/, Str, :pop!
+        rule %r/'/, Str
         mixin :single_strings
       end
     end

data/lib/rouge/lexers/common_lisp.rb

@@ -215,19 +215,19 @@ module Rouge
       symbol = /(\|[^\|]+\||#{nonmacro}#{constituent}*)/
 
       state :root do
-        rule /\s+/m, Text
-        rule /;.*$/, Comment::Single
-        rule /#\|/, Comment::Multiline, :multiline_comment
+        rule %r/\s+/m, Text
+        rule %r/;.*$/, Comment::Single
+        rule %r/#\|/, Comment::Multiline, :multiline_comment
 
         # encoding comment
-        rule /#\d*Y.*$/, Comment::Special
-        rule /"(\\.|[^"\\])*"/, Str
+        rule %r/#\d*Y.*$/, Comment::Special
+        rule %r/"(\\.|[^"\\])*"/, Str
 
-        rule /[:']#{symbol}/, Str::Symbol
-        rule /['`]/, Operator
+        rule %r/[:']#{symbol}/, Str::Symbol
+        rule %r/['`]/, Operator
 
         # numbers
-        rule /[-+]?\d+\.?#{terminated}/, Num::Integer
+        rule %r/[-+]?\d+\.?#{terminated}/, Num::Integer
         rule %r([-+]?\d+/\d+#{terminated}), Num::Integer
         rule %r(
           [-+]?
@@ -237,65 +237,65 @@ module Rouge
         )x, Num::Float
 
         # sharpsign strings and characters
-        rule /#\\.#{terminated}/, Str::Char
-        rule /#\\#{symbol}/, Str::Char
+        rule %r/#\\.#{terminated}/, Str::Char
+        rule %r/#\\#{symbol}/, Str::Char
 
-        rule /#\(/, Operator, :root
+        rule %r/#\(/, Operator, :root
 
         # bitstring
-        rule /#\d*\*[01]*/, Other
+        rule %r/#\d*\*[01]*/, Other
 
         # uninterned symbol
-        rule /#:#{symbol}/, Str::Symbol
+        rule %r/#:#{symbol}/, Str::Symbol
 
         # read-time and load-time evaluation
-        rule /#[.,]/, Operator
+        rule %r/#[.,]/, Operator
 
         # function shorthand
-        rule /#'/, Name::Function
+        rule %r/#'/, Name::Function
 
         # binary rational
-        rule /#b[+-]?[01]+(\/[01]+)?/i, Num
+        rule %r/#b[+-]?[01]+(\/[01]+)?/i, Num
 
         # octal rational
-        rule /#o[+-]?[0-7]+(\/[0-7]+)?/i, Num::Oct
+        rule %r/#o[+-]?[0-7]+(\/[0-7]+)?/i, Num::Oct
 
         # hex rational
-        rule /#x[+-]?[0-9a-f]+(\/[0-9a-f]+)?/i, Num
+        rule %r/#x[+-]?[0-9a-f]+(\/[0-9a-f]+)?/i, Num
 
         # complex
-        rule /(#c)(\()/i do
+        rule %r/(#c)(\()/i do
           groups Num, Punctuation
           push :root
         end
 
         # arrays and structures
-        rule /(#(?:\d+a|s))(\()/i do
+        rule %r/(#(?:\d+a|s))(\()/i do
           groups Str::Other, Punctuation
           push :root
         end
 
         # path
-        rule /#p?"(\\.|[^"])*"/i, Str::Symbol
+        rule %r/#p?"(\\.|[^"])*"/i, Str::Symbol
 
         # reference
-        rule /#\d+[=#]/, Operator
+        rule %r/#\d+[=#]/, Operator
 
         # read-time comment
-        rule /#+nil#{terminated}\s*\(/, Comment, :commented_form
+        rule %r/#+nil#{terminated}\s*\(/, Comment, :commented_form
 
         # read-time conditional
-        rule /#[+-]/, Operator
+        rule %r/#[+-]/, Operator
 
         # special operators that should have been parsed already
-        rule /(,@|,|\.)/, Operator
+        rule %r/(,@|,|\.)/, Operator
 
         # special constants
-        rule /(t|nil)#{terminated}/, Name::Constant
+        rule %r/(t|nil)#{terminated}/, Name::Constant
 
         # functions and variables
         # note that these get filtered through in stream_tokens
-        rule /\*#{symbol}\*/, Name::Variable::Global
+        rule %r/\*#{symbol}\*/, Name::Variable::Global
         rule symbol do |m|
           sym = m[0]
 
@@ -318,9 +318,9 @@ module Rouge
           end
         end
 
-        rule /\(/, Punctuation, :root
-        rule /\)/, Punctuation do
-          if stack.empty?
+        rule %r/\(/, Punctuation, :root
+        rule %r/\)/, Punctuation do
+          if stack.size == 1
             token Error
           else
             token Punctuation
@@ -330,16 +330,16 @@ module Rouge
       end
 
       state :multiline_comment do
-        rule /#\|/, Comment::Multiline, :multiline_comment
-        rule /\|#/, Comment::Multiline, :pop!
-        rule /[^\|#]+/, Comment::Multiline
-        rule /[\|#]/, Comment::Multiline
+        rule %r/#\|/, Comment::Multiline, :multiline_comment
+        rule %r/\|#/, Comment::Multiline, :pop!
+        rule %r/[^\|#]+/, Comment::Multiline
+        rule %r/[\|#]/, Comment::Multiline
       end
 
       state :commented_form do
-        rule /\(/, Comment, :commented_form
-        rule /\)/, Comment, :pop!
-        rule /[^()]+/, Comment
+        rule %r/\(/, Comment, :commented_form
+        rule %r/\)/, Comment, :pop!
+        rule %r/[^()]+/, Comment
       end
     end
   end