rouge 3.8.0 → 3.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4041f8ac950b427b35d8d3147b6d9aed3743655daaaf09f57d303932b11259a6
-  data.tar.gz: cddd94af18b0f7ba578fa4c57f75415233d5518095b29202a7c12afd2662b804
+  metadata.gz: 627bdb5578c0590a77e598473fcbe69330f21066cb87bd3463c2acabf31ac950
+  data.tar.gz: d28c6ae9d3a94d4cd81e1e7cd4ba883aa6a41d011569cd3051f140288bed70d8
 SHA512:
-  metadata.gz: 68b649f1f965e5cd21fd722263bdff8720ba04119b8fff2245bb9c4178648d255362c3a18129c6724dd56893f777a518d1ff74ade223697530f5a6595d20f2aa
-  data.tar.gz: 182df2ef3e868eb95132022309db218e34f2cd19e9e874a7d119f6250db0971e7ba6fd28ddea2ebfa8fdb759504dfe8a8401e085e95386748c7a00de347fc5d9
+  metadata.gz: 27fc73f1c40e471cb1120f6dab17700fb8155b1a4518c783374088725d35afe896a382e2ec2dd8690505bbe8eaf519396a4e5b4b6154816455b5865be7275244
+  data.tar.gz: 46e1d31f4df9486d498b8bc91b9fee28bfac7681b4acd276bbd084baf5a186ee2324c3fe16626f59df054e43e332b4fbb865115e7fb440b3acb4b3a6a0c0465e

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/eex

@@ -0,0 +1 @@
+<title><%= @title %></title>

data/lib/rouge/demos/haxe

@@ -0,0 +1,5 @@
+// hello world!
+public static function hello(arg : String) {
+    return 'Hello $arg';
+}
+

data/lib/rouge/demos/hql

@@ -0,0 +1,5 @@
+SELECT e.first_name, e.last_name, d.department_name
+FROM   employees e
+JOIN   departments d ON e.department_id = d.department_id;
+
+update `table` set name='abc', date=${date}, test_interpolation="${var1}.${var2}" where xyz is null;

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/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/terraform

@@ -1,10 +1,3 @@
-# From: https://github.com/terraform-providers/terraform-provider-aws/blob/master/examples/count/main.tf
-
-# Specify the provider and access details
-provider "aws" {
-  region = "${var.aws_region}"
-}
-
 resource "aws_elb" "web" {
   name = "terraform-example-elb"
 
@@ -21,11 +14,3 @@ resource "aws_elb" "web" {
   # The instances are registered automatically
   instances = ["${aws_instance.web.*.id}"]
 }
-
-resource "aws_instance" "web" {
-  instance_type = "m1.small"
-  ami           = "${lookup(var.aws_amis, var.aws_region)}"
-
-  # This will create 4 instances
-  count = 4
-}

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/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