rouge 3.17.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/moonscript.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'lua.rb'
+
+    class Moonscript < RegexLexer
+      title "MoonScript"
+      desc "Moonscript (http://www.moonscript.org)"
+      tag 'moonscript'
+      aliases 'moon'
+      filenames '*.moon'
+      mimetypes 'text/x-moonscript', 'application/x-moonscript'
+
+      option :function_highlighting, 'Whether to highlight builtin functions (default: true)'
+      option :disabled_modules, 'builtin modules to disable'
+
+      def initialize(*)
+        super
+
+        @function_highlighting = bool_option(:function_highlighting) { true }
+        @disabled_modules = list_option(:disabled_modules)
+      end
+
+      def self.detect?(text)
+        return true if text.shebang? 'moon'
+      end
+
+      def builtins
+        return [] unless @function_highlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          Rouge::Lexers::Lua.builtins.each do |mod, fns|
+            next if @disabled_modules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      state :root do
+        rule %r(#!(.*?)$), Comment::Preproc # shebang
+        rule %r//, Text, :main
+      end
+
+      state :base do
+        ident = '(?:\w\w*)'
+
+        rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
+        rule %r((?i)\d+e[+-]?\d+), Num::Float
+        rule %r((?i)0x[0-9a-f]*), Num::Hex
+        rule %r(\d+), Num::Integer
+        rule %r(@#{ident}*), Name::Variable::Instance
+        rule %r([A-Z]\w*), Name::Class
+        rule %r("?[^"]+":), Literal::String::Symbol
+        rule %r(#{ident}:), Literal::String::Symbol
+        rule %r(:#{ident}), Literal::String::Symbol
+
+        rule %r(\s+), Text::Whitespace
+        rule %r((==|~=|!=|<=|>=|\.\.\.|\.\.|->|=>|[=+\-*/%^<>#!\\])), Operator
+        rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
+        rule %r((and|or|not)\b), Operator::Word
+
+        keywords = %w{
+          break class continue do else elseif end extends for if import in
+          repeat return switch super then unless until using when with while
+        }
+        rule %r((#{keywords.join('|')})\b), Keyword
+        rule %r((local|export)\b), Keyword::Declaration
+        rule %r((true|false|nil)\b), Keyword::Constant
+
+        rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
+          name = m[0]
+          if self.builtins.include?(name)
+            token Name::Builtin
+          elsif name =~ /\./
+            a, b = name.split('.', 2)
+            token Name, a
+            token Punctuation, '.'
+            token Name, b
+          else
+            token Name
+          end
+        end
+      end
+
+      state :main do
+        rule %r(--.*$), Comment::Single
+        rule %r(\[(=*)\[.*?\]\1\])m, Str::Heredoc
+
+        mixin :base
+
+        rule %r('), Str::Single, :sqs
+        rule %r("), Str::Double, :dqs
+      end
+
+      state :sqs do
+        rule %r('), Str::Single, :pop!
+        rule %r([^']+), Str::Single
+      end
+
+      state :interpolation do
+        rule %r(\}), Str::Interpol, :pop!
+        mixin :base
+      end
+
+      state :dqs do
+        rule %r(#\{), Str::Interpol, :interpolation
+        rule %r("), Str::Double, :pop!
+        rule %r(#[^{]), Str::Double
+        rule %r([^"#]+), Str::Double
+      end
+    end
+  end
+end

data/lib/rouge/lexers/mosel.rb

@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Mosel < RegexLexer
+      tag 'mosel'
+      filenames '*.mos'
+      title "Mosel"
+      desc "An optimization language used by Fico's Xpress."
+      # http://www.fico.com/en/products/fico-xpress-optimization-suite
+      filenames '*.mos'
+
+      mimetypes 'text/x-mosel'
+
+      def self.detect?(text)
+        return true if text =~ /^\s*(model|package)\s+/
+      end
+
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      ############################################################################################################################
+      #  General language lements
+      ############################################################################################################################
+
+      core_keywords = %w(
+        and array as
+        boolean break
+        case count counter
+        declarations div do dynamic
+        elif else end evaluation exit
+        false forall forward from function
+        if imports in include initialisations initializations integer inter is_binary is_continuous is_free is_integer is_partint is_semcont is_semint is_sos1 is_sos2
+        linctr list
+        max min mod model mpvar
+        next not of options or
+        package parameters procedure
+        public prod range real record repeat requirements
+        set string sum
+        then to true
+        union until uses
+        version
+        while with
+      )
+
+      core_functions = %w(
+        abs arctan assert
+        bitflip bitneg bitset bitshift bittest bitval
+        ceil cos create currentdate currenttime cuthead cuttail
+        delcell exists exit exp exportprob
+        fclose fflush finalize findfirst findlast floor fopen fselect fskipline
+        getact getcoeff getcoeffs getdual getfid getfirst gethead getfname getlast getobjval getparam getrcost getreadcnt getreverse getsize getslack getsol gettail gettype getvars
+        iseof ishidden isodd ln log
+        makesos1 makesos2 maxlist minlist
+        publish
+        random read readln reset reverse round
+        setcoeff sethidden setioerr setname setparam setrandseed settype sin splithead splittail sqrt strfmt substr
+        timestamp
+        unpublish
+        write writeln
+      )
+
+      ############################################################################################################################
+      # mmxprs module elements
+      ############################################################################################################################
+
+      mmxprs_functions = %w(
+        addmipsol
+        basisstability
+        calcsolinfo clearmipdir clearmodcut command copysoltoinit
+        defdelayedrows defsecurevecs
+        estimatemarginals
+        fixglobal
+        getbstat getdualray getiis getiissense getiistype getinfcause getinfeas getlb getloadedlinctrs getloadedmpvars getname getprimalray getprobstat getrange getsensrng getsize getsol getub getvars
+        implies indicator isiisvalid isintegral loadbasis
+        loadmipsol loadprob
+        maximize minimize
+        postsolve
+        readbasis readdirs readsol refinemipsol rejectintsol repairinfeas resetbasis resetiis resetsol
+        savebasis savemipsol savesol savestate selectsol setbstat setcallback setcbcutoff setgndata setlb setmipdir setmodcut setsol setub setucbdata stopoptimize
+        unloadprob
+        writebasis writedirs writeprob writesol
+        xor
+      )
+
+      mmxpres_constants = %w(XPRS_OPT  XPRS_UNF  XPRS_INF XPRS_UNB XPRS_OTH)
+
+      mmxprs_parameters = %w(XPRS_colorder XPRS_enumduplpol XPRS_enummaxsol XPRS_enumsols XPRS_fullversion XPRS_loadnames XPRS_problem XPRS_probname XPRS_verbose)
+
+
+      ############################################################################################################################
+      # mmsystem module elements
+      ############################################################################################################################
+
+      mmsystem_functions = %w(
+        addmonths
+        copytext cuttext
+        deltext
+        endswith expandpath
+        fcopy fdelete findfiles findtext fmove
+        getasnumber getchar getcwd getdate getday getdaynum getdays getdirsep
+        getendparse setendparse
+        getenv getfsize getfstat getftime gethour getminute getmonth getmsec getpathsep
+        getqtype setqtype
+        getsecond
+        getsepchar setsepchar
+        getsize
+        getstart setstart
+        getsucc setsucc
+        getsysinfo getsysstat gettime
+        gettmpdir
+        gettrim settrim
+        getweekday getyear
+        inserttext isvalid
+        makedir makepath newtar
+        newzip nextfield
+        openpipe
+        parseextn parseint parsereal parsetext pastetext pathmatch pathsplit
+        qsort quote
+        readtextline regmatch regreplace removedir removefiles
+        setchar setdate setday setenv sethour
+        setminute setmonth setmsec setsecond settime setyear sleep startswith system
+        tarlist textfmt tolower toupper trim
+        untar unzip
+        ziplist
+      )
+
+      mmsystem_parameters = %w(datefmt datetimefmt monthnames sys_endparse sys_fillchar sys_pid sys_qtype sys_regcache sys_sepchar)
+
+      ############################################################################################################################
+      # mmjobs  module elements
+      ############################################################################################################################
+
+      mmjobs_instance_mgmt_functions = %w(
+        clearaliases connect
+        disconnect
+        findxsrvs
+        getaliases getbanner gethostalias
+        sethostalias
+      )
+
+      mmjobs_model_mgmt_functions = %w(
+        compile
+        detach
+        getannidents getannotations getexitcode getgid getid getnode getrmtid getstatus getuid
+        load
+        reset resetmodpar run
+        setcontrol setdefstream setmodpar setworkdir stop
+        unload
+      )
+
+      mmjobs_synchornization_functions = %w(
+        dropnextevent
+        getclass getfromgid getfromid getfromuid getnextevent getvalue
+        isqueueempty
+        nullevent
+        peeknextevent
+        send setgid setuid
+        wait waitfor
+      )
+
+      mmjobs_functions = mmjobs_instance_mgmt_functions + mmjobs_model_mgmt_functions + mmjobs_synchornization_functions
+
+      mmjobs_parameters = %w(conntmpl defaultnode fsrvdelay fsrvnbiter fsrvport jobid keepalive nodenumber parentnumber)
+
+
+      state :whitespace do
+        # Spaces
+        rule %r/\s+/m, Text
+        # ! Comments
+        rule %r((!).*$\n?), Comment::Single
+        # (! Comments !)
+        rule %r(\(!.*?!\))m, Comment::Multiline
+
+      end
+
+
+      # From Mosel documentation:
+      # Constant strings of characters must be quoted with single (') or double quote (") and may extend over several lines. Strings enclosed in double quotes may contain C-like escape sequences introduced by the 'backslash'
+      # character (\a \b \f \n \r \t \v \xxx with xxx being the character code as an octal number).
+      # Each sequence is replaced by the corresponding control character (e.g. \n is the `new line' command) or, if no control character exists, by the second character of the sequence itself (e.g. \\ is replaced by '\').
+      # The escape sequences are not interpreted if they are contained in strings that are enclosed in single quotes.
+
+      state :single_quotes do
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[^']+/, Str::Single
+      end
+
+      state :double_quotes do
+        rule %r/"/, Str::Double, :pop!
+        rule %r/(\\"|\\[0-7]{1,3}\D|\\[abfnrtv]|\\\\)/, Str::Escape
+        rule %r/[^"]/, Str::Double
+      end
+
+      state :base do
+
+        rule %r{"}, Str::Double, :double_quotes
+        rule %r{'}, Str::Single, :single_quotes
+
+        rule %r{((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?}, Num
+        rule %r{[~!@#\$%\^&\*\(\)\+`\-={}\[\]:;<>\?,\.\/\|\\]}, Punctuation
+#        rule %r{'([^']|'')*'}, Str
+#        rule %r/"(\\\\|\\"|[^"])*"/, Str
+
+
+
+        rule %r/(true|false)\b/i, Name::Builtin
+        rule %r/\b(#{core_keywords.join('|')})\b/i, Keyword
+        rule %r/\b(#{core_functions.join('|')})\b/, Name::Builtin
+
+
+
+        rule %r/\b(#{mmxprs_functions.join('|')})\b/, Name::Function
+        rule %r/\b(#{mmxpres_constants.join('|')})\b/, Name::Constant
+        rule %r/\b(#{mmxprs_parameters.join('|')})\b/i, Name::Property
+
+        rule %r/\b(#{mmsystem_functions.join('|')})\b/i, Name::Function
+        rule %r/\b(#{mmsystem_parameters.join('|')})\b/, Name::Property
+
+        rule %r/\b(#{mmjobs_functions.join('|')})\b/i, Name::Function
+        rule %r/\b(#{mmjobs_parameters.join('|')})\b/, Name::Property
+
+        rule id, Name
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :base
+      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