rouge 3.6.0 → 3.7.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/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

data/lib/rouge/lexers/ocaml.rb

@@ -3,7 +3,9 @@
 
 module Rouge
   module Lexers
-    class OCaml < RegexLexer
+    load_lexer 'ocaml/common.rb'
+
+    class OCaml < OCamlCommon
       title "OCaml"
       desc 'Objective Caml (ocaml.org)'
       tag 'ocaml'
@@ -11,35 +13,19 @@ module Rouge
       mimetypes 'text/x-ocaml'
 
       def self.keywords
-        @keywords ||= Set.new %w(
-          as assert begin class constraint do done downto else end
-          exception external false for fun function functor if in include
-          inherit initializer lazy let match method module mutable new
-          nonrec object of open private raise rec sig struct then to true
-          try type val virtual when while with
-        )
-      end
-
-      def self.word_operators
-        @word_operators ||= Set.new %w(and asr land lor lsl lxor mod or)
+        @keywords ||= super + Set.new(%w(
+          match raise
+        ))
       end
 
-      def self.primitives
-        @primitives ||= Set.new %w(unit int float bool string char list array)
-      end
-
-      operator = %r([;,_!$%&*+./:<=>?@^|~#-]+)
-      id = /[a-z_][\w']*/i
-      upper_id = /[A-Z][\w']*/
-
       state :root do
         rule %r/\s+/m, Text
         rule %r/false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
-        rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace, :dotted
-        rule %r/`#{id}/, Name::Tag
-        rule upper_id, Name::Class
+        rule %r/#{@@upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+        rule %r/`#{@@id}/, Name::Tag
+        rule @@upper_id, Name::Class
         rule %r/[(][*](?![)])/, Comment, :comment
-        rule id do |m|
+        rule @@id do |m|
           match = m[0]
           if self.class.keywords.include? match
             token Keyword
@@ -53,7 +39,7 @@ module Rouge
         end
 
         rule %r/[(){}\[\];]+/, Punctuation
-        rule operator, Operator
+        rule @@operator, Operator
 
         rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
         rule %r/0x\h[\h_]*/i, Num::Hex
@@ -65,7 +51,7 @@ module Rouge
         rule %r/'[.]'/, Str::Char
         rule %r/'/, Keyword
         rule %r/"/, Str::Double, :string
-        rule %r/[~?]#{id}/, Name::Variable
+        rule %r/[~?]#{@@id}/, Name::Variable
       end
 
       state :comment do
@@ -74,28 +60,6 @@ module Rouge
         rule %r/[*][)]/, Comment, :pop!
         rule %r/[(*)]/, Comment
       end
-
-      state :string do
-        rule %r/[^\\"]+/, Str::Double
-        mixin :escape_sequence
-        rule %r/\\\n/, Str::Double
-        rule %r/"/, Str::Double, :pop!
-      end
-
-      state :escape_sequence do
-        rule %r/\\[\\"'ntbr]/, Str::Escape
-        rule %r/\\\d{3}/, Str::Escape
-        rule %r/\\x\h{2}/, Str::Escape
-      end
-
-      state :dotted do
-        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!
-        rule %r/[({\[]/, Punctuation, :pop!
-      end
     end
   end
 end