rouge 3.9.0 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2f0b54640482b19036e531f9a7da24b88a57e4f908f58ca5d9a515771ff5d31
-  data.tar.gz: bb378080c11eec20243d1a9abb85fbe8bbaddbcdeb836d60a80972cbe69ae25b
+  metadata.gz: a05162378ada50863a8c1a08984934c22af14e5288510b83fef150bae1f6be77
+  data.tar.gz: c3785466ac705a0acac1af6d60f73c0a697fa4b7504874b8d58db6a2efcaf21d
 SHA512:
-  metadata.gz: 11f884bbfd8b631eacae6da8497d6b8444c4ec748dfceea4e8d8a7d5b92aadc6f36ca6e50367477b7b4e465004ed3c52ac597c3ed19a9e49742ed93de4c40d71
-  data.tar.gz: 137d26aa2078d6d26ba17d57b75f330e071e15211816a60daa35b269784c8fba44ddd00813d4c0d2427412084d0a47a19edace54b3bc3320751d3b10105e4a07
+  metadata.gz: cffd7cde0caf543698b605bbdf64394a529c4fb11c025bd6ffa00d04d336f8a5cff8663d3d5a7e3f57a0f061d152d01914e2c3fbeaead37d6daf37ea491169bc
+  data.tar.gz: faefcadccccee11a7e896fc408dcbfddf858c73f44697b5961777285e4f7d878fcd7ee0eefd3d42a9cd5442946dfc9ded90d6875b5d12771a6bd1eb631b57c43

data/lib/rouge/demos/apex

@@ -0,0 +1,9 @@
+public class with sharing Trigger {
+    @Deprecated
+    public void resolveSum(int x, int y) {
+        System.debug('x is ' + x);
+        System.debug('y is ' + y);
+
+        System.debug('x + y = ' + (x+y));
+    }
+}

data/lib/rouge/demos/clean

@@ -0,0 +1,6 @@
+delete :: !a !.(Set a) -> Set a | < a
+delete x Tip = Tip
+delete x (Bin _ y l r)
+  | x < y     = balanceR y (delete x l) r
+  | x > y     = balanceL y l (delete x r)
+  | otherwise = glue l r

data/lib/rouge/demos/csvs

@@ -0,0 +1,8 @@
+version 1.1
+@totalColumns 5
+@separator ','
+Transaction_Date: xDate
+Transaction_ID: notEmpty
+Originator_Name: notEmpty
+Originator_Address: any("yes","no")
+Originator_Country: notEmpty

data/lib/rouge/demos/jsl

@@ -0,0 +1,3 @@
+// Create Distribution of Big Class
+dt = open( "$sample_data\big class.jmp" );
+dt << Distribution( Column( :age ), Histograms Only( 1 ) );

data/lib/rouge/demos/liquid

@@ -5,7 +5,6 @@
       Only {{ product.price | format_as_money }}
 
       <p>{{ product.description | prettyprint | truncate: 200  }}</p>
-
     </li>
   {% endfor %}
 </ul>

data/lib/rouge/demos/lustre

@@ -0,0 +1,6 @@
+node count(init: int; reset, event: bool) returns (c: int);
+let
+	c = init -> if reset then init
+					else if event then pre(c)+1
+					else pre(c);
+tel;

data/lib/rouge/demos/lutin

@@ -0,0 +1,18 @@
+node gen_x_v1() returns (x:real) = loop 0.0<x and x<42.0
+
+node gen_x_v2() returns (x:real) = 
+  loop { 0.0<x and x<42.0 fby loop [20] x = pre x }
+
+node gen_x_v3() returns (target:real; x:real=0.0) =
+  run target := gen_x_v2() in
+  loop { x = (pre x + target) / 2.0 }
+
+let inertia=0.6
+
+node gen_x_v4()  returns (target:real; x:real=0.0) =
+  run target := gen_x_v2() in
+  exist px,ppx : real = 0.0 in
+  loop { 
+      px = pre x and ppx = pre px and
+      x = (px+target) / 2.0+inertia*(px-ppx) 
+  }

data/lib/rouge/demos/minizinc

@@ -0,0 +1,23 @@
+% from MiniZinc Handbook:
+% https://www.minizinc.org/doc-latest/en/modelling.html
+
+% Colouring Australia using nc colours
+int: nc = 3;
+
+var 1..nc: wa;   var 1..nc: nt;  var 1..nc: sa;   var 1..nc: q;
+var 1..nc: nsw;  var 1..nc: v;   var 1..nc: t;
+
+constraint wa != nt;
+constraint wa != sa;
+constraint nt != sa;
+constraint nt != q;
+constraint sa != q;
+constraint sa != nsw;
+constraint sa != v;
+constraint q != nsw;
+constraint nsw != v;
+solve satisfy;
+
+output ["wa=\(wa)\t nt=\(nt)\t sa=\(sa)\n",
+        "q=\(q)\t nsw=\(nsw)\t v=\(v)\n",
+         "t=", show(t),  "\n"];

data/lib/rouge/demos/q

@@ -1,2 +1,8 @@
 / comment
 x: til 10
+
+tab:([]a:1 2 3;b:`a `b `c);
+
+function:{[table]
+	select from table where b=`c
+	};

data/lib/rouge/demos/robot_framework

@@ -0,0 +1,27 @@
+*** Settings ***
+Document	  Example taken from http://robotframework.org/
+Suite Setup       Open Browser To Login Page
+Suite Teardown    Close Browser
+Test Setup        Go To Login Page
+Test Template     Login With Invalid Credentials Should Fail
+Resource          resource.txt
+
+*** Test Cases ***               User Name        Password
+Invalid Username                 invalid          ${VALID PASSWORD}
+Invalid Password                 ${VALID USER}    invalid
+Invalid Username And Password    invalid          whatever
+Empty Username                   ${EMPTY}         ${VALID PASSWORD}
+Empty Password                   ${VALID USER}    ${EMPTY}
+Empty Username And Password      ${EMPTY}         ${EMPTY}
+
+*** Keywords ***
+Login With Invalid Credentials Should Fail
+    [Arguments]    ${username}    ${password}
+    Input Username    ${username}
+    Input Password    ${password}
+    Submit Credentials
+    Login Should Have Failed
+
+Login Should Have Failed
+    Location Should Be    ${ERROR URL}
+    Title Should Be    Error Page

data/lib/rouge/demos/sparql

@@ -0,0 +1,6 @@
+SELECT ?item ?itemLabel
+WHERE
+{
+  ?item wdt:P31 wd:Q146.
+  SERVICE wikibase:label { bd:serviceParam wikibase:language "[AUTO_LANGUAGE],en". }
+}

data/lib/rouge/demos/ttcn3

@@ -0,0 +1,6 @@
+module DNSTester {
+  type integer Identification( 0..65535 ); // 16-bit integer
+  type enumerated MessageKind {e_Question, e_Answer};
+  type charstring Question;
+  type charstring Answer;
+}

data/lib/rouge/guessers/disambiguation.rb

@@ -126,6 +126,11 @@ module Rouge
 
         next PlainText
       end
+
+      disambiguate '*.cls' do
+        next TeX if matches?(/\A\s*(?:\\|%)/)
+        next Apex
+      end
     end
   end
 end

data/lib/rouge/lexer.rb

@@ -49,6 +49,9 @@ module Rouge
       #
       #     Lexer.find_fancy('guess', "#!/bin/bash\necho Hello, world")
       #
+      #   If the code matches more than one lexer then Guesser::Ambiguous
+      #   is raised.
+      #
       # This is used in the Redcarpet plugin as well as Rouge's own
       # markdown lexer for highlighting internal code blocks.
       #

data/lib/rouge/lexers/apex.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Apex < RegexLexer
+      title "Apex"
+      desc "The Apex programming language (provided by salesforce)"
+
+      tag 'apex'
+      filenames '*.cls'
+      mimetypes 'text/x-apex'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          assert break case catch continue default do else finally for if goto
+          instanceof new return switch this throw try while insert update
+          delete
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          abstract const enum extends final implements native private protected
+          public static super synchronized throws transient volatile with
+          sharing without inherited virtual global testmethod
+        )
+      end
+
+      def self.soql
+        @soql ||= Set.new %w(
+          SELECT FROM WHERE UPDATE LIKE TYPEOF END USING SCOPE WITH DATA
+          CATEGORY GROUP BY ROLLUP CUBE HAVING ORDER BY ASC DESC NULLS FIRST
+          LAST LIMIT OFFSET FOR VIEW REFERENCE UPDATE TRACKING VIEWSTAT OR AND
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          String boolean byte char double float int long short var void
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      id = /[a-z_][a-z0-9_]*/i
+
+      state :root do
+        rule %r/\s+/m, Text
+        
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/import\b/, Keyword::Namespace, :import
+
+        rule %r/([@$.]?)(#{id})([:(]?)/io do |m|
+          if self.class.keywords.include? m[0].downcase
+            token Keyword
+          elsif self.class.soql.include? m[0].upcase
+            token Keyword
+          elsif self.class.declarations.include? m[0].downcase
+            token Keyword::Declaration
+          elsif self.class.types.include? m[0].downcase
+            token Keyword::Type
+          elsif self.class.constants.include? m[0].downcase
+            token Keyword::Constant
+          elsif 'package'.casecmp m[0]
+            token Keyword::Namespace
+          elsif m[1] == "@"
+            token Name::Decorator
+          elsif m[3] == ":"
+            groups Operator, Name::Label, Punctuation
+          elsif m[3] == "("
+            groups Operator, Name::Function, Punctuation
+          elsif m[1] == "."
+            groups Operator, Name::Property, Punctuation
+          else
+            token Name
+          end
+        end
+
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
+
+        digit = /[0-9]_+[0-9]|[0-9]/
+        rule %r/#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
+        rule %r/0b(?:[01]_+[01]|[01])+/i, Num::Bin
+        rule %r/0x(?:\h_+\h|\h)+/i, Num::Hex
+        rule %r/0(?:[0-7]_+[0-7]|[0-7])+/, Num::Oct
+        rule %r/#{digit}+L?/, Num::Integer
+
+        rule %r/[-+\/*~^!%&<>|=.?]/, Operator
+        rule %r/[\[\](){},:;]/, Punctuation;
+      end
+
+      state :class do
+        rule %r/\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r/\s+/m, Text
+        rule %r/[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+      end
+
+      state :escape do
+        rule %r/\\[btnfr\\"']/, Str::Escape
+      end
+
+      state :dq do
+        mixin :escape
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        mixin :escape
+        rule %r/[^\\']+/, Str::Double
+        rule %r/'/, Str::Double, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/bpf.rb

@@ -13,14 +13,28 @@ module Rouge
       ).join('|')
 
       MISC_KEYWORDS = %w(
-        be16 be32 be64 exit lock
+        be16 be32 be64 exit lock map
       ).join('|')
 
       state :root do
+        # Line numbers and hexadecimal output from bpftool/objdump
+        rule %r/(\d+)(:)(\s+)(\(\h{2}\))/i do
+          groups Generic::Lineno, Punctuation, Text::Whitespace, Generic
+        end
+        rule %r/(\d+)(:)(\s+)((?:\h{2} ){8})/i do
+          groups Generic::Lineno, Punctuation, Text::Whitespace, Generic
+        end
+        rule %r/(\d+)(:)(\s+)/i do
+          groups Generic::Lineno, Punctuation, Text::Whitespace
+        end
+
         # Calls to helpers
         rule %r/(call)(\s+)(\d+)/i do
           groups Keyword, Text::Whitespace, Literal::Number::Integer
         end
+        rule %r/(call)(\s+)(\w+)(#)(\d+)/i do
+          groups Keyword, Text::Whitespace, Name::Builtin, Punctuation, Literal::Number::Integer
+        end
 
         # Unconditional jumps
         rule %r/(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
@@ -28,10 +42,10 @@ module Rouge
         end
 
         # Conditional jumps
-        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(0x\h+|[-]?\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
+        rule %r/(if)(\s+)([rw]\d+)(\s*)([s!=<>]+)(\s*)(0x\h+|[-]?\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
           groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
-        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(r\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
+        rule %r/(if)(\s+)([rw]\d+)(\s*)([s!=<>]+)(\s*)([rw]\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
           groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Name, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
 
@@ -45,7 +59,7 @@ module Rouge
         rule %r/[+-\/\*&|><^s]{0,3}=/i, Operator
 
         # Registers
-        rule %r/([+-]?)(r\d+)/i do
+        rule %r/([+-]?)([rw]\d+)/i do
           groups Punctuation, Name
         end
 
@@ -73,7 +87,7 @@ module Rouge
 
       state :address do
         # Address is offset from register
-        rule %r/(\()(r\d+)(\s*)([+-])(\s*)(\d+)(\))/i do
+        rule %r/(\()([rw]\d+)(\s*)([+-])(\s*)(\d+)(\))/i do
           groups Punctuation, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number::Integer, Punctuation
           pop!
         end
@@ -83,7 +97,7 @@ module Rouge
           groups Name, Punctuation, Literal::Number::Integer, Punctuation
           pop!
         end
-        rule %r/(\w+)(\[)(r\d+)(\])/i do
+        rule %r/(\w+)(\[)([rw]\d+)(\])/i do
           groups Name, Punctuation, Name, Punctuation
           pop!
         end

data/lib/rouge/lexers/clean.rb

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Clean < RegexLexer
+      title "Clean"
+      desc "The Clean programming language (clean.cs.ru.nl)"
+
+      tag 'clean'
+      filenames '*.dcl', '*.icl'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          if otherwise
+          let in
+          with where
+          case of
+          infix infixl infixr
+          class instance
+          generic derive
+          special
+          implementation definition system module
+          from import qualified as
+          dynamic
+          code inline foreign export ccall stdcall
+        )
+      end
+
+      # These are literal patterns common to the ABC intermediate language and
+      # Clean. Clean has more extensive literal patterns (see :basic below).
+      state :common_literals do
+        rule %r/'(?:[^'\\]|\\(?:x[0-9a-fA-F]+|\d+|.))'/, Str::Char
+
+        rule %r/[+~-]?\d+\.\d+(?:E[+-]?\d+)?\b/, Num::Float
+        rule %r/[+~-]?\d+E[+-]?\d+\b/, Num::Float
+        rule %r/[+~-]?\d+/, Num::Integer
+
+        rule %r/"/, Str::Double, :string
+      end
+
+      state :basic do
+        rule %r/\s+/m, Text::Whitespace
+
+        rule %r/\/\/\*.*/, Comment::Doc
+        rule %r/\/\/.*/, Comment::Single
+        rule %r/\/\*\*/, Comment::Doc, :comment_doc
+        rule %r/\/\*/, Comment::Multiline, :comment
+
+        rule %r/[+~-]?0[0-7]+/, Num::Oct
+        rule %r/[+~-]?0x[0-9a-fA-F]+/, Num::Hex
+        mixin :common_literals
+        rule %r/(\[)(\s*)(')(?=.*?'\])/ do
+          groups Punctuation, Text::Whitespace, Str::Single, Punctuation
+          push :charlist
+        end
+      end
+
+      # nested commenting
+      state :comment_doc do
+        rule %r/\*\//, Comment::Doc, :pop!
+        rule %r/\/\/.*/, Comment::Doc # Singleline comments in multiline comments are skipped
+        rule %r/\/\*/, Comment::Doc, :comment
+        rule %r/[^*\/]+/, Comment::Doc
+        rule %r/[*\/]/, Comment::Doc
+      end
+
+      # This is the same as the above, but with Multiline instead of Doc
+      state :comment do
+        rule %r/\*\//, Comment::Multiline, :pop!
+        rule %r/\/\/.*/, Comment::Multiline # Singleline comments in multiline comments are skipped
+        rule %r/\/\*/, Comment::Multiline, :comment
+        rule %r/[^*\/]+/, Comment::Multiline
+        rule %r/[*\/]/, Comment::Multiline
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/code(\s+inline)?\s*{/, Comment::Preproc, :abc
+
+        rule %r/_*[a-z][\w_`]*/ do |m|
+          if self.class.keywords.include?(m[0])
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule %r/_*[A-Z][\w_`]*/ do |m|
+          if m[0]=='True' || m[0]=='False'
+            token Keyword::Constant
+          else
+            token Keyword::Type
+          end
+        end
+
+        rule %r/[^\w_\s`]/, Punctuation
+        rule %r/_\b/, Punctuation
+      end
+
+      state :escapes do
+        rule %r/\\x[0-9a-fA-F]{1,2}/i, Str::Escape
+        rule %r/\\d\d{0,3}/i, Str::Escape
+        rule %r/\\0[0-7]{0,3}/, Str::Escape
+        rule %r/\\[0-7]{1,3}/, Str::Escape
+        rule %r/\\[nrfbtv\\"']/, Str::Escape
+      end
+
+      state :string do
+        rule %r/"/, Str::Double, :pop!
+        mixin :escapes
+        rule %r/[^\\"]+/, Str::Double
+      end
+
+      state :charlist do
+        rule %r/(')(\])/ do
+          groups Str::Single, Punctuation
+          pop!
+        end
+        mixin :escapes
+        rule %r/[^\\']/, Str::Single
+      end
+
+      state :abc_basic do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\|.*/, Comment::Single
+        mixin :common_literals
+      end
+
+      # The ABC intermediate language can be included, similar to C's inline
+      # assembly. For some information about ABC, see:
+      # https://en.wikipedia.org/wiki/Clean_(programming_language)#The_ABC-Machine
+      state :abc do
+        mixin :abc_basic
+
+        rule %r/}/, Comment::Preproc, :pop!
+        rule %r/\.\w*/, Keyword, :abc_rest_of_line
+        rule %r/[\w_]+/, Name::Builtin, :abc_rest_of_line
+      end
+
+      state :abc_rest_of_line do
+        rule %r/\n/, Text::Whitespace, :pop!
+        rule %r/}/ do
+          token Comment::Preproc
+          pop!
+          pop!
+        end
+
+        mixin :abc_basic
+
+        rule %r/\S+/, Name
+      end
+    end
+  end
+end