rouge 3.18.0

data/lib/rouge/lexers/ceylon.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Ceylon < RegexLexer
+      tag 'ceylon'
+      filenames '*.ceylon'
+      mimetypes 'text/x-ceylon'
+
+      title "Ceylon"
+      desc 'Say more, more clearly.'
+
+      state :whitespace do
+        rule %r([^\S\n]+), Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/\*), Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r((shared|abstract|formal|default|actual|variable|deprecated|small|
+          late|literal|doc|by|see|throws|optional|license|tagged|final|native|
+          annotation|sealed)\b), Name::Decorator
+
+        rule %r((break|case|catch|continue|else|finally|for|in|
+          if|return|switch|this|throw|try|while|is|exists|dynamic|
+          nonempty|then|outer|assert|let)\b), Keyword
+
+        rule %r((abstracts|extends|satisfies|super|given|of|out|assign)\b), Keyword::Declaration
+
+        rule %r((function|value|void|new)\b), Keyword::Type
+
+        rule %r((assembly|module|package)(\s+)) do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+
+        rule %r((true|false|null)\b), Keyword::Constant
+
+        rule %r((class|interface|object|alias)(\s+)) do
+          groups Keyword::Declaration, Text
+          push :class
+        end
+
+        rule %r((import)(\s+)) do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+
+        rule %r("(\\\\|\\"|[^"])*"), Literal::String
+        rule %r('\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'), Literal::String::Char
+        rule %r(".*``.*``.*"', String::Interpol
+        rule %r(\.)([a-z_]\w*)) do
+          groups Operator, Name::Attribute
+        end
+        rule %r([a-zA-Z_]\w*:), Name::Label
+        rule %r((\\I[a-z]|[A-Z])\w*), Name::Decorator
+        rule %r([a-zA-Z_]\w*), Name
+        rule %r([~^*!%&\[\](){}<>|+=:;,./?`-]), Operator
+        rule %r(\d{1,3}(_\d{3})+\.\d{1,3}(_\d{3})+[kMGTPmunpf]?), Literal::Number::Float
+        rule %r(\d{1,3}(_\d{3})+\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?),
+          Literal::Number::Float
+        rule %r([0-9][0-9]*\.\d{1,3}(_\d{3})+[kMGTPmunpf]?), Literal::Number::Float
+        rule %r([0-9][0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?),
+          Literal::Number::Float
+        rule %r(#([0-9a-fA-F]{4})(_[0-9a-fA-F]{4})+), Literal::Number::Hex
+        rule %r(#[0-9a-fA-F]+), Literal::Number::Hex
+        rule %r(\$([01]{4})(_[01]{4})+), Literal::Number::Bin
+        rule %r(\$[01]+), Literal::Number::Bin
+        rule %r(\d{1,3}(_\d{3})+[kMGTP]?), Literal::Number::Integer
+        rule %r([0-9]+[kMGTP]?), Literal::Number::Integer
+        rule %r(\n), Text
+
+      end
+
+      state :class do
+        mixin :whitespace
+        rule %r([A-Za-z_]\w*), Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r([a-z][\w.]*), Name::Namespace, :pop!
+        rule %r("(\\\\|\\"|[^"])*"), Literal::String, :pop!
+      end
+
+      state :comment do
+        rule %r([^*/]), Comment.Multiline
+        rule %r(/\*), Comment::Multiline, :push!
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r([*/]), Comment::Multiline
+      end
+    end
+  end
+end

data/lib/rouge/lexers/cfscript.rb

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+
+    class Cfscript < RegexLexer
+      title "CFScript"
+      desc 'CFScript, the CFML scripting language'
+      tag 'cfscript'
+      aliases 'cfc'
+      filenames '*.cfc'
+
+      def self.keywords
+        @keywords ||= %w(
+          if else var xml default break switch do try catch throw in continue for return while required
+        )
+      end
+
+      def self.declarations
+        @declarations ||= %w(
+          component property function remote public package private
+        )
+      end
+
+      def self.types
+        @types ||= %w(
+          any array binary boolean component date guid numeric query string struct uuid void xml
+        )
+      end
+
+      constants = %w(application session client cookie super this variables arguments cgi)
+
+
+      operators = %w(\+\+ -- && \|\| <= >= < > == != mod eq lt gt lte gte not is and or xor eqv imp equal contains \? )
+      dotted_id = /[$a-zA-Z_][a-zA-Z0-9_.]*/
+
+      state :root do
+        mixin :comments_and_whitespace
+        rule %r/(?:#{operators.join('|')}|does not contain|greater than(?: or equal to)?|less than(?: or equal to)?)\b/i, Operator, :expr_start
+        rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start
+
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
+
+        rule %r/[?]/ do
+          token Punctuation
+          push :ternary
+          push :expr_start
+        end
+
+        rule %r/[{}]/, Punctuation, :statement
+
+        rule %r/(?:#{constants.join('|')})\b/, Name::Constant
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/import\b/, Keyword::Namespace, :import
+        rule %r/(#{dotted_id})(\s*)(:)(\s*)/ do
+          groups Name, Text, Punctuation, Text
+          push :expr_start
+        end
+
+        rule %r/([A-Za-z_$][\w.]*)(\s*)(\()/ do |m|
+          if self.class.keywords.include? m[1]
+            token Keyword, m[1]
+            token Text, m[2]
+            token Punctuation, m[3]
+          else
+            token Name::Function, m[1]
+            token Text, m[2]
+            token Punctuation, m[3]
+          end
+        end
+
+        rule dotted_id do |m|
+          if self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :expr_start
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+            push :expr_start
+          elsif self.class.types.include? m[0]
+            token Keyword::Type
+            push :expr_start
+          else
+            token Name::Other
+          end
+        end
+
+        rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\\\|\\"|[^"])*"/, Str::Double
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
+
+      end
+
+      # same as java, broken out
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+      end
+
+      state :expr_start do
+        mixin :comments_and_whitespace
+
+        rule %r/[{]/, Punctuation, :object
+
+        rule %r//, Text, :pop!
+      end
+
+      state :statement do
+
+        rule %r/[{}]/, Punctuation
+
+        mixin :expr_start
+      end
+
+      # object literals
+      state :object do
+        mixin :comments_and_whitespace
+        rule %r/[}]/ do
+          token Punctuation
+          push :expr_start
+        end
+
+        rule %r/(#{dotted_id})(\s*)(:)/ do
+          groups Name::Other, Text, Punctuation
+          push :expr_start
+        end
+
+        rule %r/:/, Punctuation
+        mixin :root
+      end
+
+      # ternary expressions, where <dotted_id>: is not a label!
+      state :ternary do
+        rule %r/:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
+        mixin :root
+      end
+
+      state :import do
+        rule %r/\s+/m, Text
+        rule %r/[a-z0-9_.]+\*?/i, Name::Namespace, :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

data/lib/rouge/lexers/clojure.rb

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Clojure < RegexLexer
+      title "Clojure"
+      desc "The Clojure programming language (clojure.org)"
+
+      tag 'clojure'
+      aliases 'clj', 'cljs'
+
+      filenames '*.clj', '*.cljs', '*.cljc', 'build.boot', '*.edn'
+
+      mimetypes 'text/x-clojure', 'application/x-clojure'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          fn def defn defmacro defmethod defmulti defn- defstruct if
+          cond let for
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          . ..  * + - -> / < <= = == > >= accessor agent agent-errors
+          aget alength all-ns alter and append-child apply array-map
+          aset aset-boolean aset-byte aset-char aset-double aset-float
+          aset-int aset-long aset-short assert assoc await await-for bean
+          binding bit-and bit-not bit-or bit-shift-left bit-shift-right
+          bit-xor boolean branch?  butlast byte cast char children
+          class clear-agent-errors comment commute comp comparator
+          complement concat conj cons constantly construct-proxy
+          contains? count create-ns create-struct cycle dec  deref
+          difference disj dissoc distinct doall doc dorun doseq dosync
+          dotimes doto double down drop drop-while edit end? ensure eval
+          every? false? ffirst file-seq filter find find-doc find-ns
+          find-var first float flush fnseq frest gensym get-proxy-class
+          get hash-map hash-set identical? identity if-let import in-ns
+          inc index insert-child insert-left insert-right inspect-table
+          inspect-tree instance? int interleave intersection into
+          into-array iterate join key keys keyword keyword? last lazy-cat
+          lazy-cons left lefts line-seq list* list load load-file locking
+          long loop macroexpand macroexpand-1 make-array make-node map
+          map-invert map? mapcat max max-key memfn merge merge-with meta
+          min min-key name namespace neg? new newline next nil? node not
+          not-any? not-every? not= ns-imports ns-interns ns-map ns-name
+          ns-publics ns-refers ns-resolve ns-unmap nth nthrest or parse
+          partial path peek pop pos? pr pr-str print print-str println
+          println-str prn prn-str project proxy proxy-mappings quot
+          rand rand-int range re-find re-groups re-matcher re-matches
+          re-pattern re-seq read read-line reduce ref ref-set refer rem
+          remove remove-method remove-ns rename rename-keys repeat replace
+          replicate resolve rest resultset-seq reverse rfirst right
+          rights root rrest rseq second select select-keys send send-off
+          seq seq-zip seq? set short slurp some sort sort-by sorted-map
+          sorted-map-by sorted-set special-symbol? split-at split-with
+          str string?  struct struct-map subs subvec symbol symbol?
+          sync take take-nth take-while test time to-array to-array-2d
+          tree-seq true? union up update-proxy val vals var-get var-set
+          var? vector vector-zip vector? when when-first when-let
+          when-not with-local-vars with-meta with-open with-out-str
+          xml-seq xml-zip zero? zipmap zipper'
+        )
+      end
+
+      identifier = %r([\w!$%*+,<=>?/.-]+)
+      keyword = %r([\w!\#$%*+,<=>?/.-]+)
+
+      def name_token(name)
+        return Keyword if self.class.keywords.include?(name)
+        return Name::Builtin if self.class.builtins.include?(name)
+        nil
+      end
+
+      state :root do
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/m, Text::Whitespace
+
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
+        rule %r/0x-?[0-9a-fA-F]+/, Num::Hex
+
+        rule %r/"(\\.|[^"])*"/, Str
+        rule %r/'#{keyword}/, Str::Symbol
+        rule %r/::?#{keyword}/, Name::Constant
+        rule %r/\\(.|[a-z]+)/i, Str::Char
+
+
+        rule %r/~@|[`\'#^~&@]/, Operator
+
+        rule %r/(\()(\s*)(#{identifier})/m do |m|
+          token Punctuation, m[1]
+          token Text::Whitespace, m[2]
+          token(name_token(m[3]) || Name::Function, m[3])
+        end
+
+        rule identifier do |m|
+          token name_token(m[0]) || Name
+        end
+
+        # vectors
+        rule %r/[\[\]]/, Punctuation
+
+        # maps
+        rule %r/[{}]/, Punctuation
+
+        # parentheses
+        rule %r/[()]/, Punctuation
+      end
+    end
+  end
+end