rouge 3.0.0 → 3.18.0

data/lib/rouge/lexers/sass.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -17,13 +18,13 @@ module Rouge
       id = /[\w-]+/
 
       state :root do
-        rule /[ \t]*\n/, Text
+        rule %r/[ \t]*\n/, Text
         rule(/[ \t]*/) { |m| token Text; indentation(m[0]) }
       end
 
       state :content do
         # block comments
-        rule %r(//.*?\n) do
+        rule %r(//.*?$) do
           token Comment::Single
           pop!; starts_block :single_comment
         end
@@ -33,32 +34,32 @@ module Rouge
           pop!; starts_block :multi_comment
         end
 
-        rule /@import\b/, Keyword, :import
+        rule %r/@import\b/, Keyword, :import
 
         mixin :content_common
 
         rule %r(=#{id}), Name::Function, :value
         rule %r([+]#{id}), Name::Decorator, :value
 
-        rule /:/, Name::Attribute, :old_style_attr
+        rule %r/:/, Name::Attribute, :old_style_attr
 
-        rule(/(?=.+?:([^a-z]|$))/) { push :attribute }
+        rule(/(?=[^\[\n]+?:([^a-z]|$))/) { push :attribute }
 
         rule(//) { push :selector }
       end
 
       state :single_comment do
-        rule /.*?\n/, Comment::Single, :pop!
+        rule %r/.*?$/, Comment::Single, :pop!
       end
 
       state :multi_comment do
-        rule /.*?\n/, Comment::Multiline, :pop!
+        rule %r/.*?\n/, Comment::Multiline, :pop!
       end
 
       state :import do
-        rule /[ \t]+/, Text
-        rule /\S+/, Str
-        rule /\n/, Text, :pop!
+        rule %r/[ \t]+/, Text
+        rule %r/\S+/, Str
+        rule %r/\n/, Text, :pop!
       end
 
       state :old_style_attr do

data/lib/rouge/lexers/sass/common.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -7,30 +8,30 @@ module Rouge
       id = /[\w-]+/
 
       state :content_common do
-        rule /@for\b/, Keyword, :for
-        rule /@(debug|warn|if|each|while|else|return|media)/, Keyword, :value
+        rule %r/@for\b/, Keyword, :for
+        rule %r/@(debug|warn|if|each|while|else|return|media)/, Keyword, :value
 
-        rule /(@mixin)(\s+)(#{id})/ do
+        rule %r/(@mixin)(\s+)(#{id})/ do
           groups Keyword, Text, Name::Function
           push :value
         end
 
-        rule /(@function)(\s+)(#{id})/ do
+        rule %r/(@function)(\s+)(#{id})/ do
           groups Keyword, Text, Name::Function
           push :value
         end
 
-        rule /@extend\b/, Keyword, :selector
+        rule %r/@extend\b/, Keyword, :selector
 
-        rule /(@include)(\s+)(#{id})/ do
+        rule %r/(@include)(\s+)(#{id})/ do
           groups Keyword, Text, Name::Decorator
           push :value
         end
 
-        rule /@#{id}/, Keyword, :selector
+        rule %r/@#{id}/, Keyword, :selector
 
         # $variable: assignment
-        rule /([$]#{id})([ \t]*)(:)/ do
+        rule %r/([$]#{id})([ \t]*)(:)/ do
           groups Name::Variable, Text, Punctuation
           push :value
         end
@@ -38,26 +39,26 @@ module Rouge
 
       state :value do
         mixin :end_section
-        rule /[ \t]+/, Text
-        rule /[$]#{id}/, Name::Variable
-        rule /url[(]/, Str::Other, :string_url
-        rule /#{id}(?=\s*[(])/, Name::Function
-        rule /%#{id}/, Name::Decorator
+        rule %r/[ \t]+/, Text
+        rule %r/[$]#{id}/, Name::Variable
+        rule %r/url[(]/, Str::Other, :string_url
+        rule %r/#{id}(?=\s*[(])/, Name::Function
+        rule %r/%#{id}/, Name::Decorator
 
         # named literals
-        rule /(true|false)\b/, Name::Builtin::Pseudo
-        rule /(and|or|not)\b/, Operator::Word
+        rule %r/(true|false)\b/, Name::Builtin::Pseudo
+        rule %r/(and|or|not)\b/, Operator::Word
 
         # colors and numbers
-        rule /#[a-z0-9]{1,6}/i, Num::Hex
-        rule /-?\d+(%|[a-z]+)?/, Num
-        rule /-?\d*\.\d+(%|[a-z]+)?/, Num::Integer
+        rule %r/#[a-z0-9]{1,6}/i, Num::Hex
+        rule %r/-?\d+(%|[a-z]+)?/, Num
+        rule %r/-?\d*\.\d+(%|[a-z]+)?/, Num::Integer
 
         mixin :has_strings
         mixin :has_interp
 
-        rule /[~^*!&%<>\|+=@:,.\/?-]+/, Operator
-        rule /[\[\]()]+/, Punctuation
+        rule %r/[~^*!&%<>\|+=@:,.\/?-]+/, Operator
+        rule %r/[\[\]()]+/, Punctuation
         rule %r(/[*]), Comment::Multiline, :inline_comment
         rule %r(//[^\n]*), Comment::Single
 
@@ -74,16 +75,16 @@ module Rouge
       end
 
       state :has_interp do
-        rule /[#][{]/, Str::Interpol, :interpolation
+        rule %r/[#][{]/, Str::Interpol, :interpolation
       end
 
       state :has_strings do
-        rule /"/, Str::Double, :dq
-        rule /'/, Str::Single, :sq
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
       end
 
       state :interpolation do
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
         mixin :value
       end
 
@@ -92,31 +93,31 @@ module Rouge
 
         mixin :has_strings
         mixin :has_interp
-        rule /[ \t]+/, Text
-        rule /:/, Name::Decorator, :pseudo_class
-        rule /[.]/, Name::Class, :class
-        rule /#/, Name::Namespace, :id
-        rule /%/, Name::Variable, :placeholder
+        rule %r/[ \t]+/, Text
+        rule %r/:/, Name::Decorator, :pseudo_class
+        rule %r/[.]/, Name::Class, :class
+        rule %r/#/, Name::Namespace, :id
+        rule %r/%/, Name::Variable, :placeholder
         rule id, Name::Tag
-        rule /&/, Keyword
-        rule /[~^*!&\[\]()<>\|+=@:;,.\/?-]/, Operator
+        rule %r/&/, Keyword
+        rule %r/[~^*!&\[\]()<>\|+=@:;,.\/?-]/, Operator
       end
 
       state :dq do
-        rule /"/, Str::Double, :pop!
+        rule %r/"/, Str::Double, :pop!
         mixin :has_interp
-        rule /(\\.|#(?![{])|[^\n"#])+/, Str::Double
+        rule %r/(\\.|#(?![{])|[^\n"#])+/, Str::Double
       end
 
       state :sq do
-        rule /'/, Str::Single, :pop!
+        rule %r/'/, Str::Single, :pop!
         mixin :has_interp
-        rule /(\\.|#(?![{])|[^\n'#])+/, Str::Single
+        rule %r/(\\.|#(?![{])|[^\n'#])+/, Str::Single
       end
 
       state :string_url do
-        rule /[)]/, Str::Other, :pop!
-        rule /(\\.|#(?![{])|[^\n)#])+/, Str::Other
+        rule %r/[)]/, Str::Other, :pop!
+        rule %r/(\\.|#(?![{])|[^\n)#])+/, Str::Other
         mixin :has_interp
       end
 
@@ -146,7 +147,7 @@ module Rouge
       end
 
       state :for do
-        rule /(from|to|through)/, Operator::Word
+        rule %r/(from|to|through)/, Operator::Word
         mixin :value
       end
 
@@ -164,14 +165,14 @@ module Rouge
       state :attribute do
         mixin :attr_common
 
-        rule /([ \t]*)(:)/ do
+        rule %r/([ \t]*)(:)/ do
           groups Text, Punctuation
           push :value
         end
       end
 
       state :inline_comment do
-        rule /(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, Comment::Multiline
+        rule %r/(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, Comment::Multiline
         mixin :has_interp
         rule %r([*]/), Comment::Multiline, :pop!
       end

data/lib/rouge/lexers/scala.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -35,96 +36,122 @@ module Rouge
       )
 
       state :root do
-        rule /(class|trait|object)(\s+)/ do
+        rule %r/(class|trait|object)(\s+)/ do
           groups Keyword, Text
           push :class
         end
-        rule /'#{idrest}[^']/, Str::Symbol
-        rule /[^\S\n]+/, Text
+        rule %r/'#{idrest}(?!')/, Str::Symbol
+        rule %r/[^\S\n]+/, Text
 
-        rule %r(//.*?\n), Comment::Single
+        rule %r(//.*), Comment::Single
         rule %r(/\*), Comment::Multiline, :comment
 
-        rule /@#{idrest}/, Name::Decorator
+        rule %r/@#{idrest}/, Name::Decorator
+
+        rule %r/(def)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+          groups Keyword, Text, Name::Function, Text
+        end
+
+        rule %r/(val)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+          groups Keyword, Text, Name::Variable, Text
+        end
+
+        rule %r/(this)(\n*)(\.)(#{idrest})/ do
+          groups Keyword, Text, Operator, Name::Property
+        end
+
+        rule %r/(#{idrest}|_)(\n*)(\.)(#{idrest})/ do
+          groups Name::Variable, Text, Operator, Name::Property
+        end
+
+        rule %r/#{upper}#{idrest}\b/, Name::Class
+
+        rule %r/(#{idrest})(#{whitespace}*)(\()/ do
+          groups Name::Function, Text, Operator
+        end
+
+        rule %r/(\.)(#{idrest})/ do
+          groups Operator, Name::Property
+        end
+
         rule %r(
           (#{keywords.join("|")})\b|
           (<[%:-]|=>|>:|[#=@_\u21D2\u2190])(\b|(?=\s)|$)
         )x, Keyword
-        rule /:(?!#{op})/, Keyword, :type
-        rule /#{upper}#{idrest}\b/, Name::Class
-        rule /(true|false|null)\b/, Keyword::Constant
-        rule /(import|package)(\s+)/ do
+        rule %r/:(?!#{op})/, Keyword, :type
+        rule %r/(true|false|null)\b/, Keyword::Constant
+        rule %r/(import|package)(\s+)/ do
           groups Keyword, Text
           push :import
         end
 
-        rule /(type)(\s+)/ do
+        rule %r/(type)(\s+)/ do
           groups Keyword, Text
           push :type
         end
 
-        rule /""".*?"""(?!")/m, Str
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'/, Str::Char
+        rule %r/""".*?"""(?!")/m, Str
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'/, Str::Char
 
         rule idrest, Name
-        rule /`[^`]+`/, Name
+        rule %r/`[^`]+`/, Name
 
-        rule /\[/, Operator, :typeparam
-        rule /[\(\)\{\};,.#]/, Operator
-        rule /#{op}+/, Operator
+        rule %r/\[/, Operator, :typeparam
+        rule %r/[\(\)\{\};,.#]/, Operator
+        rule %r/#{op}+/, Operator
 
-        rule /([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?/, Num::Float
-        rule /([0-9][0-9]*[fFdD])/, Num::Float
-        rule /0x[0-9a-fA-F]+/, Num::Hex
-        rule /[0-9]+L?/, Num::Integer
-        rule /\n/, Text
+        rule %r/([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?/, Num::Float
+        rule %r/([0-9][0-9]*[fFdD])/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/[0-9]+L?/, Num::Integer
+        rule %r/\n/, Text
       end
 
       state :class do
-        rule /(#{idrest}|#{op}+|`[^`]+`)(\s*)(\[)/ do
+        rule %r/(#{idrest}|#{op}+|`[^`]+`)(\s*)(\[)/ do
           groups Name::Class, Text, Operator
           push :typeparam
         end
 
-        rule /\s+/, Text
-        rule /{/, Operator, :pop!
-        rule /\(/, Operator, :pop!
-        rule %r(//.*?\n), Comment::Single, :pop!
+        rule %r/\s+/, Text
+        rule %r/{/, Operator, :pop!
+        rule %r/\(/, Operator, :pop!
+        rule %r(//.*), Comment::Single, :pop!
         rule %r(#{idrest}|#{op}+|`[^`]+`), Name::Class, :pop!
       end
 
       state :type do
-        rule /\s+/, Text
-        rule /<[%:]|>:|[#_\u21D2]|forSome|type/, Keyword
-        rule /([,\);}]|=>|=)(\s*)/ do
+        rule %r/\s+/, Text
+        rule %r/<[%:]|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule %r/([,\);}]|=>|=)(\s*)/ do
           groups Operator, Text
           pop!
         end
-        rule /[\(\{]/, Operator, :type
+        rule %r/[\(\{]/, Operator, :type
 
         typechunk = /(?:#{idrest}|#{op}+\`[^`]+`)/
-        rule /(#{typechunk}(?:\.#{typechunk})*)(\s*)(\[)/ do
+        rule %r/(#{typechunk}(?:\.#{typechunk})*)(\s*)(\[)/ do
           groups Keyword::Type, Text, Operator
           pop!
           push :typeparam
         end
 
-        rule /(#{typechunk}(?:\.#{typechunk})*)(\s*)$/ do
+        rule %r/(#{typechunk}(?:\.#{typechunk})*)(\s*)$/ do
           groups Keyword::Type, Text
           pop!
         end
 
-        rule %r(//.*?\n), Comment::Single, :pop!
-        rule /\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
+        rule %r(//.*), Comment::Single, :pop!
+        rule %r/\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
       end
 
       state :typeparam do
-        rule /[\s,]+/, Text
-        rule /<[%:]|=>|>:|[#_\u21D2]|forSome|type/, Keyword
-        rule /([\]\)\}])/, Operator, :pop!
-        rule /[\(\[\{]/, Operator, :typeparam
-        rule /\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
+        rule %r/[\s,]+/, Text
+        rule %r/<[%:]|=>|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule %r/([\]\)\}])/, Operator, :pop!
+        rule %r/[\(\[\{]/, Operator, :typeparam
+        rule %r/\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
       end
 
       state :comment do

data/lib/rouge/lexers/scheme.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -60,33 +61,33 @@ module Rouge
 
       state :root do
         # comments
-        rule /;.*$/, Comment::Single
-        rule /\s+/m, Text
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+/, Num::Integer
+        rule %r/;.*$/, Comment::Single
+        rule %r/\s+/m, Text
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
 
         # Racket infinitites
-        rule /[+-]inf[.][f0]/, Num
+        rule %r/[+-]inf[.][f0]/, Num
 
-        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|#f/, Name::Constant
+        rule %r/(?:'|#|`|,@|,|\.)/, Operator
 
-        rule /(['#])(\s*)(\()/m do
+        rule %r/(['#])(\s*)(\()/m do
           groups Str::Symbol, Text, Punctuation
         end
 
-        rule /\(/, Punctuation, :command
-        rule /\)/, Punctuation
+        rule %r/\(|\[/, Punctuation, :command
+        rule %r/\)|\]/, Punctuation
 
         rule id, Name::Variable
       end