rouge 3.6.0 → 3.12.0

data/lib/rouge/lexers/minizinc.rb

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# Based on Chroma's MiniZinc lexer:
+# https://github.com/alecthomas/chroma/blob/5152194c717b394686d3d7a7e1946a360ec0728f/lexers/m/minizinc.go
+
+module Rouge
+  module Lexers
+    class MiniZinc < RegexLexer
+      title "MiniZinc"
+      desc "MiniZinc is a free and open-source constraint modeling language (minizinc.org)"
+      tag 'minizinc'
+      filenames '*.mzn', '*.fzn', '*.dzn'
+      mimetypes 'text/minizinc'
+
+      def self.builtins
+        @builtins = Set.new %w[
+          abort abs acosh array_intersect array_union array1d array2d array3d
+          array4d array5d array6d asin assert atan bool2int card ceil concat
+          cos cosh dom dom_array dom_size fix exp floor index_set
+          index_set_1of2 index_set_2of2 index_set_1of3 index_set_2of3
+          index_set_3of3 int2float is_fixed join lb lb_array length ln log log2
+          log10 min max pow product round set2array show show_int show_float
+          sin sinh sqrt sum tan tanh trace ub ub_array
+        ]
+      end
+
+      def self.keywords
+        @keywords = Set.new %w[
+          ann annotation any constraint else endif function for forall if
+          include list of op output minimize maximize par predicate record
+          satisfy solve test then type var where
+        ]
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          array set bool enum float int string tuple
+        )
+      end
+
+      def self.operators
+        @operators ||= Set.new %w(
+          in subset superset union diff symdiff intersect
+        )
+      end
+
+      id = /[$a-zA-Z_]\w*/
+
+      state :root do
+        rule %r(\s+)m, Text::Whitespace
+        rule %r(\\\n)m, Text::Whitespace
+        rule %r(%.*), Comment::Single
+        rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/)m, Comment::Multiline
+        rule %r/"(\\\\|\\"|[^"])*"/, Literal::String
+
+        rule %r(not|<->|->|<-|\\/|xor|/\\), Operator
+        rule %r(<|>|<=|>=|==|=|!=), Operator
+        rule %r(\+|-|\*|/|div|mod), Operator
+        rule %r(\\|\.\.|\+\+), Operator
+        rule %r([|()\[\]{},:;]), Punctuation
+        rule %r((true|false)\b), Keyword::Constant
+        rule %r(([+-]?)\d+(\.(?!\.)\d*)?([eE][-+]?\d+)?), Literal::Number
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.keywords_type.include? m[0]
+            token Keyword::Type
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif self.class.operators.include? m[0]
+            token Operator
+          else
+            token Name::Other
+          end
+        end
+
+        rule %r(::\s*([^\W\d]\w*)(\s*\([^\)]*\))?), Name::Decorator
+        rule %r(\b([^\W\d]\w*)\b(\()) do
+          groups Name::Function, Punctuation
+        end
+        rule %r([^\W\d]\w*), Name::Other
+      end
+    end
+  end
+end

data/lib/rouge/lexers/msgtrans.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class MsgTrans < RegexLexer
+      title "MessageTrans"
+      desc "RISC OS message translator messages file"
+      tag 'msgtrans'
+      filenames 'Messages', 'Message[0-9]', 'Message[1-9][0-9]', 'Message[1-9][0-9][0-9]'
+
+      state :root do
+        rule %r/^#[^\n]*/, Comment
+        rule %r/[^\t\n\r ,):?\/]+/, Name::Variable
+        rule %r/[\n\/?]/, Operator
+        rule %r/:/, Operator, :value
+      end
+
+      state :value do
+        rule %r/\n/, Text, :pop!
+        rule %r/%[0-3%]/, Operator
+        rule %r/[^\n%]/, Literal::String
+      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

data/lib/rouge/lexers/ocaml/common.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # shared states with Reasonml
+    class OCamlCommon < RegexLexer
+      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 module mutable new
+          nonrec object of open 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)
+      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 :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

data/lib/rouge/lexers/opentype_feature_file.rb

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class OpenTypeFeatureFile < RegexLexer
+      title "OpenType Feature File"
+      desc "Feature specifications for an OpenType font (adobe-type-tools.github.io/afdko)"
+      tag 'opentype_feature_file'
+      aliases 'fea', 'opentype', 'opentypefeature'
+      filenames '*.fea'
+
+      def self.keywords
+        @keywords ||= %w(
+          Ascender Attach CapHeight CaretOffset CodePageRange Descender FontRevision FSType
+          GlyphClassDef HorizAxis.BaseScriptList HorizAxis.BaseTagList HorizAxis.MinMax
+          IgnoreBaseGlyphs IgnoreLigatures IgnoreMarks LigatureCaretByDev LigatureCaretByIndex
+          LigatureCaretByPos LineGap MarkAttachClass MarkAttachmentType NULL Panose RightToLeft
+          TypoAscender TypoDescender TypoLineGap UnicodeRange UseMarkFilteringSet Vendor
+          VertAdvanceY VertAxis.BaseScriptList VertAxis.BaseTagList VertAxis.MinMax VertOriginY
+          VertTypoAscender VertTypoDescender VertTypoLineGap WeightClass WidthClass XHeight
+
+          anchorDef anchor anonymous anon by contour cursive device enumerate enum
+          exclude_dflt featureNames feature from ignore include_dflt include languagesystem
+          language lookupflag lookup markClass mark nameid name parameters position pos required
+          reversesub rsub script sizemenuname substitute subtable sub table useExtension
+          valueRecordDef winAscent winDescent
+        )
+      end
+
+
+      identifier = %r/[a-z_][a-z0-9\/_]*/i
+
+      state :root do
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/#.*$/, Comment
+
+        # feature <tag>
+        rule %r/(anonymous|anon|feature|lookup|table)((?:\s)+)/ do
+          groups Keyword, Text
+          push :featurename
+        end
+        # } <tag> ;
+        rule %r/(\})((?:\s)*)/ do
+          groups Punctuation, Text
+          push :featurename
+        end
+        # solve include( ../path)
+        rule %r/(include)/i, Keyword, :includepath
+
+        rule %r/[\-\[\]\/(){},.:;=%*<>']/, Punctuation
+
+        rule %r/`.*?/, Str::Backtick
+        rule %r/\"/, Str, :dqs
+
+        # classes, start with @<nameOfClass>
+        rule %r/@#{identifier}/, Name::Class
+
+        # using negative lookbehind so we don't match property names
+        rule %r/(?<!\.)#{identifier}/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule identifier, Name
+        rule %r/-?\d+/, Num::Integer
+      end
+
+      state :featurename do
+        rule identifier, Name::Function, :pop!
+      end
+
+      state :includepath do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/\(/, Punctuation
+        rule %r/[a-z0-9\/_.]*/i, Str
+      end
+
+      state :strings do
+        rule %r/(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, Str
+      end
+
+      state :strings_double do
+        rule %r/[^\\"%\n]+/, Str
+        mixin :strings
+      end
+
+      state :escape do
+        rule %r(\\
+          ( [\\abfnrtv"']
+          | \n
+          | N{[a-zA-z][a-zA-Z ]+[a-zA-Z]}
+          | u[a-fA-F0-9]{4}
+          | U[a-fA-F0-9]{8}
+          | x[a-fA-F0-9]{2}
+          | [0-7]{1,3}
+          )
+        )x, Str::Escape
+      end
+
+      state :dqs do
+        rule %r/"/, Str, :pop!
+        mixin :escape
+        mixin :strings_double
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/perl.rb

@@ -127,7 +127,7 @@ module Rouge
         rule %r/(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
         rule %r/(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
         rule %r/(q|qq|qw|qr|qx)</, Str::Other, :lt_string
-        rule %r/(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
+        rule %r/(q|qq|qw|qr|qx)(\W)(.|\n)*?\2/, Str::Other
 
         rule %r/package\s+/, Keyword, :modulename
         rule %r/sub\s+/, Keyword, :funcname

data/lib/rouge/lexers/php.rb

@@ -72,7 +72,7 @@ module Rouge
           while endforeach global __FILE__ endif list __LINE__ endswitch
           new __sleep endwhile not array __wakeup E_ALL NULL final
           php_user_filter interface implements public private protected
-          abstract clone try catch throw this use namespace yield
+          abstract clone try catch finally throw this use namespace yield
         )
       end
 
@@ -98,21 +98,29 @@ module Rouge
       state :php do
         rule %r/\?>/, Comment::Preproc, :pop!
         # heredocs
-        rule %r/<<<('?)(#{id})\1\n.*?\n\2;?\n/im, Str::Heredoc
+        rule %r/<<<('?)(#{id})\1\n.*?\n\s*\2;?/im, Str::Heredoc
         rule %r/\s+/, Text
         rule %r/#.*?$/, Comment::Single
         rule %r(//.*?$), Comment::Single
-        # empty comment, otherwise seen as the start of a docstring
-        rule %r(/\*\*/), Comment::Multiline
-        rule %r(/\*\*.*?\*/)m, Str::Doc
+        rule %r(/\*\*(?!/).*?\*/)m, Comment::Doc
         rule %r(/\*.*?\*/)m, Comment::Multiline
+        
         rule %r/(->|::)(\s*)(#{id})/ do
           groups Operator, Text, Name::Attribute
         end
 
         rule %r/[~!%^&*+=\|:.<>\/?@-]+/, Operator
         rule %r/[\[\]{}();,]/, Punctuation
-        rule %r/class\b/, Keyword, :classname
+        rule %r/(class|interface|trait)(\s+)(#{nsid})/ do
+          groups Keyword::Declaration, Text, Name::Class
+        end
+        rule %r/(use)(\s+)(function|const|)(\s*)(#{nsid})/ do
+          groups Keyword::Namespace, Text, Keyword::Namespace, Text, Name::Namespace
+          push :use
+        end
+        rule %r/(namespace)(\s+)(#{nsid})/ do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
         # anonymous functions
         rule %r/(function)(\s*)(?=\()/ do
           groups Keyword, Text
@@ -154,10 +162,24 @@ module Rouge
         rule %r/`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
         rule %r/"/, Str::Double, :string
       end
-
-      state :classname do
+      
+      state :use do
+        rule %r/(\s+)(as)(\s+)(#{id})/ do
+          groups Text, Keyword, Text, Name
+          :pop!
+        end
+        rule %r/\\\{/, Operator, :uselist
+        rule %r/;/, Punctuation, :pop!
+      end
+      
+      state :uselist do
         rule %r/\s+/, Text
-        rule %r/#{nsid}/, Name::Class, :pop!
+        rule %r/,/, Operator
+        rule %r/\}/, Operator, :pop!
+        rule %r/(as)(\s+)(#{id})/ do
+          groups Keyword, Text, Name
+        end
+        rule %r/#{id}/, Name::Namespace
       end
 
       state :funcname do