nano-max-hub 0.0.1

data/rouge-5.0.0/lib/rouge/lexers/nial.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Nial < RegexLexer
+      title 'Nial'
+      desc 'The Nial programming language (nial-array-language.org)'
+      tag 'nial'
+      filenames '*.ndf', '*.nlg'
+
+      def self.keywords
+        @keywords ||= Set.new ["is", "gets", "op", "tr", ";",
+                     "if", "then", "elseif", "else",
+                     "endif", "case", "from", "endcase",
+                     "begin", "end", "for", "with",
+                     "endfor", "while", "do", "endwhile",
+                     "repeat", "until", "endrepeat"]
+      end
+
+      def self.operators
+        @operators||= Set.new [".",  "!", "#", "+", "*", "-", "<<",
+                 "/", "<", ">>", "<=", ">", "=", ">=", "@", "|", "~="]
+      end
+
+      def self.punctuations
+        @punctuations ||= Set.new [ "{", "}", "[", "]", ",", "(", ")", ":=", ":", ";"]
+      end
+
+      def self.transformers
+        @transformers ||= Set.new ["accumulate", "across",
+        "bycols", "bykey",  "byrows",
+        "converse",  "down",
+        "eachboth", "eachall", "each",
+        "eachleft", "eachright",
+        "filter", "fold", "fork",
+        "grade",  "inner", "iterate",
+        "leaf",  "no_tr", "outer",
+        "partition", "rank", "recur",
+        "reduce", "reducecols", "reducerows",
+        "sort", "team", "timeit", "twig"]
+      end
+
+      def self.funcs
+        @funcs ||= Set.new ["operation", "expression", "and", "abs",
+                  "allbools", "allints", "allchars", "allin",
+                  "allreals", "allnumeric", "append",
+                  "arcsin", "arccos", "appendfile", "apply",
+                  "arctan", "atomic", "assign", "atversion",
+                  "axes", "cart", "break", "blend", "breaklist",
+                  "breakin", "bye", "callstack", "choose", "char",
+                  "ceiling", "catenate", "charrep", "check_socket",
+                  "cos", "content", "close", "clearws",
+                  "clearprofile", "cols", "continue", "copyright",
+                  "cosh", "cull", "count", "diverse", "deepplace",
+                  "cutall", "cut", "display", "deparse",
+                  "deepupdate", "descan", "depth", "diagram",
+                  "div", "divide", "drop", "dropright", "edit",
+                  "empty", "exit", "except", "erase",
+                  "equal", "eval", "eraserecord", "execute", "exp",
+                  "external", "exprs", "findall", "find",
+                  "fault", "falsehood", "filestatus", "filelength",
+                  "filepath", "filetally", "floor", "first",
+                  "flip", "fuse", "fromraw", "front",
+                  "gage", "getfile", "getdef", "getcommandline",
+                  "getenv", "getname", "hitch", "grid", "getsyms",
+                  "gradeup", "gt", "gte", "host", "in", "inverse",
+                  "innerproduct", "inv", "ip", "ln", "link", "isboolean",
+                  "isinteger", "ischar", "isfault", "isreal", "isphrase",
+                  "isstring", "istruthvalue", "last", "laminate",
+                  "like", "libpath", "library", "list", "load",
+                  "loaddefs", "nonlocal", "max", "match", "log",
+                  "lt", "lower", "lte", "mate", "min", "maxlength",
+                  "mod", "mix", "minus", "nialroot", "mold", "not",
+                  "numeric", "no_op", "no_expr", "notin", "open", "or", "opposite", "opp",
+                  "operators", "plus", "pick", "pack", "pass", "pair", "parse",
+                  "paste", "phrase", "place", "picture", "placeall",
+                  "power", "positions", "post", "quotient", "putfile",
+                  "profile", "prod", "product", "profiletree",
+                  "profiletable", "quiet_fault", "raise", "reach",
+                  "random", "reciprocal", "read", "readfile",
+                  "readchar", "readarray", "readfield",
+                  "readscreen", "readrecord", "recip", "reshape",
+                  "seek", "second", "rest", "reverse", "restart",
+                  "return_status", "scan", "save", "rows", "rotate",
+                  "seed", "see", "sublist", "sin", "simple", "shape",
+                  "setformat", "setdeftrace", "set", "seeusercalls",
+                  "seeprimcalls", "separator", "setwidth", "settrigger",
+                  "setmessages", "setlogname", "setinterrupts",
+                  "setprompt", "setprofile", "sinh", "single",
+                  "sqrt", "solitary", "sketch", "sleep",
+                  "socket_listen", "socket_accept", "socket_close",
+                  "socket_bind", "socket_connect", "socket_getline",
+                  "socket_receive", "socket_peek", "socket_read",
+                  "socket_send", "socket_write", "solve", "split",
+                  "sortup", "string", "status", "take", "symbols",
+                  "sum", "system", "tan", "tally", "takeright",
+                  "tanh", "tell", "tr", "times", "third", "time",
+                  "toupper", "tolower", "timestamp", "tonumber",
+                  "toraw", "toplevel", "transformer", "type",
+                  "transpose", "trs", "truth", "unequal",
+                  "variable", "valence", "up", "updateall",
+                  "update", "vacate", "value", "version", "vars",
+                  "void", "watch", "watchlist", "write", "writechars",
+                  "writearray", "writefile", "writefield",
+                  "writescreen", "writerecord"]
+      end
+
+      def self.consts
+        @consts ||= Set.new %w(false null pi true)
+      end
+
+      state :root do
+        rule %r/'/, Str::Single, :str
+        rule %r/\b[lo]+\b/, Num::Bin
+        rule %r/-?\d+((\.\d*)?[eE][+-]?\d|\.)\d*/, Num::Float
+        rule %r/\-?\d+/, Num::Integer
+        rule %r/`./, Str::Char
+        rule %r/"[^\s()\[\]{}#,;]*/, Str::Symbol
+        rule %r/\?[^\s()\[\]{}#,;]*/, Generic::Error
+        rule %r/%[^;]+;/, Comment::Multiline
+        rule %r/^#(.+\n)+\n/, Comment::Multiline
+        rule %r/:=|[\{\}\[\]\(\),:;]/ do |m|
+          if self.class.punctuations.include?(m[0])
+            token Punctuation
+          else
+            token Text
+          end
+        end
+        # [".",  "!", "#", "+", "*", "-", "<<",
+        #   "/", "<", ">>", "<=", ">", "=", ">=", "@", "|", "~="]
+        rule %r'>>|>=|<=|~=|[\.!#+*\-=></|@]' do |m|
+          if self.class.operators.include?(m[0])
+            token Operator
+          else
+            token Text
+          end
+        end
+
+        rule %r/\b[_A-Za-z]\w*\b/ do |m|
+          lower = m[0].downcase
+          if self.class.keywords.include?(lower)
+            token Keyword
+          elsif self.class.funcs.include?(lower)
+            token Keyword::Pseudo
+          elsif self.class.transformers.include?(lower)
+            token Name::Builtin
+          elsif self.class.consts.include?(lower)
+            token Keyword::Constant
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r/\s+/, Text
+      end
+
+      state :str do
+        rule %r/''/, Str::Escape
+        rule %r/[^']+/, Str::Single
+        rule %r/'|$/, Str::Single, :pop!
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/nim.rb

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Nim < RegexLexer
+      # This is pretty much a 1-1 port of the pygments NimrodLexer class
+      title "Nim"
+      desc "The Nim programming language (http://nim-lang.org/)"
+
+      tag 'nim'
+      aliases 'nimrod'
+      filenames '*.nim'
+
+      KEYWORDS = %w(
+        addr as asm atomic bind block break case cast const continue
+        converter defer discard distinct do elif else end enum except export
+        func finally for from generic if import include interface iterator let
+        macro method mixin nil object of out proc ptr raise ref return static
+        template try tuple type using var when while with without yield
+      )
+
+      OPWORDS = %w(
+        and or not xor shl shr div mod in notin is isnot
+      )
+
+      PSEUDOKEYWORDS = %w(
+        nil true false
+      )
+
+      TYPES = %w(
+       int int8 int16 int32 int64 float float32 float64 bool char range array
+       seq set string
+      )
+
+      NAMESPACE = %w(
+        from import include
+      )
+
+      def self.underscorize(words)
+        words.map do |w|
+          w.gsub(/./) { |x| "#{Regexp.escape(x)}_?" }
+        end.join('|')
+      end
+
+      state :chars do
+        rule(/\\([\\abcefnrtvl"\']|x[a-fA-F0-9]{2}|[0-9]{1,3})/, Str::Escape)
+        rule(/'/, Str::Char, :pop!)
+        rule(/./, Str::Char)
+      end
+
+      state :strings do
+        rule(/(?<!\$)\$(\d+|#|\w+)+/, Str::Interpol)
+        rule(/[^\\\'"\$\n]+/,         Str)
+        rule(/[\'"\\]/,               Str)
+        rule(/\$/,                    Str)
+      end
+
+      state :dqs do
+        rule(/\\([\\abcefnrtvl"\']|\n|x[a-fA-F0-9]{2}|[0-9]{1,3})/,
+             Str::Escape)
+        rule(/"/, Str, :pop!)
+        mixin :strings
+      end
+
+      state :rdqs do
+        rule(/"(?!")/, Str, :pop!)
+        rule(/"/,      Str::Escape, :pop!)
+        mixin :strings
+      end
+
+      state :tdqs do
+        rule(/"""(?!")/, Str, :pop!)
+        mixin :strings
+        mixin :nl
+      end
+
+      state :funcname do
+        rule(/((?![\d_])\w)(((?!_)\w)|(_(?!_)\w))*/, Name::Function, :pop!)
+        rule(/`.+`/,                                 Name::Function, :pop!)
+      end
+
+      state :nl do
+        rule(/\n/, Str)
+      end
+
+      state :floatnumber do
+        rule(/\.(?!\.)[0-9_]*/,       Num::Float)
+        rule(/[eE][+-]?[0-9][0-9_]*/, Num::Float)
+        rule(//,                      Text, :pop!)
+      end
+
+      # Making apostrophes optional, as only hexadecimal with type suffix
+      # possibly ambiguous.
+      state :floatsuffix do
+        rule(/'?[fF](32|64)/,          Num::Float)
+        rule(//,                      Text, :pop!)
+      end
+
+      state :intsuffix do
+        rule(/'?[iI](32|64)/,          Num::Integer::Long)
+        rule(/'?[iI](8|16)/,           Num::Integer)
+        rule(/'?[uU]/,                 Num::Integer)
+        rule(//,                      Text, :pop!)
+      end
+
+      state :root do
+        rule(/##.*$/, Str::Doc)
+        rule(/#.*$/,  Comment)
+        rule(/\*|=|>|<|\+|-|\/|@|\$|~|&|%|\!|\?|\||\\|\[|\]/, Operator)
+        rule(/\.\.|\.|,|\[\.|\.\]|{\.|\.}|\(\.|\.\)|{|}|\(|\)|:|\^|`|;/,
+             Punctuation)
+
+        # Strings
+        rule(/(?:\w+)"/,Str, :rdqs)
+        rule(/"""/,       Str, :tdqs)
+        rule(/"/,         Str, :dqs)
+
+        # Char
+        rule(/'/, Str::Char, :chars)
+
+        # Keywords
+        rule(%r[(#{Nim.underscorize(OPWORDS)})\b], Operator::Word)
+        rule(/(p_?r_?o_?c_?\s)(?![\(\[\]])/, Keyword, :funcname)
+        rule(%r[(#{Nim.underscorize(KEYWORDS)})\b],  Keyword)
+        rule(%r[(#{Nim.underscorize(NAMESPACE)})\b], Keyword::Namespace)
+        rule(/(v_?a_?r)\b/, Keyword::Declaration)
+        rule(%r[(#{Nim.underscorize(TYPES)})\b],          Keyword::Type)
+        rule(%r[(#{Nim.underscorize(PSEUDOKEYWORDS)})\b], Keyword::Pseudo)
+        # Identifiers
+        rule(/\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*/, Name)
+
+        # Numbers
+        # Note: Have to do this with a block to push multiple states first,
+        #       since we can't pass array of states like w/ Pygments.
+        rule(/[0-9][0-9_]*(?=([eE.]|'?[fF](32|64)))/) do
+          push :floatsuffix
+          push :floatnumber
+          token Num::Float
+        end
+
+        rule(/0[xX][a-fA-F0-9][a-fA-F0-9_]*/, Num::Hex,     :intsuffix)
+        rule(/0[bB][01][01_]*/,               Num,          :intsuffix)
+        rule(/0o[0-7][0-7_]*/,                Num::Oct,     :intsuffix)
+        rule(/[0-9][0-9_]*/,                  Num::Integer, :intsuffix)
+
+        # Whitespace
+        rule(/\s+/, Text)
+        rule(/.+$/, Error)
+      end
+
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/nix.rb

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Nix < RegexLexer
+      title 'Nix'
+      desc 'The Nix expression language (https://nixos.org/nix/manual/#ch-expression-language)'
+      tag 'nix'
+      aliases 'nixos'
+      filenames '*.nix'
+
+      id_boundary = /(?![a-zA-Z0-9_'-])/
+
+      state :whitespaces do
+        rule %r/^\s*\n\s*$/m, Text
+        rule %r/\s+/, Text
+      end
+
+      state :comment do
+        rule %r/#.*$/, Comment
+        rule %r(/\*), Comment, :multiline_comment
+      end
+
+      state :multiline_comment do
+        rule %r(\*/), Comment, :pop!
+        rule %r/./, Comment
+      end
+
+      state :number do
+        rule %r/[0-9]/, Num::Integer
+      end
+
+      state :null do
+        rule %r/null#{id_boundary}/, Keyword::Constant
+      end
+
+      state :boolean do
+        rule %r/(?:true|false)#{id_boundary}/, Keyword::Constant
+      end
+
+      state :binding do
+        rule %r/[a-zA-Z_][a-zA-Z0-9_'-]*/, Name::Variable
+      end
+
+      state :path do
+        word = "[a-zA-Z0-9\._-]+"
+        section = "(\/#{word})"
+        prefix = "[a-z\+]+:\/\/"
+        root = /#{section}+/.source
+        tilde = /~#{section}+/.source
+        basic = /#{word}(\/#{word})+/.source
+        url = /#{prefix}(\/?#{basic})/.source
+        rule %r/(#{root}|#{tilde}|#{basic}|#{url})/, Str::Other
+      end
+
+      state :string do
+        rule %r/"/, Str::Double, :double_quoted_string
+        rule %r/''/, Str::Double, :indented_string
+      end
+
+      state :string_content do
+        rule %r/\\./, Str::Escape
+        rule %r/\$\$/, Str::Escape
+        rule %r/\${/, Str::Interpol, :string_interpolated_arg
+      end
+
+      state :indented_string_content do
+        rule %r/'''/, Str::Escape
+        rule %r/''\$/, Str::Escape
+        rule %r/\$\$/, Str::Escape
+        rule %r/''\\./, Str::Escape
+        rule %r/\${/, Str::Interpol, :string_interpolated_arg
+      end
+
+      state :string_interpolated_arg do
+        mixin :expression
+        rule %r/}/, Str::Interpol, :pop!
+      end
+
+      state :indented_string do
+        mixin :indented_string_content
+        rule %r/''/, Str::Double, :pop!
+        rule %r/./, Str::Double
+      end
+
+      state :double_quoted_string do
+        mixin :string_content
+        rule %r/"/, Str::Double, :pop!
+        rule %r/./, Str::Double
+      end
+
+      state :operator do
+        rule %r/(\.|\?|\+\+|\+|!=|!|\/\/|\=\=|&&|\|\||->|\/|\*|-|<|>|<=|=>)/, Operator
+      end
+
+      state :assignment do
+        rule %r/(=)/, Operator
+        rule %r/(@)/, Operator
+      end
+
+      state :accessor do
+        rule %r/(\$)/, Punctuation
+      end
+
+      state :delimiter do
+        rule %r/(;|,|:)/, Punctuation
+      end
+
+      state :atom_content do
+        mixin :expression
+        rule %r/\)/, Punctuation, :pop!
+      end
+
+      state :atom do
+        rule %r/\(/, Punctuation, :atom_content
+      end
+
+      state :list do
+        rule %r/\[/, Punctuation, :list_content
+      end
+
+      state :list_content do
+        rule %r/\]/, Punctuation, :pop!
+        mixin :expression
+      end
+
+      state :set do
+        rule %r/{/, Punctuation, :set_content
+      end
+
+      state :set_content do
+        rule %r/}/, Punctuation, :pop!
+        mixin :expression
+      end
+
+      state :expression do
+        mixin :ignore
+        mixin :comment
+        mixin :boolean
+        mixin :null
+        mixin :number
+        mixin :path
+        mixin :string
+        mixin :keywords
+        mixin :operator
+        mixin :accessor
+        mixin :assignment
+        mixin :delimiter
+        mixin :binding
+        mixin :atom
+        mixin :set
+        mixin :list
+      end
+
+      state :keywords do
+        mixin :keywords_namespace
+        mixin :keywords_declaration
+        mixin :keywords_conditional
+        mixin :keywords_reserved
+        mixin :keywords_builtin
+      end
+
+      state :keywords_namespace do
+        keywords = %w(with in inherit)
+        rule %r/(?:#{keywords.join('|')})#{id_boundary}/, Keyword::Namespace
+      end
+
+      state :keywords_declaration do
+        keywords = %w(let)
+        rule %r/(?:#{keywords.join('|')})#{id_boundary}/, Keyword::Declaration
+      end
+
+      state :keywords_conditional do
+        keywords = %w(if then else)
+        rule %r/(?:#{keywords.join('|')})#{id_boundary}/, Keyword
+      end
+
+      state :keywords_reserved do
+        keywords = %w(rec assert map)
+        rule %r/(?:#{keywords.join('|')})#{id_boundary}/, Keyword::Reserved
+      end
+
+      state :keywords_builtin do
+        keywords = %w(
+          abort
+          baseNameOf
+          builtins
+          derivation
+          fetchTarball
+          import
+          isNull
+          removeAttrs
+          throw
+          toString
+        )
+        rule %r/(?:#{keywords.join('|')})#{id_boundary}/, Keyword::Reserved
+      end
+
+      state :ignore do
+        mixin :whitespaces
+      end
+
+      state :root do
+        mixin :ignore
+        mixin :expression
+      end
+
+      start do
+      end
+    end
+  end
+end