rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/ghc_core.rb

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# See http://www.cs.cmu.edu/afs/andrew/course/15/411/ghc/share/doc/ghc/ext-core/core.pdf for a description of the syntax
+# of the language and https://www.aosabook.org/en/ghc.html for a high level overview.
+module Rouge
+  module Lexers
+    class GHCCore < RegexLexer
+      title "GHC Core"
+      desc "Intermediate representation of the GHC Haskell compiler."
+      tag 'ghc-core'
+
+      filenames '*.dump-simpl', '*.dump-cse', '*.dump-ds', '*.dump-spec'
+
+      state :root do
+        # sections
+        rule %r/^=====.*=====$/, Generic::Heading
+        # timestamps
+        rule %r/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ UTC$/, Comment::Single
+        rule %r/^Result size of .+\s*.*}/, Comment::Multiline
+        rule %r/--.*$/, Comment::Single
+
+        rule %r/\[/, Comment::Special, :annotation
+
+        mixin :recursive_binding
+        mixin :ghc_rule
+        mixin :function
+
+        # rest is Text
+        rule %r/\s/m, Text
+        rule %r/.*/, Text
+      end
+
+      state :expression do
+        rule %r/[\n]+/, Text
+        rule %r/(?=^\S)/ do
+          pop!
+        end
+
+        rule %r/\s+/, Text, :expression_line
+      end
+
+      state :expression_line do
+        rule %r/ /, Text
+
+        mixin :common
+
+        rule %r/\n/, Text, :pop!
+      end
+
+      state :annotation do
+        rule %r/\]/, Comment::Special, :pop!
+        rule %r/\[/, Comment::Special, :annotation
+        rule %r/[^\[\]]+/, Comment::Special
+      end
+
+      state :common do
+        # array, e.g. '[]' or '[Char]'
+        rule %r/\[[^=]*\]/, Keyword::Type
+
+        rule %r/\[/, Comment::Special, :annotation
+
+        mixin :literal
+        mixin :constants
+        mixin :punctuation
+        mixin :operator
+        mixin :name
+      end
+
+      state :literal do
+        rule %r/\d+\.\d+\#{0,2}/, Literal::Number::Float
+        rule %r/\d+\#{0,2}/, Literal::Number::Integer
+        rule %r/".*"#/, Literal::String
+        rule %r/'.'#/, Literal::String::Char
+      end
+
+      state :constants do
+        rule %r/__DEFAULT/, Name::Constant
+      end
+
+      state :name do
+        rule %r/^([A-Z]\w*)(\.)/ do |m|
+          token Name::Namespace, m[0]
+          token Punctuation, m[1]
+        end
+
+        rule %r/[A-Z][^\s.,(){}]*/, Keyword::Type
+
+        # packages, e.g. 'ghc-prim-0.5.3:'
+        rule %r/(^[a-z].*?\d+\.\d+\.\d+)(:)(?=\S)/ do |m|
+          token Name::Namespace, m[1]
+          token Punctuation, m[2]
+        end
+
+        rule %r/\S*\(,\)\S*/, Name::Variable # '(,)' is a name, not punctuation
+        rule %r/\S[^\s.,(){}]*/, Name::Variable
+      end
+
+      state :punctuation do
+        rule %r/[.,(){};]/, Punctuation
+      end
+
+      state :operator do
+        rule %r/=>/, Operator
+        rule %r/->/, Operator
+        rule %r/::/, Operator
+        rule %r/=/, Operator
+        rule %r/forall/, Keyword
+        rule %r/case/, Keyword
+        rule %r/of/, Keyword
+        rule %r/letrec/, Keyword
+        rule %r/let/, Keyword
+        rule %r/join/, Keyword
+        rule %r/@/, Operator
+        rule %r/\\/, Operator
+      end
+
+      state :recursive_binding do
+        rule %r/(Rec)(\s*)({)/ do |m|
+          token Keyword, m[1]
+          token Text, m[2]
+          token Punctuation, m[3]
+        end
+
+        rule %r/^(end)(\s*)(Rec)(\s*)(})/ do |m|
+          token Keyword, m[1]
+          token Text, m[2]
+          token Keyword, m[3]
+          token Text, m[4]
+          token Punctuation, m[5]
+        end
+      end
+
+      state :ghc_rule do
+        rule %r/^(".*?")/m do |m|
+          token Name::Label, m[0]
+
+          push :expression
+        end
+      end
+
+      state :function do
+        rule %r/^(\S+)(?=.*?(=|::))/m do |m|
+          token Name::Function, m[0]
+
+          push :expression
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/gherkin.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -7,7 +8,7 @@ module Rouge
       aliases 'cucumber', 'behat'
 
       title "Gherkin"
-      desc 'A business-readable spec DSL ( github.com/cucumber/cucumber/wiki/Gherkin )'
+      desc 'A business-readable spec DSL (github.com/cucumber/cucumber/wiki/Gherkin)'
 
       filenames '*.feature'
       mimetypes 'text/x-gherkin'
@@ -18,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(Lexers::BASE_DIR, 'gherkin/keywords.rb')
         keywords
       end
 
@@ -29,6 +30,8 @@ module Rouge
           keywords[:step].map do |w|
             if w.end_with? '<'
               Regexp.escape(w.chop)
+            elsif w.end_with?(' ')
+              Regexp.escape(w)
             else
               "#{Regexp.escape(w)}\\b"
             end
@@ -40,7 +43,7 @@ module Rouge
 
       state :basic do
         rule %r(#.*$), Comment
-        rule /[ \r\t]+/, Text
+        rule %r/[ \r\t]+/, Text
       end
 
       state :root do
@@ -84,8 +87,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
@@ -94,9 +97,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
@@ -107,29 +110,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[^\s<]*/, Text
         rule rest_of_line, Text, :pop!
       end
     end

data/lib/rouge/lexers/gherkin/keywords.rb

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
 # automatically generated by `rake builtins:gherkin`
 module Rouge
   module Lexers

data/lib/rouge/lexers/glsl.rb

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

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -13,7 +14,7 @@ module Rouge
 
       # Characters
 
-      WHITE_SPACE            = /[\s\t\r\n]+/
+      WHITE_SPACE            = /\s+/
 
       NEWLINE                = /\n/
       UNICODE_CHAR           = /[^\n]/
@@ -148,7 +149,7 @@ module Rouge
         rule(OPERATOR,              Operator)
         rule(SEPARATOR,             Punctuation)
         rule(IDENTIFIER,            Name)
-        rule(WHITE_SPACE,           Other)
+        rule(WHITE_SPACE,           Text)
       end
 
       state :root do

data/lib/rouge/lexers/gradle.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers

data/lib/rouge/lexers/graphql.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -11,40 +12,54 @@ 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 %r/\bscalar\b/, Keyword, :value
 
-        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 /\bunion\b/, Keyword, :union_definition
+        rule %r/\b(?:input|schema)\b/, Keyword, :type_definition
+
+        rule %r/\bunion\b/, Keyword, :union_definition
+
+        rule %r/\bextend\b/, Keyword
 
         mixin :basic
+
+        # Markdown descriptions
+        rule %r/(""")(\n)(.*?)(\n)(""")/m do |m|
+          token Str::Double, m[1]
+          token Text::Whitespace, m[2]
+          delegate Markdown, m[3]
+          token Text::Whitespace, m[4]
+          token Str::Double, m[5]
+        end
       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
@@ -52,31 +67,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
@@ -86,13 +101,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
 
@@ -100,62 +115,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
@@ -166,35 +181,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)
@@ -204,13 +219,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
@@ -226,15 +241,18 @@ module Rouge
           }
         }
 
-        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]
+        # Multiline strings
+        rule %r/""".*?"""/m, Str::Double
+
+        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