rouge 3.4.1 → 3.6.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

@@ -18,10 +18,10 @@ module Rouge
           internal lazy let let! match member module mutable namespace
           new not null of open or override private public rec return
           return! select static struct then to true try type upcast
-          use use! val void when while with yield yield! sig atomic 
-          break checked component const constraint constructor 
-          continue eager event external fixed functor include method 
-          mixin object parallel process protected pure sealed tailcall 
+          use use! val void when while with yield yield! sig atomic
+          break checked component const constraint constructor
+          continue eager event external fixed functor include method
+          mixin object parallel process protected pure sealed tailcall
           trait virtual volatile
         )
       end
@@ -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
@@ -99,7 +95,7 @@ module Rouge
           gl_TexCoord gl_FogFragCoord gl_Color gl_SecondaryColor gl_Normal gl_VertexID
           gl_MultiTexCord0 gl_MultiTexCord1 gl_MultiTexCord2 gl_MultiTexCord3
           gl_MultiTexCord4 gl_MultiTexCord5 gl_MultiTexCord6 gl_MultiTexCord7
-          gl_FogCoord gl_MaxVertexAttribs gl_MaxVertexUniformComponents 
+          gl_FogCoord gl_MaxVertexAttribs gl_MaxVertexUniformComponents
           gl_MaxVaryingFloats gl_MaxVaryingComponents gl_MaxVertexOutputComponents
           gl_MaxGeometryInputComponents gl_MaxGeometryOutputComponents
           gl_MaxFragmentInputComponents gl_MaxVertexTextureImageUnits

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