rouge 3.2.0 → 3.18.0

data/lib/rouge/lexers/ceylon.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -10,34 +11,6 @@ module Rouge
       title "Ceylon"
       desc 'Say more, more clearly.'
 
-      keywords = %w(
-        break case catch continue else finally for in
-        if return switch this throw try while is exists dynamic
-        nonempty then outer assert let
-      )
-      
-      keywords_declaration = %w(
-        abstracts extends satisfies super given of out assign
-      )
-      
-      keywords_type = %w(
-        function value void new
-      )
-      
-      keywords_namespace = %w(
-        assembly module package
-      )
-      
-      keywords_constant = %w(
-        true false null
-      )
-
-      annotations = %w(
-        shared abstract formal default actual variable deprecated small
-        late literal doc by see throws optional license tagged final native
-        annotation sealed
-      )
-
       state :whitespace do
         rule %r([^\S\n]+), Text
         rule %r(//.*?\n), Comment::Single
@@ -58,14 +31,14 @@ module Rouge
         rule %r((abstracts|extends|satisfies|super|given|of|out|assign)\b), Keyword::Declaration
 
         rule %r((function|value|void|new)\b), Keyword::Type
-        
+
         rule %r((assembly|module|package)(\s+)) do
           groups Keyword::Namespace, Text
           push :import
         end
-        
+
         rule %r((true|false|null)\b), Keyword::Constant
-        
+
         rule %r((class|interface|object|alias)(\s+)) do
           groups Keyword::Declaration, Text
           push :class
@@ -75,7 +48,7 @@ module Rouge
           groups Keyword::Namespace, Text
           push :import
         end
-        
+
         rule %r("(\\\\|\\"|[^"])*"), Literal::String
         rule %r('\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'), Literal::String::Char
         rule %r(".*``.*``.*"', String::Interpol
@@ -85,7 +58,7 @@ module Rouge
         rule %r([a-zA-Z_]\w*:), Name::Label
         rule %r((\\I[a-z]|[A-Z])\w*), Name::Decorator
         rule %r([a-zA-Z_]\w*), Name
-        rule %r([~^*!%&\[\](){}<>|+=:;,./?-`]), Operator
+        rule %r([~^*!%&\[\](){}<>|+=:;,./?`-]), Operator
         rule %r(\d{1,3}(_\d{3})+\.\d{1,3}(_\d{3})+[kMGTPmunpf]?), Literal::Number::Float
         rule %r(\d{1,3}(_\d{3})+\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?),
           Literal::Number::Float
@@ -111,7 +84,7 @@ module Rouge
         rule %r([a-z][\w.]*), Name::Namespace, :pop!
         rule %r("(\\\\|\\"|[^"])*"), Literal::String, :pop!
       end
-      
+
       state :comment do
         rule %r([^*/]), Comment.Multiline
         rule %r(/\*), Comment::Multiline, :push!

data/lib/rouge/lexers/cfscript.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -36,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]
@@ -86,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
@@ -104,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
@@ -119,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
@@ -144,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/clean.rb

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Clean < RegexLexer
+      title "Clean"
+      desc "The Clean programming language (clean.cs.ru.nl)"
+
+      tag 'clean'
+      filenames '*.dcl', '*.icl'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          if otherwise
+          let in
+          with where
+          case of
+          infix infixl infixr
+          class instance
+          generic derive
+          special
+          implementation definition system module
+          from import qualified as
+          dynamic
+          code inline foreign export ccall stdcall
+        )
+      end
+
+      # These are literal patterns common to the ABC intermediate language and
+      # Clean. Clean has more extensive literal patterns (see :basic below).
+      state :common_literals do
+        rule %r/'(?:[^'\\]|\\(?:x[0-9a-fA-F]+|\d+|.))'/, Str::Char
+
+        rule %r/[+~-]?\d+\.\d+(?:E[+-]?\d+)?\b/, Num::Float
+        rule %r/[+~-]?\d+E[+-]?\d+\b/, Num::Float
+        rule %r/[+~-]?\d+/, Num::Integer
+
+        rule %r/"/, Str::Double, :string
+      end
+
+      state :basic do
+        rule %r/\s+/m, Text::Whitespace
+
+        rule %r/\/\/\*.*/, Comment::Doc
+        rule %r/\/\/.*/, Comment::Single
+        rule %r/\/\*\*/, Comment::Doc, :comment_doc
+        rule %r/\/\*/, Comment::Multiline, :comment
+
+        rule %r/[+~-]?0[0-7]+/, Num::Oct
+        rule %r/[+~-]?0x[0-9a-fA-F]+/, Num::Hex
+        mixin :common_literals
+        rule %r/(\[)(\s*)(')(?=.*?'\])/ do
+          groups Punctuation, Text::Whitespace, Str::Single, Punctuation
+          push :charlist
+        end
+      end
+
+      # nested commenting
+      state :comment_doc do
+        rule %r/\*\//, Comment::Doc, :pop!
+        rule %r/\/\/.*/, Comment::Doc # Singleline comments in multiline comments are skipped
+        rule %r/\/\*/, Comment::Doc, :comment
+        rule %r/[^*\/]+/, Comment::Doc
+        rule %r/[*\/]/, Comment::Doc
+      end
+
+      # This is the same as the above, but with Multiline instead of Doc
+      state :comment do
+        rule %r/\*\//, Comment::Multiline, :pop!
+        rule %r/\/\/.*/, Comment::Multiline # Singleline comments in multiline comments are skipped
+        rule %r/\/\*/, Comment::Multiline, :comment
+        rule %r/[^*\/]+/, Comment::Multiline
+        rule %r/[*\/]/, Comment::Multiline
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/code(\s+inline)?\s*{/, Comment::Preproc, :abc
+
+        rule %r/_*[a-z][\w_`]*/ do |m|
+          if self.class.keywords.include?(m[0])
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule %r/_*[A-Z][\w_`]*/ do |m|
+          if m[0]=='True' || m[0]=='False'
+            token Keyword::Constant
+          else
+            token Keyword::Type
+          end
+        end
+
+        rule %r/[^\w_\s`]/, Punctuation
+        rule %r/_\b/, Punctuation
+      end
+
+      state :escapes do
+        rule %r/\\x[0-9a-fA-F]{1,2}/i, Str::Escape
+        rule %r/\\d\d{0,3}/i, Str::Escape
+        rule %r/\\0[0-7]{0,3}/, Str::Escape
+        rule %r/\\[0-7]{1,3}/, Str::Escape
+        rule %r/\\[nrfbtv\\"']/, Str::Escape
+      end
+
+      state :string do
+        rule %r/"/, Str::Double, :pop!
+        mixin :escapes
+        rule %r/[^\\"]+/, Str::Double
+      end
+
+      state :charlist do
+        rule %r/(')(\])/ do
+          groups Str::Single, Punctuation
+          pop!
+        end
+        mixin :escapes
+        rule %r/[^\\']/, Str::Single
+      end
+
+      state :abc_basic do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\|.*/, Comment::Single
+        mixin :common_literals
+      end
+
+      # The ABC intermediate language can be included, similar to C's inline
+      # assembly. For some information about ABC, see:
+      # https://en.wikipedia.org/wiki/Clean_(programming_language)#The_ABC-Machine
+      state :abc do
+        mixin :abc_basic
+
+        rule %r/}/, Comment::Preproc, :pop!
+        rule %r/\.\w*/, Keyword, :abc_rest_of_line
+        rule %r/[\w_]+/, Name::Builtin, :abc_rest_of_line
+      end
+
+      state :abc_rest_of_line do
+        rule %r/\n/, Text::Whitespace, :pop!
+        rule %r/}/ do
+          token Comment::Preproc
+          pop!
+          pop!
+        end
+
+        mixin :abc_basic
+
+        rule %r/\S+/, Name
+      end
+    end
+  end
+end

data/lib/rouge/lexers/clojure.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -73,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])
@@ -99,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

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -124,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
@@ -149,27 +150,28 @@ 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/\\"/, Text
+        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
@@ -188,7 +190,7 @@ module Rouge
       state :variable_reference do
         mixin :variable_interpolation
 
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
 
         mixin :default
       end
@@ -196,8 +198,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