nano-max-hub 0.0.1

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

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'json'
+
+module Rouge
+  module Lexers
+    class JSONDOC < JSON
+      desc "JavaScript Object Notation with extensions for documentation"
+      tag 'json-doc'
+      aliases 'jsonc'
+
+      prepend :name do
+        rule %r/([$\w]+)(\s*)(:)/ do
+          groups Name::Attribute, Text, Punctuation
+        end
+      end
+
+      prepend :value do
+        rule %r(/[*].*?[*]/), Comment
+        rule %r(//.*?$), Comment::Single
+        rule %r/(\.\.\.)/, Comment::Single
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Jsonnet < RegexLexer
+      title 'Jsonnet'
+      desc 'An elegant, formally-specified config language for JSON'
+      tag 'jsonnet'
+      filenames '*.jsonnet', '*.libsonnet'
+      mimetypes 'text/x-jsonnet'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          self super local for in if then else import importstr error
+          tailstrict assert
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          function
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          null true false
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          acos
+          asin
+          atan
+          ceil
+          char
+          codepoint
+          cos
+          exp
+          exponent
+          filter
+          floor
+          force
+          length
+          log
+          makeArray
+          mantissa
+          objectFields
+          objectHas
+          pow
+          sin
+          sqrt
+          tan
+          thisFile
+          type
+          abs
+          assertEqual
+          escapeStringBash
+          escapeStringDollars
+          escapeStringJson
+          escapeStringPython
+          filterMap
+          flattenArrays
+          foldl
+          foldr
+          format
+          join
+          lines
+          manifestIni
+          manifestPython
+          manifestPythonVars
+          map
+          max
+          min
+          mod
+          range
+          set
+          setDiff
+          setInter
+          setMember
+          setUnion
+          sort
+          split
+          stringChars
+          substr
+          toString
+          uniq
+        )
+      end
+
+      identifier = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      state :root do
+        rule %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(#.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        rule %r/-?(?:0|[1-9]\d*)\.\d+(?:e[+-]\d+)?/i, Num::Float
+        rule %r/-?(?:0|[1-9]\d*)(?:e[+-]\d+)?/i, Num::Integer
+
+        rule %r/[{}:\.,;+\[\]=%\(\)]/, Punctuation
+
+        rule %r/"/, Str, :string_double
+        rule %r/'/, Str, :string_single
+        rule %r/\|\|\|/, Str, :string_block
+
+        rule %r/\$/, Keyword
+
+        rule identifier do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+      end
+
+      state :string do
+        rule %r/\\([\\\/bfnrt]|(u[0-9a-fA-F]{4}))/, Str::Escape
+        rule %r/\\./, Str::Escape
+      end
+
+      state :string_double do
+        mixin :string
+        rule %r/\\"/, Str::Escape
+        rule %r/"/, Str, :pop!
+        rule %r/[^\\"]+/, Str
+      end
+
+      state :string_single do
+        mixin :string
+        rule %r/'/, Str, :pop!
+        rule %r/[^\\']+/, Str
+      end
+
+      state :string_block do
+        mixin :string
+        rule %r/[|][|][|]/, Str, :pop!
+        rule %r/[^|\\]+/, Str
+        rule %r/[|]/, Str
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class JSP < TemplateLexer
+      desc 'JSP'
+      tag 'jsp'
+      filenames '*.jsp'
+      mimetypes 'text/x-jsp', 'application/x-jsp'
+
+      def initialize(*)
+        super
+        @java = Java.new
+      end
+
+      directives = %w(page include taglib)
+      actions = %w(scriptlet declaration expression)
+
+      state :root do
+
+        rule %r/<%--/, Comment, :jsp_comment
+
+        rule %r/<%@\s*(#{directives.join('|')})\s*/, Name::Tag, :jsp_directive
+
+        rule %r/<jsp:directive\.(#{directives.join('|')})/, Name::Tag, :jsp_directive2
+
+        rule %r/<jsp:(#{actions.join('|')})>/, Name::Tag, :jsp_expression
+
+        # start of tag, e.g. <c:if>
+        rule %r/<[a-zA-Z]*:[a-zA-Z]*\s*/, Name::Tag, :jsp_tag
+
+        # end of tag, e.g. </c:if>
+        rule %r(</[a-zA-Z]*:[a-zA-Z]*>), Name::Tag
+
+        rule %r/<%[!=]?/, Name::Tag, :jsp_expression2
+
+        # fallback to HTML
+        rule(/(.+?)(?=(<%|<\/?[a-zA-Z]*:))/m) { delegate parent }
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :jsp_comment do
+        rule %r/(--%>)/, Comment, :pop!
+        rule %r/./m, Comment
+      end
+
+      state :jsp_directive do
+        rule %r/(%>)/, Name::Tag, :pop!
+        mixin :attributes
+        rule(/(.+?)(?=%>)/m) { delegate parent }
+      end
+
+      state :jsp_directive2 do
+        rule %r!(/>)!, Name::Tag, :pop!
+        mixin :attributes
+        rule(/(.+?)(?=\/>)/m) { delegate parent }
+      end
+
+      state :jsp_expression do
+        rule %r/<\/jsp:(#{actions.join('|')})>/, Name::Tag, :pop!
+        mixin :attributes
+        rule(/[^<\/]+/) { delegate @java }
+      end
+
+      state :jsp_expression2 do
+        rule %r/%>/, Name::Tag, :pop!
+        rule(/[^%>]+/) { delegate @java }
+      end
+
+      state :jsp_tag do
+        rule %r/\/?>/, Name::Tag, :pop!
+        mixin :attributes
+        rule(/(.+?)(?=\/?>)/m) { delegate parent }
+      end
+
+      state :attributes do
+        rule %r/\s*[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
+      end
+
+      state :attr do
+        rule %r/"/ do
+          token Str
+          goto :double_quotes
+        end
+
+        rule %r/'/ do
+          token Str
+          goto :single_quotes
+        end
+
+        rule %r/[^\s>]+/, Str, :pop!
+      end
+
+      state :double_quotes do
+        rule %r/"/, Str, :pop!
+        rule %r/\$\{/, Str::Interpol, :jsp_interp
+        rule %r/[^"]+/, Str
+      end
+
+      state :single_quotes do
+        rule %r/'/, Str, :pop!
+        rule %r/\$\{/, Str::Interpol, :jsp_interp
+        rule %r/[^']+/, Str
+      end
+
+      state :jsp_interp do
+        rule %r/\}/, Str::Interpol, :pop!
+        rule %r/'/, Literal, :jsp_interp_literal_start
+        rule(/[^'\}]+/) { delegate @java }
+      end
+
+      state :jsp_interp_literal_start do
+        rule %r/'/, Literal, :pop!
+        rule %r/[^']+/, Literal
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'javascript'
+
+module Rouge
+  module Lexers
+    class JSX < Javascript
+      title 'JSX'
+      desc 'An XML-like syntax extension to JavaScript (facebook.github.io/jsx/)'
+      tag 'jsx'
+      aliases 'jsx', 'react'
+      filenames '*.jsx'
+
+      mimetypes 'text/x-jsx', 'application/x-jsx'
+
+      start { @html = HTML.new(options); push :expr_start }
+
+      prepend :expr_start do
+        mixin :tag
+      end
+
+      state :tag do
+        rule %r/</ do
+          token Punctuation
+          push :tag_opening
+          push :element
+          push :element_name
+        end
+      end
+
+      state :tag_opening do
+        rule %r/<\// do
+          token Punctuation
+          goto :element
+          push :element_name
+        end
+        mixin :tag
+        rule %r/{/ do
+          token Str::Interpol
+          push :interpol
+          push :expr_start
+        end
+        rule %r/[^<{]+/ do
+          delegate @html
+        end
+      end
+
+      state :element do
+        mixin :comments_and_whitespace
+        rule %r/\/>/ do
+          token Punctuation
+          pop! 2
+        end
+        rule %r/>/, Punctuation, :pop!
+        rule %r/{/ do
+          token Str::Interpol
+          push :interpol
+          push :expr_start
+        end
+        rule %r/\w[\w-]*/, Name::Attribute
+        rule %r/=/, Punctuation
+        rule %r/(["']).*?(\1)/, Str
+      end
+
+      state :element_name do
+        rule %r/[A-Z]\w*/, Name::Class
+        rule %r/\w+/, Name::Tag
+        rule %r/\./, Punctuation
+        rule(//) { pop! }
+      end
+
+      state :interpol do
+        rule %r/}/, Str::Interpol, :pop!
+        rule %r/{/ do
+          token Punctuation
+          push :interpol_inner
+          push :statement
+        end
+        mixin :root
+      end
+
+      state :interpol_inner do
+        rule %r/}/ do
+          token Punctuation
+          goto :statement
+        end
+        mixin :root
+      end
+    end
+  end
+end

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

@@ -0,0 +1,293 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Julia < RegexLexer
+      title "Julia"
+      desc "The Julia programming language"
+      tag 'julia'
+      aliases 'jl'
+      filenames '*.jl'
+      mimetypes 'text/x-julia', 'application/x-julia'
+
+      # Documentation: https://docs.julialang.org/en/v1/manual/variables/#Allowed-Variable-Names-1
+
+      def self.detect?(text)
+        return true if text.shebang? 'julia'
+      end
+
+      BUILTINS            = /\b(?:
+                              true      | false    | missing | nothing
+                            | Inf       | Inf16    | Inf32   | Inf64
+                            | NaN       | NaN16    | NaN32   | NaN64
+                            | stdout    | stderr   | stdin   | devnull
+                            | pi        | π        | ℯ       | im
+                            | ARGS      | C_NULL   | ENV     | ENDIAN_BOM
+                            | VERSION   | undef    | (LOAD|DEPOT)_PATH
+                            )\b/x
+
+      KEYWORDS            = /\b(?:
+                              function | return | module | import | export
+                            | if       | else   | elseif | end    | for
+                            | in       | isa    | while  | try    | catch
+                            | const    | local  | global | using  | struct
+                            | mutable struct    | abstract type   | finally
+                            | begin    | do     | quote  | macro  | for outer
+                            | where
+                            )\b/x
+
+      # NOTE: The list of types was generated automatically using the following script:
+      # using Pkg, InteractiveUtils
+      #
+      # allnames = [names(Core); names(Base, imported=true)]
+      #
+      # for stdlib in readdir(Pkg.Types.stdlib_dir())
+      #     mod = Symbol(basename(stdlib))
+      #     @eval begin
+      #         using $mod
+      #         append!(allnames, names($mod))
+      #     end
+      # end
+      #
+      # sort!(unique!(allnames))
+      #
+      # i = 1
+      # for sym in allnames
+      #     global i # needed at the top level, e.g. in the REPL
+      #     isdefined(Main, sym) || continue
+      #     getfield(which(Main, sym), sym) isa Type || continue
+      #     sym === :(=>) && continue # Actually an alias for Pair
+      #     print("| ", sym)
+      #     i % 3 == 0 ? println() : print(" ") # print 3 to a line
+      #     i += 1
+      # end
+      TYPES               = /\b(?:
+                              ARPACKException | AbstractArray | AbstractChannel
+                            | AbstractChar | AbstractDict | AbstractDisplay
+                            | AbstractFloat | AbstractIrrational | AbstractLogger
+                            | AbstractMatrix | AbstractREPL | AbstractRNG
+                            | AbstractRange | AbstractSerializer | AbstractSet
+                            | AbstractSparseArray | AbstractSparseMatrix | AbstractSparseVector
+                            | AbstractString | AbstractUnitRange | AbstractVecOrMat
+                            | AbstractVector | AbstractWorkerPool | Adjoint
+                            | Any | ArgumentError | Array
+                            | AssertionError | Base64DecodePipe | Base64EncodePipe
+                            | BasicREPL | Bidiagonal | BigFloat
+                            | BigInt | BitArray | BitMatrix
+                            | BitSet | BitVector | Bool
+                            | BoundsError | BunchKaufman | CachingPool
+                            | CapturedException | CartesianIndex | CartesianIndices
+                            | Cchar | Cdouble | Cfloat
+                            | Channel | Char | Cholesky
+                            | CholeskyPivoted | Cint | Cintmax_t
+                            | Clong | Clonglong | ClusterManager
+                            | Cmd | Colon | Complex
+                            | ComplexF16 | ComplexF32 | ComplexF64
+                            | CompositeException | Condition | ConsoleLogger
+                            | Cptrdiff_t | Cshort | Csize_t
+                            | Cssize_t | Cstring | Cuchar
+                            | Cuint | Cuintmax_t | Culong
+                            | Culonglong | Cushort | Cvoid
+                            | Cwchar_t | Cwstring | DataType
+                            | Date | DateFormat | DatePeriod
+                            | DateTime | Day | DenseArray
+                            | DenseMatrix | DenseVecOrMat | DenseVector
+                            | Diagonal | Dict | DimensionMismatch
+                            | Dims | DivideError | DomainError
+                            | EOFError | Eigen | Enum
+                            | ErrorException | Exception | ExponentialBackOff
+                            | Expr | FDWatcher | Factorization
+                            | FileMonitor | Float16 | Float32
+                            | Float64 | FolderMonitor | Function
+                            | GeneralizedEigen | GeneralizedSVD | GeneralizedSchur
+                            | GenericArray | GenericDict | GenericSet
+                            | GenericString | GitConfig | GitRepo
+                            | GlobalRef | HMAC_CTX | HTML
+                            | Hermitian | Hessenberg | Hour
+                            | IO | IOBuffer | IOContext
+                            | IOStream | IPAddr | IPv4
+                            | IPv6 | IdDict | IndexCartesian
+                            | IndexLinear | IndexStyle | InexactError
+                            | InitError | Int | Int128
+                            | Int16 | Int32 | Int64
+                            | Int8 | Integer | InterruptException
+                            | InvalidStateException | Irrational | KeyError
+                            | LAPACKException | LDLt | LQ
+                            | LU | LinRange | LineEditREPL
+                            | LineNumberNode | LinearIndices | LoadError
+                            | LogLevel | LowerTriangular | MIME
+                            | Matrix | MersenneTwister | Method
+                            | MethodError | Microsecond | Millisecond
+                            | Minute | Missing | MissingException
+                            | Module | Month | NTuple
+                            | NamedTuple | Nanosecond | Nothing
+                            | NullLogger | Number | OrdinalRange
+                            | OutOfMemoryError | OverflowError | PackageMode
+                            | PackageSpec | Pair | PartialQuickSort
+                            | Period | PermutedDimsArray | Pipe
+                            | PollingFileWatcher | PosDefException | ProcessExitedException
+                            | Ptr | QR | QRPivoted
+                            | QuoteNode | RandomDevice | RankDeficientException
+                            | Rational | RawFD | ReadOnlyMemoryError
+                            | Real | ReentrantLock | Ref
+                            | Regex | RegexMatch | RemoteChannel
+                            | RemoteException | RoundingMode | SHA1_CTX
+                            | SHA224_CTX | SHA256_CTX | SHA2_224_CTX
+                            | SHA2_256_CTX | SHA2_384_CTX | SHA2_512_CTX
+                            | SHA384_CTX | SHA3_224_CTX | SHA3_256_CTX
+                            | SHA3_384_CTX | SHA3_512_CTX | SHA512_CTX
+                            | SVD | Schur | Second
+                            | SegmentationFault | Serializer | Set
+                            | SharedArray | SharedMatrix | SharedVector
+                            | Signed | SimpleLogger | SingularException
+                            | Some | SparseMatrixCSC | SparseVector
+                            | StackOverflowError | StepRange | StepRangeLen
+                            | StreamREPL | StridedArray | StridedMatrix
+                            | StridedVecOrMat | StridedVector | String
+                            | StringIndexError | SubArray | SubString
+                            | SubstitutionString | SymTridiagonal | Symbol
+                            | Symmetric | SystemError | TCPSocket
+                            | Task | TestSetException | Text
+                            | TextDisplay | Time | TimePeriod
+                            | TimeType | TimeZone | Timer
+                            | Transpose | Tridiagonal | Tuple
+                            | Type | TypeError | TypeVar
+                            | UDPSocket | UInt | UInt128
+                            | UInt16 | UInt32 | UInt64
+                            | UInt8 | UTC | UUID
+                            | UndefInitializer | UndefKeywordError | UndefRefError
+                            | UndefVarError | UniformScaling | Union
+                            | UnionAll | UnitLowerTriangular | UnitRange
+                            | UnitUpperTriangular | Unsigned | UpgradeLevel
+                            | UpperTriangular | Val | Vararg
+                            | VecElement | VecOrMat | Vector
+                            | VersionNumber | WeakKeyDict | WeakRef
+                            | Week | WorkerConfig | WorkerPool
+                            | Year
+                            )\b/x
+
+      OPERATORS           = / \+      | =        | -     | \*   | \/
+                              | \\    | &        | \|    | \$   | ~
+                              | \^    | %        | !     | >>>  | >>
+                              | <<    | &&       | \|\|  | \+=  | -=
+                              | \*=   | \/=      | \\=   | ÷=   | %=
+                              | \^=   | &=       | \|=   | \$=  | >>>=
+                              | >>=   | <<=      | ==    | !=   | ≠
+                              | <=    | ≤        | >=    | ≥    | \.
+                              | ::    | <:       | ->    | \?   | \.\*
+                              | \.\^  | \.\\     | \.\/  | \\   | <
+                              | >     | ÷        | >:    | :    | ===
+                              | !==   | =>
+                            /x
+
+      PUNCTUATION         = /[\[\]{}\(\),;]/
+
+
+      state :root do
+        rule %r/\n/, Text
+        rule %r/[^\S\n]+/, Text
+        rule %r/#=/, Comment::Multiline, :blockcomment
+        rule %r/#.*$/, Comment
+        rule OPERATORS, Operator
+        rule %r/\\\n/, Text
+        rule %r/\\/, Text
+
+
+        # functions and macros
+        rule %r/(function|macro)((?:\s|\\\s)+)/ do
+          groups Keyword, Name::Function
+          push :funcname
+        end
+
+        # types
+        rule %r/((?:mutable )?struct|(?:abstract|primitive) type)((?:\s|\\\s)+)/ do
+          groups Keyword, Name::Class
+          push :typename
+        end
+        rule TYPES, Keyword::Type
+
+        # keywords
+        rule %r/(local|global|const)\b/, Keyword::Declaration
+        rule KEYWORDS, Keyword
+
+        # TODO: end is a builtin when inside of an indexing expression
+        rule BUILTINS, Name::Builtin
+
+        # TODO: symbols
+
+        # backticks
+        rule %r/`.*?`/, Literal::String::Backtick
+
+        # chars
+        rule %r/'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'/, Literal::String::Char
+
+        # try to match trailing transpose
+        rule %r/(?<=[.\w)\]])\'+/, Operator
+
+        # strings
+        # TODO: triple quoted string literals
+        # TODO: Detect string interpolation
+        rule %r/(?:[IL])"/, Literal::String, :string
+        rule %r/[E]?"/, Literal::String, :string
+
+        # names
+        rule %r/@[\w.]+/, Name::Decorator
+        rule %r/(?:[a-zA-Z_\u00A1-\uffff]|[\u1000-\u10ff])(?:[a-zA-Z_0-9\u00A1-\uffff]|[\u1000-\u10ff])*!*/, Name
+
+        rule PUNCTUATION, Other
+
+        # numbers
+        rule %r/(\d+(_\d+)+\.\d*|\d*\.\d+(_\d+)+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule %r/(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule %r/\d+(_\d+)+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule %r/\d+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule %r/0b[01]+(_[01]+)+/, Literal::Number::Bin
+        rule %r/0b[01]+/, Literal::Number::Bin
+        rule %r/0o[0-7]+(_[0-7]+)+/, Literal::Number::Oct
+        rule %r/0o[0-7]+/, Literal::Number::Oct
+        rule %r/0x[a-fA-F0-9]+(_[a-fA-F0-9]+)+/, Literal::Number::Hex
+        rule %r/0x[a-fA-F0-9]+/, Literal::Number::Hex
+        rule %r/\d+(_\d+)+/, Literal::Number::Integer
+        rule %r/\d+/, Literal::Number::Integer
+      end
+
+      NAME_RE = %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/
+
+      state :funcname do
+        rule NAME_RE, Name::Function, :pop!
+        rule %r/\([^\s\w{]{1,2}\)/, Operator, :pop!
+        rule %r/[^\s\w{]{1,2}/, Operator, :pop!
+      end
+
+      state :typename do
+        rule NAME_RE, Name::Class, :pop!
+      end
+
+      state :stringescape do
+        rule %r/\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})/,
+          Literal::String::Escape
+      end
+
+      state :blockcomment do
+        rule %r/[^=#]/, Comment::Multiline
+        rule %r/#=/, Comment::Multiline, :blockcomment
+        rule %r/\=#/, Comment::Multiline, :pop!
+        rule %r/[=#]/, Comment::Multiline
+      end
+
+      state :string do
+        mixin :stringescape
+
+        rule %r/"/, Literal::String, :pop!
+        rule %r/\\\\|\\"|\\\n/, Literal::String::Escape  # included here for raw strings
+        rule %r/\$(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/, Literal::String::Interpol
+        rule %r/[^\\"$]+/, Literal::String
+        # quotes, dollar signs, and backslashes must be parsed one at a time
+        rule %r/["\\]/, Literal::String
+        # unhandled string formatting sign
+        rule %r/\$/, Literal::String
+      end
+    end
+  end
+end