rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/fortran.rb

@@ -88,21 +88,21 @@ module Rouge
       end
 
       state :root do
-        rule /[\s\n]+/, Text::Whitespace
-        rule /!.*$/, Comment::Single
-        rule /^#.*$/, Comment::Preproc
+        rule %r/[\s]+/, Text::Whitespace
+        rule %r/!.*$/, Comment::Single
+        rule %r/^#.*$/, Comment::Preproc
 
-        rule /::|[()\/;,:&\[\]]/, Punctuation
+        rule %r/::|[()\/;,:&\[\]]/, Punctuation
 
         # TODO: This does not take into account line continuation.
-        rule /^(\s*)([0-9]+)\b/m do |m|
+        rule %r/^(\s*)([0-9]+)\b/m do |m|
           token Text::Whitespace, m[1]
           token Name::Label, m[2]
         end
 
         # Format statements are quite a strange beast.
         # Better process them in their own state.
-        rule /\b(FORMAT)(\s*)(\()/mi do |m|
+        rule %r/\b(FORMAT)(\s*)(\()/mi do |m|
           token Keyword, m[1]
           token Text::Whitespace, m[2]
           token Punctuation, m[3]
@@ -118,25 +118,25 @@ module Rouge
           (_#{kind_param})? # kind parameter
         )xi, Num::Float
 
-        rule /[+-]?\d+(_#{kind_param})?/i, Num::Integer
-        rule /B'[01]+'|B"[01]+"/i, Num::Bin
-        rule /O'[0-7]+'|O"[0-7]+"/i, Num::Oct
-        rule /Z'[0-9A-F]+'|Z"[0-9A-F]+"/i, Num::Hex
-        rule /(#{kind_param}_)?'/, Str::Single, :string_single
-        rule /(#{kind_param}_)?"/, Str::Double, :string_double
-        rule /[.](TRUE|FALSE)[.](_#{kind_param})?/i, Keyword::Constant
+        rule %r/[+-]?\d+(_#{kind_param})?/i, Num::Integer
+        rule %r/B'[01]+'|B"[01]+"/i, Num::Bin
+        rule %r/O'[0-7]+'|O"[0-7]+"/i, Num::Oct
+        rule %r/Z'[0-9A-F]+'|Z"[0-9A-F]+"/i, Num::Hex
+        rule %r/(#{kind_param}_)?'/, Str::Single, :string_single
+        rule %r/(#{kind_param}_)?"/, Str::Double, :string_double
+        rule %r/[.](TRUE|FALSE)[.](_#{kind_param})?/i, Keyword::Constant
 
         rule %r{\*\*|//|==|/=|<=|>=|=>|[-+*/<>=%]}, Operator
-        rule /\.(?:EQ|NE|LT|LE|GT|GE|NOT|AND|OR|EQV|NEQV|[A-Z]+)\./i, Operator::Word
+        rule %r/\.(?:EQ|NE|LT|LE|GT|GE|NOT|AND|OR|EQV|NEQV|[A-Z]+)\./i, Operator::Word
 
         # Special rules for two-word keywords and types.
         # Note: "doubleprecision" is covered by the normal keyword rule.
-        rule /double\s+precision\b/i, Keyword::Type
-        rule /go\s+to\b/i, Keyword
-        rule /sync\s+(all|images|memory)\b/i, Keyword
-        rule /error\s+stop\b/i, Keyword
+        rule %r/double\s+precision\b/i, Keyword::Type
+        rule %r/go\s+to\b/i, Keyword
+        rule %r/sync\s+(all|images|memory)\b/i, Keyword
+        rule %r/error\s+stop\b/i, Keyword
 
-        rule /#{name}/m do |m|
+        rule %r/#{name}/m do |m|
           match = m[0].downcase
           if self.class.keywords.include? match
             token Keyword
@@ -152,26 +152,26 @@ module Rouge
       end
 
       state :string_single do
-        rule /[^']+/, Str::Single
-        rule /''/, Str::Escape
-        rule /'/, Str::Single, :pop!
+        rule %r/[^']+/, Str::Single
+        rule %r/''/, Str::Escape
+        rule %r/'/, Str::Single, :pop!
       end
 
       state :string_double do
-        rule /[^"]+/, Str::Double
-        rule /""/, Str::Escape
-        rule /"/, Str::Double, :pop!
+        rule %r/[^"]+/, Str::Double
+        rule %r/""/, Str::Escape
+        rule %r/"/, Str::Double, :pop!
       end
 
       state :format_spec do
-        rule /'/, Str::Single, :string_single
-        rule /"/, Str::Double, :string_double
-        rule /\(/, Punctuation, :format_spec
-        rule /\)/, Punctuation, :pop!
-        rule /,/, Punctuation
-        rule /[\s\n]+/, Text::Whitespace
+        rule %r/'/, Str::Single, :string_single
+        rule %r/"/, Str::Double, :string_double
+        rule %r/\(/, Punctuation, :format_spec
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/[\s]+/, Text::Whitespace
         # Edit descriptors could be seen as a kind of "format literal".
-        rule /[^\s'"(),]+/, Literal
+        rule %r/[^\s'"(),]+/, Literal
       end
     end
   end

data/lib/rouge/lexers/fsharp.rb

@@ -46,11 +46,11 @@ module Rouge
       upper_id = /[A-Z][\w']*/
 
       state :root do
-        rule /\s+/m, Text
-        rule /false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
-        rule /#{upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+        rule %r/\s+/m, Text
+        rule %r/false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace, :dotted
         rule upper_id, Name::Class
-        rule /[(][*](?![)])/, Comment, :comment
+        rule %r/[(][*](?![)])/, Comment, :comment
         rule %r(//.*?$), Comment::Single
         rule id do |m|
           match = m[0]
@@ -74,43 +74,43 @@ module Rouge
           end
         end
 
-        rule /-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
-        rule /0x\h[\h_]*/i, Num::Hex
-        rule /0o[0-7][0-7_]*/i, Num::Oct
-        rule /0b[01][01_]*/i, Num::Bin
-        rule /\d[\d_]*/, Num::Integer
+        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 /'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
-        rule /'[.]'/, Str::Char
-        rule /'/, Keyword
-        rule /"/, Str::Double, :string
-        rule /[~?]#{id}/, Name::Variable
+        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 /[^(*)]+/, Comment
+        rule %r/[^(*)]+/, Comment
         rule(/[(][*]/) { token Comment; push }
-        rule /[*][)]/, Comment, :pop!
-        rule /[(*)]/, Comment
+        rule %r/[*][)]/, Comment, :pop!
+        rule %r/[(*)]/, Comment
       end
 
       state :string do
-        rule /[^\\"]+/, Str::Double
+        rule %r/[^\\"]+/, Str::Double
         mixin :escape_sequence
-        rule /\\\n/, Str::Double
-        rule /"/, Str::Double, :pop!
+        rule %r/\\\n/, Str::Double
+        rule %r/"/, Str::Double, :pop!
       end
 
       state :escape_sequence do
-        rule /\\[\\"'ntbr]/, Str::Escape
-        rule /\\\d{3}/, Str::Escape
-        rule /\\x\h{2}/, Str::Escape
+        rule %r/\\[\\"'ntbr]/, Str::Escape
+        rule %r/\\\d{3}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
       end
 
       state :dotted do
-        rule /\s+/m, Text
-        rule /[.]/, Punctuation
-        rule /#{upper_id}(?=\s*[.])/, Name::Namespace
+        rule %r/\s+/m, Text
+        rule %r/[.]/, Punctuation
+        rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace
         rule upper_id, Name::Class, :pop!
         rule id, Name, :pop!
       end

data/lib/rouge/lexers/gherkin.rb

@@ -19,7 +19,7 @@ module Rouge
 
       # self-modifying method that loads the keywords file
       def self.keywords
-        load Pathname.new(__FILE__).dirname.join('gherkin/keywords.rb')
+        load File.join(__dir__, 'gherkin/keywords.rb')
         keywords
       end
 
@@ -41,7 +41,7 @@ module Rouge
 
       state :basic do
         rule %r(#.*$), Comment
-        rule /[ \r\t]+/, Text
+        rule %r/[ \r\t]+/, Text
       end
 
       state :root do
@@ -85,8 +85,8 @@ module Rouge
       end
 
       state :table_header do
-        rule /[^|\s]+/, Name::Variable
-        rule /\n/ do
+        rule %r/[^|\s]+/, Name::Variable
+        rule %r/\n/ do
           token Text
           goto :table
         end
@@ -95,9 +95,9 @@ module Rouge
 
       state :table do
         mixin :basic
-        rule /\n/, Text, :table_bol
-        rule /[|]/, Punctuation
-        rule /[^|\s]+/, Name
+        rule %r/\n/, Text, :table_bol
+        rule %r/[|]/, Punctuation
+        rule %r/[^|\s]+/, Name
       end
 
       state :table_bol do
@@ -108,29 +108,29 @@ module Rouge
       state :description do
         mixin :basic
         mixin :has_examples
-        rule /\n/, Text
+        rule %r/\n/, Text
         rule rest_of_line, Text
       end
 
       state :feature_description do
         mixin :basic
         mixin :has_scenarios
-        rule /\n/, Text
+        rule %r/\n/, Text
         rule rest_of_line, Text
       end
 
       state :example_description do
         mixin :basic
         mixin :has_table
-        rule /\n/, Text
+        rule %r/\n/, Text
         rule rest_of_line, Text
       end
 
       state :step do
         mixin :basic
-        rule /<.*?>/, Name::Variable
-        rule /".*?"/, Str
-        rule /\S+/, Text
+        rule %r/<.*?>/, Name::Variable
+        rule %r/".*?"/, Str
+        rule %r/\S+/, Text
         rule rest_of_line, Text, :pop!
       end
     end

data/lib/rouge/lexers/glsl.rb

@@ -17,10 +17,6 @@ module Rouge
       title "GLSL"
       desc "The GLSL shader language"
 
-      # optional comment or whitespace
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
-      id = /[a-zA-Z_][a-zA-Z0-9_]*/
-
       def self.keywords
         @keywords ||= Set.new %w(
           attribute const uniform varying

data/lib/rouge/lexers/go.rb

@@ -14,7 +14,7 @@ module Rouge
 
       # Characters
 
-      WHITE_SPACE            = /[\s\t\r\n]+/
+      WHITE_SPACE            = /\s+/
 
       NEWLINE                = /\n/
       UNICODE_CHAR           = /[^\n]/

data/lib/rouge/lexers/graphql.rb

@@ -12,24 +12,24 @@ module Rouge
       name = /[_A-Za-z][_0-9A-Za-z]*/
 
       state :root do
-        rule /\b(?:query|mutation|subscription)\b/, Keyword, :query_definition
-        rule /\{/ do
+        rule %r/\b(?:query|mutation|subscription)\b/, Keyword, :query_definition
+        rule %r/\{/ do
           token Punctuation
           push :query_definition
           push :selection_set
         end
 
-        rule /\bfragment\b/, Keyword, :fragment_definition
+        rule %r/\bfragment\b/, Keyword, :fragment_definition
 
-        rule /\b(?:type|interface|enum)\b/, Keyword, :type_definition
-        rule /\b(?:input|schema)\b/, Keyword, :type_definition
+        rule %r/\b(?:type|interface|enum)\b/, Keyword, :type_definition
+        rule %r/\b(?:input|schema)\b/, Keyword, :type_definition
 
-        rule /\bunion\b/, Keyword, :union_definition
+        rule %r/\bunion\b/, Keyword, :union_definition
 
         mixin :basic
 
         # Markdown descriptions
-        rule /(""")(.*?)(""")/m do |m|
+        rule %r/(""")(.*?)(""")/m do |m|
           token Str::Double, m[1]
           delegate Markdown, m[2]
           token Str::Double, m[3]
@@ -37,22 +37,22 @@ module Rouge
       end
 
       state :basic do
-        rule /\s+/m, Text::Whitespace
-        rule /#.*$/, Comment
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/#.*$/, Comment
 
-        rule /[!,]/, Punctuation
+        rule %r/[!,]/, Punctuation
       end
 
       state :has_directives do
-        rule /(@#{name})(\s*)(\()/ do
+        rule %r/(@#{name})(\s*)(\()/ do
           groups Keyword, Text::Whitespace, Punctuation
           push :arguments
         end
-        rule /@#{name}\b/, Keyword
+        rule %r/@#{name}\b/, Keyword
       end
 
       state :fragment_definition do
-        rule /\bon\b/, Keyword
+        rule %r/\bon\b/, Keyword
 
         mixin :query_definition
       end
@@ -60,31 +60,31 @@ module Rouge
       state :query_definition do
         mixin :has_directives
 
-        rule /\b#{name}\b/, Name
-        rule /\(/, Punctuation, :variable_definitions
-        rule /\{/, Punctuation, :selection_set
+        rule %r/\b#{name}\b/, Name
+        rule %r/\(/, Punctuation, :variable_definitions
+        rule %r/\{/, Punctuation, :selection_set
 
         mixin :basic
       end
 
       state :type_definition do
-        rule /\bimplements\b/, Keyword
-        rule /\b#{name}\b/, Name
-        rule /\(/, Punctuation, :variable_definitions
-        rule /\{/, Punctuation, :type_definition_set
+        rule %r/\bimplements\b/, Keyword
+        rule %r/\b#{name}\b/, Name
+        rule %r/\(/, Punctuation, :variable_definitions
+        rule %r/\{/, Punctuation, :type_definition_set
 
         mixin :basic
       end
 
       state :union_definition do
-        rule /\b#{name}\b/, Name
-        rule /\=/, Punctuation, :union_definition_variant
+        rule %r/\b#{name}\b/, Name
+        rule %r/\=/, Punctuation, :union_definition_variant
 
         mixin :basic
       end
 
       state :union_definition_variant do
-        rule /\b#{name}\b/ do
+        rule %r/\b#{name}\b/ do
           token Name
           pop!
           push :union_definition_pipe
@@ -94,13 +94,13 @@ module Rouge
       end
 
       state :union_definition_pipe do
-        rule /\|/ do
+        rule %r/\|/ do
           token Punctuation
           pop!
           push :union_definition_variant
         end
 
-        rule /(?!\||\s+|#[^\n]*)/ do
+        rule %r/(?!\||\s+|#[^\n]*)/ do
           pop! 2
         end
 
@@ -108,62 +108,62 @@ module Rouge
       end
 
       state :type_definition_set do
-        rule /\}/ do
+        rule %r/\}/ do
           token Punctuation
           pop! 2
         end
 
-        rule /\b(#{name})(\s*)(\()/ do
+        rule %r/\b(#{name})(\s*)(\()/ do
           groups Name, Text::Whitespace, Punctuation
           push :variable_definitions
         end
-        rule /\b#{name}\b/, Name
+        rule %r/\b#{name}\b/, Name
 
-        rule /:/, Punctuation, :type_names
+        rule %r/:/, Punctuation, :type_names
 
         mixin :basic
       end
 
       state :arguments do
-        rule /\)/ do
+        rule %r/\)/ do
           token Punctuation
           pop!
         end
 
-        rule /\b#{name}\b/, Name
-        rule /:/, Punctuation, :value
+        rule %r/\b#{name}\b/, Name
+        rule %r/:/, Punctuation, :value
 
         mixin :basic
       end
 
       state :variable_definitions do
-        rule /\)/ do
+        rule %r/\)/ do
           token Punctuation
           pop!
         end
 
-        rule /\$#{name}\b/, Name::Variable
-        rule /\b#{name}\b/, Name
-        rule /:/, Punctuation, :type_names
-        rule /\=/, Punctuation, :value
+        rule %r/\$#{name}\b/, Name::Variable
+        rule %r/\b#{name}\b/, Name
+        rule %r/:/, Punctuation, :type_names
+        rule %r/\=/, Punctuation, :value
 
         mixin :basic
       end
 
       state :type_names do
-        rule /\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin, :pop!
-        rule /\b#{name}\b/, Name, :pop!
+        rule %r/\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin, :pop!
+        rule %r/\b#{name}\b/, Name, :pop!
 
-        rule /\[/, Punctuation, :type_name_list
+        rule %r/\[/, Punctuation, :type_name_list
 
         mixin :basic
       end
 
       state :type_name_list do
-        rule /\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin
-        rule /\b#{name}\b/, Name
+        rule %r/\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin
+        rule %r/\b#{name}\b/, Name
 
-        rule /\]/ do
+        rule %r/\]/ do
           token Punctuation
           pop! 2
         end
@@ -174,35 +174,35 @@ module Rouge
       state :selection_set do
         mixin :has_directives
 
-        rule /\}/ do
+        rule %r/\}/ do
           token Punctuation
           pop!
           pop! if state?(:query_definition) || state?(:fragment_definition)
         end
 
-        rule /\b(#{name})(\s*)(\()/ do
+        rule %r/\b(#{name})(\s*)(\()/ do
           groups Name, Text::Whitespace, Punctuation
           push :arguments
         end
 
-        rule /\b(#{name})(\s*)(:)/ do
+        rule %r/\b(#{name})(\s*)(:)/ do
           groups Name, Text::Whitespace, Punctuation
         end
 
-        rule /\b#{name}\b/, Name
+        rule %r/\b#{name}\b/, Name
 
-        rule /(\.\.\.)(\s+)(on)\b/ do
+        rule %r/(\.\.\.)(\s+)(on)\b/ do
           groups Punctuation, Text::Whitespace, Keyword
         end
-        rule /\.\.\./, Punctuation
+        rule %r/\.\.\./, Punctuation
 
-        rule /\{/, Punctuation, :selection_set
+        rule %r/\{/, Punctuation, :selection_set
 
         mixin :basic
       end
 
       state :list do
-        rule /\]/ do
+        rule %r/\]/ do
           token Punctuation
           pop!
           pop! if state?(:value)
@@ -212,13 +212,13 @@ module Rouge
       end
 
       state :object do
-        rule /\}/ do
+        rule %r/\}/ do
           token Punctuation
           pop!
           pop! if state?(:value)
         end
 
-        rule /\b(#{name})(\s*)(:)/ do
+        rule %r/\b(#{name})(\s*)(:)/ do
           groups Name, Text::Whitespace, Punctuation
           push :value
         end
@@ -235,17 +235,17 @@ module Rouge
         }
 
         # Multiline strings
-        rule /""".*?"""/m, Str::Double
+        rule %r/""".*?"""/m, Str::Double
 
-        rule /\$#{name}\b/, &pop_unless_list[Name::Variable]
-        rule /\b(?:true|false|null)\b/, &pop_unless_list[Keyword::Constant]
-        rule /[+-]?[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Float]
-        rule /[+-]?[1-9][0-9]*(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Integer]
-        rule /"(\\[\\"]|[^"])*"/, &pop_unless_list[Str::Double]
-        rule /\b#{name}\b/, &pop_unless_list[Name]
+        rule %r/\$#{name}\b/, &pop_unless_list[Name::Variable]
+        rule %r/\b(?:true|false|null)\b/, &pop_unless_list[Keyword::Constant]
+        rule %r/[+-]?[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Float]
+        rule %r/[+-]?[1-9][0-9]*(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Integer]
+        rule %r/"(\\[\\"]|[^"])*"/, &pop_unless_list[Str::Double]
+        rule %r/\b#{name}\b/, &pop_unless_list[Name]
 
-        rule /\{/, Punctuation, :object
-        rule /\[/, Punctuation, :list
+        rule %r/\{/, Punctuation, :object
+        rule %r/\[/, Punctuation, :list
 
         mixin :basic
       end