rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/diff.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     class Diff < RegexLexer
@@ -17,14 +19,18 @@ module Rouge
 
       state :root do
         rule(/^ .*$\n?/, Text)
-        rule(/^---$\n?/, Text)
+        rule(/^---$\n?/, Punctuation)
+        rule(/^[+>]+.*$\n?/, Generic::Inserted)
         rule(/^\+.*$\n?/, Generic::Inserted)
-        rule(/^-+.*$\n?/, Generic::Deleted)
+        rule(/^[-<]+.*$\n?/, Generic::Deleted)
         rule(/^!.*$\n?/, Generic::Strong)
-        rule(/^@.*$\n?/, Generic::Subheading)
         rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
+        rule(/^(@@[^@]*@@)([^\n]*\n)/) do
+          groups Punctuation, Text
+        end
+        rule(/^\w.*$\n?/, Punctuation)
         rule(/^=.*$\n?/, Generic::Heading)
-        rule(/.*$\n?/, Text)
+        rule(/\s.*$\n?/, Text)
       end
     end
   end

data/lib/rouge/lexers/digdag.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 module Rouge
   module Lexers
@@ -58,7 +60,7 @@ module Rouge
       ))
 
       prepend :block_nodes do
-        rule /(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
+        rule %r/(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
           groups Keyword::Reserved, Punctuation::Indicator
           set_indent m[0], :implicit => true
         end

data/lib/rouge/lexers/docker.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -7,7 +8,7 @@ module Rouge
       desc "Dockerfile syntax"
       tag 'docker'
       aliases 'dockerfile'
-      filenames 'Dockerfile', '*.docker'
+      filenames 'Dockerfile', '*.Dockerfile', '*.docker', 'Dockerfile_*'
       mimetypes 'text/x-dockerfile-config'
 
       KEYWORDS = %w(
@@ -17,32 +18,32 @@ module Rouge
       start { @shell = Shell.new(@options) }
 
       state :root do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /^(ONBUILD)(\s+)(#{KEYWORDS})(.*)/io do |m|
+        rule %r/^(ONBUILD)(\s+)(#{KEYWORDS})(.*)/io do
           groups Keyword, Text::Whitespace, Keyword, Str
         end
 
-        rule /^(#{KEYWORDS})\b(.*)/io do |m|
+        rule %r/^(#{KEYWORDS})\b(.*)/io do
           groups Keyword, Str
         end
 
-        rule /#.*?$/, Comment
+        rule %r/#.*?$/, Comment
 
-        rule /^(ONBUILD\s+)?RUN(\s+)/i do
+        rule %r/^(ONBUILD\s+)?RUN(\s+)/i do
           token Keyword
           push :run
           @shell.reset!
         end
 
-        rule /\w+/, Text
-        rule /[^\w]+/, Text
-        rule /./, Text
+        rule %r/\w+/, Text
+        rule %r/[^\w]+/, Text
+        rule %r/./, Text
       end
 
       state :run do
-        rule /\n/, Text, :pop!
-        rule /\\./m, Str::Escape
+        rule %r/\n/, Text, :pop!
+        rule %r/\\./m, Str::Escape
         rule(/(\\.|[^\n\\])+/) { delegate @shell }
       end
     end

data/lib/rouge/lexers/dot.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -15,33 +16,33 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
-        rule %r(#.*?\n), Comment::Single
-        rule %r(//.*?\n), Comment::Single
+        rule %r/\s+/, Text
+        rule %r(#.*), Comment::Single
+        rule %r(//.*?$), Comment::Single
         rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
       end
 
       state :html do
-        rule /[^<>]+/ do
+        rule %r/[^<>]+/ do
           delegate @html
         end
-        rule /<.+?>/m do
+        rule %r/<.+?>/m do
           delegate @html
         end
-        rule />/, Punctuation, :pop!
+        rule %r/>/, Punctuation, :pop!
       end
 
       state :ID do
-        rule /([a-zA-Z][a-zA-Z_0-9]*)(\s*)(=)/ do |m|
+        rule %r/([a-zA-Z][a-zA-Z_0-9]*)(\s*)(=)/ do |m|
           token Name, m[1]
           token Text, m[2]
           token Punctuation, m[3]
         end
-        rule /[a-zA-Z][a-zA-Z_0-9]*/, Name::Variable
-        rule /([0-9]+)?\.[0-9]+/, Num::Float
-        rule /[0-9]+/, Num::Integer
-        rule /"(\\"|[^"])*"/, Str::Double
-        rule /</ do
+        rule %r/[a-zA-Z][a-zA-Z_0-9]*/, Name::Variable
+        rule %r/([0-9]+)?\.[0-9]+/, Num::Float
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\"|[^"])*"/, Str::Double
+        rule %r/</ do
           token Punctuation
           @html.reset!
           push :html
@@ -51,16 +52,16 @@ module Rouge
       state :a_list do
         mixin :comments_and_whitespace
         mixin :ID
-        rule /[=;,]/, Punctuation
-        rule /\]/, Operator, :pop!
+        rule %r/[=;,]/, Punctuation
+        rule %r/\]/, Operator, :pop!
       end
 
       state :root do
         mixin :comments_and_whitespace
-        rule /\b(strict|graph|digraph|subgraph|node|edge)\b/i, Keyword
-        rule /[{};:=]/, Punctuation
-        rule /-[->]/, Operator
-        rule /\[/, Operator, :a_list
+        rule %r/\b(strict|graph|digraph|subgraph|node|edge)\b/i, Keyword
+        rule %r/[{};:=]/, Punctuation
+        rule %r/-[->]/, Operator
+        rule %r/\[/, Operator, :a_list
         mixin :ID
       end
     end

data/lib/rouge/lexers/ecl.rb

@@ -0,0 +1,175 @@
+# -*- codding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ECL < RegexLexer
+      tag 'ecl'
+      filenames '*.ecl'
+      mimetypes 'application/x-ecl'
+
+      title "ECL"
+      desc "Enterprise Control Language (hpccsystems.com)"
+
+      id = /(#?)\b([a-z_][\w]*?)(\d*)\b/i
+
+      def self.class_first
+        @class_first ||= Set.new %w(
+          file date str math metaphone metaphone3 uni audit blas system
+        )
+      end
+
+      def self.class_second
+        @class_second ||= Set.new %w(
+          debug email job log thorlib util workunit
+        )
+      end
+
+      def self.functions
+        @functions ||= Set.new %w(
+          abs acos aggregate allnodes apply ascii asin asstring atan _token ave
+          case catch choose choosen choosesets clustersize combine correlation
+          cos cosh count covariance cron dataset dedup define denormalize
+          dictionary distribute distributed distribution ebcdic enth error
+          evaluate event eventextra eventname exists exp failcode failmessage
+          fetch fromunicode fromxml getenv getisvalid global graph group hash
+          hashcrc having httpcall httpheader if iff index intformat isvalid
+          iterate join keyunicode length library limit ln local log loop map
+          matched matchlength matchposition matchtext matchunicode max merge
+          mergejoin min nofold nolocal nonempty normalize parse pipe power
+          preload process project pull random range rank ranked realformat
+          recordof regexfind regexreplace regroup rejected rollup round roundup
+          row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt
+          stepped stored sum table tan tanh thisnode topn tounicode toxml
+          transfer transform trim truncate typeof ungroup unicodeorder variance
+          which workunit xmldecode xmlencode xmltext xmlunicode apply assert
+          build buildindex evaluate fail keydiff keypatch loadxml nothor notify
+          output parallel sequential soapcall wait
+        )
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          and or in not all any as from atmost before best between case const
+          counter csv descend encrypt end endmacro enum except exclusive expire
+          export extend fail few first flat full function functionmacro group
+          heading hole ifblock import joined keep keyed last left limit load
+          local locale lookup many maxcount maxlength _token module interface
+          named nocase noroot noscan nosort of only opt outer overwrite packed
+          partition penalty physicallength pipe quote record repeat return
+          right rows scan self separator service shared skew skip sql store
+          terminator thor threshold token transform trim type unicodeorder
+          unsorted validate virtual whole wild within xml xpath after cluster
+          compressed compression default encoding escape fileposition forward
+          grouped inner internal linkcounted literal lzw mofn multiple
+          namespace wnotrim noxpath onfail prefetch retry rowset scope smart
+          soapaction stable timelimit timeout unordered unstable update use
+          width
+        )
+      end
+
+      def self.template
+        @template ||= Set.new %w(
+          append apply break constant debug declare demangle else elseif end
+          endregion error expand export exportxml for forall getdatatype if
+          ifdefined inmodule isdefined isvalid line link loop mangle onwarning
+          option region set stored text trace uniquename warning webservice
+          workunit loadxml
+        )
+      end
+
+      def self.type
+        @type ||= Set.new %w(
+          ascii big_endian boolean data decimal ebcdic grouped integer
+          linkcounted pattern qstring real record rule set of streamed string
+          token udecimal unicode utf8 unsigned varstring varunicode
+        )
+      end
+
+      def self.typed
+        @typed ||= Set.new %w(
+          data string qstring varstring varunicode unicode utf8
+        )
+      end
+
+      state :single_quote do
+        rule %r([xDQUV]?'([^'\\]*(?:\\.[^'\\]*)*)'), Str::Single
+        rule %r/\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)/, Text
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text
+        rule %r(//.*), Comment::Single
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :single_quote
+
+        rule %r(\b(?i:(and|not|or|in))\b), Operator::Word
+        rule %r([:=|>|<|<>|/|\\|\+|-|=]), Operator
+        rule %r([\[\]{}();,\&,\.,\%]), Punctuation
+
+        rule %r(\b(?i:(beginc\+\+.*?endc\+\+)))m, Str::Single
+        rule %r(\b(?i:(embed.*?endembed)))m, Str::Single
+
+        rule %r(\b(\w+)\.(\w+)\.(\w+)) do |m|
+          if m[1] == "std" &&
+             self.class.class_first.include?(m[2]) &&
+             self.class.class_second.include?(m[3])
+            token Name::Class
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r(\b(?i:(u)?decimal)(\d+(_\d+)?)\b), Keyword::Type
+
+        rule %r/\d+\.\d+(e[\+\-]?\d+)?/i, Num::Float
+        rule %r/x[0-9a-f]+/i, Num::Hex
+
+        rule %r/0x[0-9a-f]+/i, Num::Hex
+        rule %r/0[0-9a-f]+x/i, Num::Hex
+        rule %r(0[bB][01]+), Num::Bin
+        rule %r([01]+[bB]), Num::Bin
+        rule %r(\d+), Num::Integer
+
+        rule id do |m|
+          name_only = m[2].downcase
+          name      = name_only + m[3]
+          number    = (m[3] == "") ? nil : m[3].to_i
+          if m[1] == "#"
+            if self.class.template.include? name
+              token Keyword::Type
+            else
+              token Error
+            end
+          elsif self.class.typed.include?(name_only) && number != nil
+            token Keyword::Type
+          elsif self.class.type.include? name
+            token Keyword::Type
+          elsif self.class.keywords.include? name
+            token Keyword
+          elsif self.class.functions.include? name
+            token Name::Function
+          elsif ["integer", "unsigned"].include?(name_only) && (1..8).cover?(number)
+            token Keyword::Type
+          elsif name_only == "real" && [4, 8].include?(number)
+            token Keyword::Type
+          elsif ["true", "false"].include? name
+            token Keyword::Constant
+          else
+            token Name::Other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/eex.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class EEX < TemplateLexer
+      title "EEX"
+      desc "Embedded Elixir"
+
+      tag 'eex'
+      aliases 'leex'
+
+      filenames '*.eex', '*.leex'
+
+      def initialize(opts={})
+        @elixir_lexer = Elixir.new(opts)
+
+        super(opts)
+      end
+
+      start do
+        parent.reset!
+        @elixir_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|<%/
+      close = /%%>|%>/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :elixir
+
+        rule %r/.+?(?=#{open})|.+/mo do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/mo, Comment
+      end
+
+      state :elixir do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/mo do
+          delegate @elixir_lexer
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/eiffel.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -26,37 +27,37 @@ module Rouge
       SimpleString = /(?:[^"%\b\f\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)+?/
 
       state :root do
-        rule /"\[/, Str::Other, :aligned_verbatim_string
-        rule /"\{/, Str::Other, :non_aligned_verbatim_string
-        rule /"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
-        rule /--.*/, Comment::Single
-        rule /'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
+        rule %r/"\[/, Str::Other, :aligned_verbatim_string
+        rule %r/"\{/, Str::Other, :non_aligned_verbatim_string
+        rule %r/"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
+        rule %r/--.*/, Comment::Single
+        rule %r/'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
 
-        rule /(?:#{LanguageKeywords.join('|')})\b/, Keyword
-        rule /(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
-        rule /(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
+        rule %r/(?:#{LanguageKeywords.join('|')})\b/, Keyword
+        rule %r/(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
+        rule %r/(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
 
-        rule  /\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
-        rule /\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
-        rule /\b0[bB][01](?:_*[01])*\b/, Num::Bin
-        rule /\d(?:_*\d)*/, Num::Integer
-        rule /(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
+        rule %r/\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
+        rule %r/\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
+        rule %r/\b0[bB][01](?:_*[01])*\b/, Num::Bin
+        rule %r/\d(?:_*\d)*/, Num::Integer
+        rule %r/(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
 
-        rule /:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
-        rule /\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
+        rule %r/:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
+        rule %r/\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
 
-        rule /[A-Z][\dA-Z_]*/, Name::Class
-        rule /[A-Za-z][\dA-Za-z_]*/, Name
-        rule /\s+/, Text
+        rule %r/[A-Z][\dA-Z_]*/, Name::Class
+        rule %r/[A-Za-z][\dA-Za-z_]*/, Name
+        rule %r/\s+/, Text
       end
 
       state :aligned_verbatim_string do
-        rule /]"/, Str::Other, :pop!
+        rule %r/]"/, Str::Other, :pop!
         rule SimpleString, Str::Other
       end
 
       state :non_aligned_verbatim_string do
-        rule /}"/, Str::Other, :pop!
+        rule %r/}"/, Str::Other, :pop!
         rule SimpleString, Str::Other
       end
     end