rouge 3.6.0 → 3.8.0

data/lib/rouge/lexers/gherkin.rb

@@ -8,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'
@@ -30,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
@@ -130,7 +132,7 @@ module Rouge
         mixin :basic
         rule %r/<.*?>/, Name::Variable
         rule %r/".*?"/, Str
-        rule %r/\S+/, Text
+        rule %r/\S[^\s<]*/, Text
         rule rest_of_line, Text, :pop!
       end
     end

data/lib/rouge/lexers/graphql.rb

@@ -20,19 +20,26 @@ module Rouge
         end
 
         rule %r/\bfragment\b/, Keyword, :fragment_definition
+        
+        rule %r/\bscalar\b/, Keyword, :value
 
         rule %r/\b(?:type|interface|enum)\b/, Keyword, :type_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/(""")(.*?)(""")/m do |m|
+        rule %r/(""")(\n)(.*?)(\n)(""")/m do |m|
           token Str::Double, m[1]
-          delegate Markdown, m[2]
-          token Str::Double, m[3]
+          token Text::Whitespace, m[2]
+          delegate Markdown, m[3]
+          token Text::Whitespace, m[4]
+          token Str::Double, m[5]
         end
       end
 

data/lib/rouge/lexers/handlebars.rb

@@ -27,7 +27,15 @@ module Rouge
           push :open_sym
         end
 
-        rule(/(.+?)(?=\\|{{)/m) { delegate parent }
+        rule(/(.+?)(?=\\|{{)/m) do
+          delegate parent
+
+          # if parent state is attr, then we have an html attribute without quotes
+          # pop the parent state to return to the tag state
+          if parent.state?('attr')
+            parent.pop!
+          end
+        end
 
         # if we get here, there's no more mustache tags, so we eat
         # the rest of the doc
@@ -43,9 +51,12 @@ module Rouge
 
       state :stache do
         rule %r/}}}?/, Keyword, :pop!
+        rule %r/\|/, Punctuation
+        rule %r/~/, Keyword
         rule %r/\s+/m, Text
         rule %r/[=]/, Operator
         rule %r/[\[\]]/, Punctuation
+        rule %r/[\(\)]/, Punctuation
         rule %r/[.](?=[}\s])/, Name::Variable
         rule %r/[.][.]/, Name::Variable
         rule %r([/.]), Punctuation
@@ -65,7 +76,7 @@ module Rouge
           goto :block_name
         end
 
-        rule %r/[>^&]/, Keyword
+        rule %r/[>^&~]/, Keyword
 
         rule(//) { pop! }
       end
@@ -77,4 +88,4 @@ module Rouge
       end
     end
   end
-end
+end

data/lib/rouge/lexers/hocon.rb

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'json.rb'
+
+    class HOCON < JSON
+      title 'HOCON'
+      desc "Human-Optimized Config Object Notation (https://github.com/lightbend/config)"
+      tag 'hocon'
+      filenames '*.hocon'
+
+      state :comments do
+        # Comments
+        rule %r(//.*?$), Comment::Single
+        rule %r(#.*?$), Comment::Single
+      end
+
+      prepend :root do
+        mixin :comments
+      end
+
+      prepend :object do
+        # Keywords
+        rule %r/\b(?:include|url|file|classpath)\b/, Keyword
+      end
+
+      state :name do
+        rule %r/("(?:\"|[^"\n])*?")(\s*)([:=]|(?={))/ do
+          groups Name::Label, Text::Whitespace, Punctuation
+        end
+
+        rule %r/([-\w.]+)(\s*)([:=]|(?={))/ do
+          groups Name::Label, Text::Whitespace, Punctuation
+        end
+      end
+
+      state :value do
+        mixin :comments
+
+        rule %r/\n/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
+
+        mixin :constants
+
+        # Interpolation
+        rule %r/[$][{][?]?/, Literal::String::Interpol, :interpolation
+
+        # Strings
+        rule %r/"""/, Literal::String::Double, :multiline_string
+        rule %r/"/, Str::Double, :string
+
+        rule %r/\[/, Punctuation, :array
+        rule %r/{/, Punctuation, :object
+
+        # Symbols (only those not handled by JSON)
+        rule %r/[()=]/, Punctuation
+
+        # Values
+        rule %r/[^$"{}\[\]:=,\+#`^?!@*&]+?/, Literal
+      end
+
+      state :interpolation do
+        rule %r/[\w\-\.]+?/, Name::Variable
+        rule %r/}/, Literal::String::Interpol, :pop!
+      end
+
+      prepend :string do
+        rule %r/[$][{][?]?/, Literal::String::Interpol, :interpolation
+        rule %r/[^\\"\${]+/, Literal::String::Double
+      end
+
+      state :multiline_string do
+        rule %r/"[^"]{1,2}/, Literal::String::Double
+        mixin :string
+        rule %r/"""/, Literal::String::Double, :pop!
+      end
+
+      prepend :constants do
+        # Numbers (handle the case where we have multiple periods, ie. IP addresses)
+        rule %r/\d+\.(\d+\.?){3,}/, Literal
+      end
+    end
+  end
+end

data/lib/rouge/lexers/html.rb

@@ -83,8 +83,8 @@ module Rouge
 
       state :tag do
         rule %r/\s+/m, Text
-        rule %r/[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
-        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/[a-zA-Z0-9_:\[\]()*.-]+\s*=\s*/m, Name::Attribute, :attr
+        rule %r/[a-zA-Z0-9_:#*-]+/, Name::Attribute
         rule %r(/?\s*>)m, Name::Tag, :pop!
       end
 

data/lib/rouge/lexers/igorpro.rb

@@ -20,7 +20,7 @@ module Rouge
           break return continue
           for endfor do while
           case default
-	  try catch endtry
+          try catch endtry
           abortonrte
         )
       end

data/lib/rouge/lexers/json.rb

@@ -12,13 +12,39 @@ module Rouge
                 'application/hal+json', 'application/problem+json',
                 'application/schema+json'
 
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+      end
+
       state :root do
-        rule %r/\s+/m, Text::Whitespace
+        mixin :whitespace
+        rule %r/{/, Punctuation, :object
+        rule %r/\[/, Punctuation, :array
+
+        mixin :name
+        mixin :value
+      end
+
+      state :object do
+        mixin :whitespace
+        mixin :name
+        mixin :value
+        rule %r/}/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+      end
+
+      state :name do
+        rule %r/("(?:\\.|[^"\n])*?")(\s*)(:)/ do
+          groups Name::Label, Text::Whitespace, Punctuation
+        end
+      end
+
+      state :value do
+        mixin :whitespace
+        mixin :constants
         rule %r/"/, Str::Double, :string
-        rule %r/(?:true|false|null)\b/, Keyword::Constant
-        rule %r/[{},:\[\]]/, Punctuation
-        rule %r/-?(?:0|[1-9]\d*)\.\d+(?:e[+-]?\d+)?/i, Num::Float
-        rule %r/-?(?:0|[1-9]\d*)(?:e[+-]?\d+)?/i, Num::Integer
+        rule %r/\[/, Punctuation, :array
+        rule %r/{/, Punctuation, :object
       end
 
       state :string do
@@ -26,6 +52,18 @@ module Rouge
         rule %r/\\./, Str::Escape
         rule %r/"/, Str::Double, :pop!
       end
+
+      state :array do
+        mixin :value
+        rule %r/\]/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+      end
+
+      state :constants do
+        rule %r/(?:true|false|null)/, Keyword::Constant
+        rule %r/-?(?:0|[1-9]\d*)\.\d+(?:e[+-]?\d+)?/i, Num::Float
+        rule %r/-?(?:0|[1-9]\d*)(?:e[+-]?\d+)?/i, Num::Integer
+      end
     end
   end
 end

data/lib/rouge/lexers/julia.rb

@@ -199,7 +199,7 @@ module Rouge
         end
 
         # types
-        rule %r/((mutable )?struct|(abstract|primitive) type)((?:\s|\\\s)+)/ do
+        rule %r/((?:mutable )?struct|(?:abstract|primitive) type)((?:\s|\\\s)+)/ do
           groups Keyword, Name::Class
           push :typename
         end

data/lib/rouge/lexers/make.rb

@@ -8,9 +8,18 @@ module Rouge
       desc "Makefile syntax"
       tag 'make'
       aliases 'makefile', 'mf', 'gnumake', 'bsdmake'
-      filenames '*.make', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'
+      filenames '*.make', '*.mak', '*.mk', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile', '*,fe1'
       mimetypes 'text/x-makefile'
 
+      def self.functions
+        @functions ||= %w(
+          abspath addprefix addsuffix and basename call dir error eval file
+          filter filter-out findstring firstword flavor foreach if join lastword
+          notdir or origin patsubst realpath shell sort strip subst suffix value
+          warning wildcard word wordlist words
+        )
+      end
+
       # TODO: Add support for special keywords
       # bsd_special = %w(
       #   include undef error warning if else elif endif for endfor
@@ -28,15 +37,25 @@ module Rouge
 
         rule %r/#.*?\n/, Comment
 
-        rule %r/(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
+        rule %r/([-s]?include)((?:[\t ]+[^\t\n #]+)+)/ do
+          groups Keyword, Literal::String::Other
+        end
+
+        rule %r/(ifn?def|ifn?eq)([\t ]+)([^#\n]+)/ do
+          groups Keyword, Text, Name::Variable
+        end
+
+        rule %r/(?:else|endif)[\t ]*(?=[#\n])/, Keyword
+
+        rule %r/(export)([\t ]+)(?=[\w\${}()\t -]+\n)/ do
           groups Keyword, Text
           push :export
         end
 
-        rule %r/export\s+/, Keyword
+        rule %r/export[\t ]+/, Keyword
 
         # assignment
-        rule %r/([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)/m do |m|
+        rule %r/([\w${}().-]+)([\t ]*)([!?:+]?=)/m do |m|
           token Name::Variable, m[1]
           token Text, m[2]
           token Operator, m[3]
@@ -52,9 +71,9 @@ module Rouge
       end
 
       state :export do
-        rule %r/[\w\${}-]/, Name::Variable
+        rule %r/[\w\${}()-]/, Name::Variable
         rule %r/\n/, Text, :pop!
-        rule %r/\s+/, Text
+        rule %r/[\t ]+/, Text
       end
 
       state :block_header do
@@ -70,6 +89,14 @@ module Rouge
       end
 
       state :block_body do
+        rule %r/(ifn?def|ifn?eq)([\t ]+)([^#\n]+)(#.*)?(\n)/ do
+          groups Keyword, Text, Name::Variable, Comment, Text
+        end
+
+        rule %r/(else|endif)([\t ]*)(#.*)?(\n)/ do
+          groups Keyword, Text, Comment, Text
+        end
+
         rule %r/(\t[\t ]*)([@-]?)/ do
           groups Text, Punctuation
           push :shell_line
@@ -80,22 +107,22 @@ module Rouge
 
       state :shell do
         # macro interpolation
-        rule %r/\$\(\s*[a-z_]\w*\s*\)/i, Name::Variable
-        # $(shell ...)
-        rule %r/(\$\()(\s*)(shell)(\s+)/m do
+        rule %r/\$[({][\t ]*\w[\w:=%.]*[\t ]*[)}]/i, Name::Variable
+        # function invocation
+        rule %r/(\$[({])([\t ]*)(#{Make.functions.join('|')})([\t ]+)/m do
           groups Name::Function, Text, Name::Builtin, Text
           push :shell_expr
         end
 
         rule(/\\./m) { delegate @shell }
-        stop = /\$\(|\(|\)|\\|$/
+        stop = /\$\(|\$\{|\(|\)|\}|\\|$/
         rule(/.+?(?=#{stop})/m) { delegate @shell }
         rule(stop) { delegate @shell }
       end
 
       state :shell_expr do
-        rule(/\(/) { delegate @shell; push }
-        rule %r/\)/, Name::Variable, :pop!
+        rule(/[({]/) { delegate @shell; push }
+        rule %r/[)}]/, Name::Function, :pop!
         mixin :shell
       end
 

data/lib/rouge/lexers/mason.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Mason < TemplateLexer
+      title 'Mason'
+      desc 'The HTML::Mason framework (https://metacpan.org/pod/HTML::Mason)'
+      tag 'mason'
+      filenames '*.mi', '*.mc', '*.mas', '*.m', '*.mhtml', '*.mcomp', 'autohandler', 'dhandler'
+      mimetypes 'text/x-mason', 'application/x-mason'
+
+      def initialize(*)
+        super
+        @perl = Perl.new
+      end
+  
+      def self.detect?(text)
+        return false if text.doctype?(/((?:ht|x)ml)/)
+        return true if text.doctype?
+      end
+
+      # Note: If you add a tag in the lines below, you also need to modify "disambiguate '*.m'" in file disambiguation.rb
+      TEXT_BLOCKS = %w(text doc)
+      PERL_BLOCKS = %w(args flags attr init once shared perl cleanup filter)
+      COMPONENTS = %w(def method)
+  
+      state :root do
+        mixin :mason_tags
+      end
+
+      state :mason_tags do
+        rule %r/\s+/, Text::Whitespace
+
+        rule %r/<%(#{TEXT_BLOCKS.join('|')})>/oi, Comment::Preproc, :text_block
+
+        rule %r/<%(#{PERL_BLOCKS.join('|')})>/oi, Comment::Preproc, :perl_block
+
+        rule %r/(<%(#{COMPONENTS.join('|')}))([^>]*)(>)/oi do |m|
+          token Comment::Preproc, m[1]
+          token Name, m[3]
+          token Comment::Preproc, m[4]
+          push :component_block
+        end
+        
+        # perl line
+        rule %r/^(%)(.*)$/ do |m|
+          token Comment::Preproc, m[1]
+          delegate @perl, m[2]
+        end
+
+        # start of component call
+        rule %r/<%/, Comment::Preproc, :component_call
+
+         # start of component with content
+        rule %r/<&\|/ do
+          token Comment::Preproc
+          push :component_with_content
+          push :component_sub
+        end
+
+        # start of component substitution
+        rule %r/<&/, Comment::Preproc, :component_sub
+
+        # fallback to HTML until a mason tag is encountered
+        rule(/(.+?)(?=(<\/?&|<\/?%|^%|^#))/m) { delegate parent }
+
+        # if we get here, there's no more mason tags, so we parse the rest of the doc as HTML
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :perl_block do
+        rule %r/<\/%(#{PERL_BLOCKS.join('|')})>/oi, Comment::Preproc, :pop!
+        rule %r/\s+/, Text::Whitespace
+        rule %r/^(#.*)$/, Comment
+        rule(/(.*?[^"])(?=<\/%)/m) { delegate @perl }
+      end
+
+      state :text_block do
+        rule %r/<\/%(#{TEXT_BLOCKS.join('|')})>/oi, Comment::Preproc, :pop!
+        rule %r/\s+/, Text::Whitespace
+        rule %r/^(#.*)$/, Comment
+        rule %r/(.*?[^"])(?=<\/%)/m, Comment
+      end
+
+      state :component_block do
+        rule %r/<\/%(#{COMPONENTS.join('|')})>/oi, Comment::Preproc, :pop!
+        rule %r/\s+/, Text::Whitespace
+        rule %r/^(#.*)$/, Comment
+        mixin :mason_tags
+      end
+
+      state :component_with_content do
+        rule %r/<\/&>/ do 
+          token Comment::Preproc
+          pop!
+        end
+
+        mixin :mason_tags
+      end
+
+      state :component_sub do
+        rule %r/&>/, Comment::Preproc, :pop!
+
+        rule(/(.*?)(?=&>)/m) { delegate @perl }
+      end
+
+      state :component_call do
+        rule %r/%>/, Comment::Preproc, :pop!
+
+        rule(/(.*?)(?=%>)/m) { delegate @perl }
+      end
+    end
+  end
+end