nano-max-hub 0.0.1

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

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Protobuf < RegexLexer
+      title 'Protobuf'
+      desc 'Google\'s language-neutral, platform-neutral, extensible mechanism for serializing structured data'
+      tag 'protobuf'
+      aliases 'proto'
+      filenames '*.proto'
+      mimetypes 'text/x-proto'
+
+      kw = /\b(ctype|default|extensions|import|max|oneof|option|optional|packed|repeated|required|returns|rpc|to)\b/
+      datatype = /\b(bool|bytes|double|fixed32|fixed64|float|int32|int64|sfixed32|sfixed64|sint32|sint64|string|uint32|uint64)\b/
+
+      state :root do
+        rule %r/[\s]+/, Text
+        rule %r/[,;{}\[\]()]/, Punctuation
+        rule %r/\/(\\\n)?\/($|(.|\n)*?[^\\]$)/, Comment::Single
+        rule %r/\/(\\\n)?\*(.|\n)*?\*(\\\n)?\//, Comment::Multiline
+        rule kw, Keyword
+        rule datatype, Keyword::Type
+        rule %r/true|false/, Keyword::Constant
+        rule %r/(package)(\s+)/ do
+          groups Keyword::Namespace, Text
+          push :package
+        end
+
+        rule %r/(message|extend)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :message
+        end
+
+        rule %r/(enum|group|service)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :type
+        end
+
+        rule %r/".*?"/, Str
+        rule %r/'.*?'/, Str
+        rule %r/(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*/, Num::Float
+        rule %r/(\d+\.\d*|\.\d+|\d+[fF])[fF]?/, Num::Float
+        rule %r/(\-?(inf|nan))\b/, Num::Float
+        rule %r/0x[0-9a-fA-F]+[LlUu]*/, Num::Hex
+        rule %r/0[0-7]+[LlUu]*/, Num::Oct
+        rule %r/\d+[LlUu]*/, Num::Integer
+        rule %r/[+-=]/, Operator
+        rule %r/([a-zA-Z_][\w.]*)([ \t]*)(=)/ do
+          groups Name::Attribute, Text, Operator
+        end
+        rule %r/[a-zA-Z_][\w.]*/, Name
+      end
+
+      state :package do
+        rule %r/[a-zA-Z_]\w*/, Name::Namespace, :pop!
+        rule(//) { pop! }
+      end
+
+      state :message do
+        rule %r/[a-zA-Z_]\w*/, Name::Class, :pop!
+        rule(//) { pop! }
+      end
+
+      state :type do
+        rule %r/[a-zA-Z_]\w*/, Name, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Puppet < RegexLexer
+      title "Puppet"
+      desc 'The Puppet configuration management language (puppetlabs.org)'
+      tag 'puppet'
+      aliases 'pp'
+      filenames '*.pp'
+
+      def self.detect?(text)
+        return true if text.shebang? 'puppet-apply'
+        return true if text.shebang? 'puppet'
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          and case class default define else elsif if in import inherits
+          node unless
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          false true undef
+        )
+      end
+
+      def self.metaparameters
+        @metaparameters ||= Set.new %w(
+          before require notify subscribe
+        )
+      end
+
+      id = /[a-z]\w*/
+      cap_id = /[A-Z]\w*/
+      qualname = /(::)?(#{id}::)*\w+/
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r/#.*?\n/, Comment
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/[$]#{qualname}/, Name::Variable
+        rule %r/(#{id})(?=\s*[=+]>)/m do |m|
+          if self.class.metaparameters.include? m[0]
+            token Keyword::Pseudo
+          else
+            token Name::Property
+          end
+        end
+
+        rule %r/(#{qualname})(?=\s*[(])/m, Name::Function
+        rule cap_id, Name::Class
+
+        rule %r/[+=|~-]>|<[|~-]/, Punctuation
+        rule %r/[|:}();\[\]]/, Punctuation
+
+        # HACK for case statements and selectors
+        rule %r/{/, Punctuation, :regex_allowed
+        rule %r/,/, Punctuation, :regex_allowed
+
+        rule %r/(in|and|or)\b/, Operator::Word
+        rule %r/[=!<>]=/, Operator
+        rule %r/[=!]~/, Operator, :regex_allowed
+        rule %r([.=<>!+*/-]), Operator
+
+        rule %r/(class|include)(\s*)(#{qualname})/ do
+          groups Keyword, Text, Name::Class
+        end
+
+        rule %r/node\b/, Keyword, :regex_allowed
+
+        rule %r/'(\\[\\']|[^'])*'/m, Str::Single
+        rule %r/"/, Str::Double, :dquotes
+
+        rule %r/\d+([.]\d+)?(e[+-]\d+)?/, Num
+
+        # a valid regex.  TODO: regexes are only allowed
+        # in certain places in puppet.
+        rule qualname do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          else
+            token Name
+          end
+        end
+      end
+
+      state :regex_allowed do
+        mixin :whitespace
+        rule %r(/), Str::Regex, :regex
+
+        rule(//) { pop! }
+      end
+
+      state :regex do
+        rule %r(/), Str::Regex, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/[(){}]/, Str::Interpol
+        rule %r/\[/, Str::Interpol, :regex_class
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_class do
+        rule %r/\]/, Str::Interpol, :pop!
+        rule %r/(?<!\[)-(?=\])/, Str::Regex
+        rule %r/-/, Str::Interpol
+        rule %r/\\./, Str::Escape
+        rule %r/[^\\\]-]+/, Str::Regex
+      end
+
+      state :dquotes do
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^$\\"]+/m, Str::Double
+        rule %r/\\./m, Str::Escape
+        rule %r/[$]#{qualname}/, Name::Variable
+        rule %r/[$][{]#{qualname}[}]/, Name::Variable
+      end
+    end
+  end
+end

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

@@ -0,0 +1,340 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Python < RegexLexer
+      title "Python"
+      desc "The Python programming language (python.org)"
+      tag 'python'
+      aliases 'py'
+      filenames '*.py', '*.pyi', '*.pyw', '*.sc', 'SConstruct', 'SConscript',
+                '*.tac', '*.bzl', 'BUCK', 'BUILD', 'BUILD.bazel', 'WORKSPACE'
+      mimetypes 'text/x-python', 'application/x-python'
+
+      def self.detect?(text)
+        return true if text.shebang?(/pythonw?(?:[23](?:\.\d+)?)?/)
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          assert break continue del elif else except exec
+          finally for global if lambda pass print raise
+          return try while yield as with from import
+          async await nonlocal
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          __import__ abs aiter all anext any apply ascii
+          basestring bin bool buffer breakpoint bytearray bytes
+          callable chr classmethod cmp coerce compile complex
+          delattr dict dir divmod enumerate eval exec execfile exit
+          file filter float format frozenset getattr globals
+          hasattr hash help hex
+          id input int intern isinstance issubclass iter len list locals long
+          map max memoryview min next object oct open ord pow print property
+          range raw_input reduce reload repr reversed round set setattr slice
+          sorted staticmethod str sum super tuple type unichr unicode vars
+          xrange zip
+        )
+      end
+
+      def self.builtins_pseudo
+        @builtins_pseudo ||= Set.new %w(None Ellipsis NotImplemented False True)
+      end
+
+      def self.exceptions
+        @exceptions ||= Set.new %w(
+          ArithmeticError AssertionError AttributeError BaseException
+          BaseExceptionGroup BlockingIOError BrokenPipeError BufferError
+          BytesWarning ChildProcessError ConnectionAbortedError ConnectionError
+          ConnectionRefusedError ConnectionResetError DeprecationWarning
+          EOFError EnvironmentError EncodingWarning Exception ExceptionGroup
+          FileExistsError FileNotFoundError FloatingPointError FutureWarning
+          GeneratorExit IOError ImportError ImportWarning IndentationError
+          IndexError InterruptedError IsADirectoryError
+          KeyError KeyboardInterrupt LookupError
+          MemoryError ModuleNotFoundError
+          NameError NotADirectoryError NotImplemented NotImplementedError
+          OSError OverflowError OverflowWarning PendingDeprecationWarning
+          PermissionError ProcessLookupError PythonFinalizationError
+          RecursionError ReferenceError ResourceWarning RuntimeError RuntimeWarning
+          StandardError StopAsyncIteration StopIteration SyntaxError SyntaxWarning
+          SystemError SystemExit TabError TimeoutError TypeError
+          UnboundLocalError UnicodeDecodeError UnicodeEncodeError UnicodeError
+          UnicodeTranslateError UnicodeWarning UserWarning ValueError VMSError
+          Warning WindowsError
+          ZeroDivisionError
+        )
+      end
+
+      identifier =        /[[:alpha:]_][[:alnum:]_]*/
+      dotted_identifier = /[[:alpha:]_.][[:alnum:]_.]*/
+      inline_ws = /(?:[ \t]|\\\n)*?/
+      inline_content = /(?:[^\\\n]|\\[\n.])*?/
+
+      def current_string
+        @current_string ||= StringRegister.new
+      end
+
+      operator_words = %r/(in|is|and|or|not)\b/
+      operators = %r{(<<|>>|//|[*][*])=?|!=|[-~+\/*%=<>&^|@]=?|!=}
+
+      start do
+        push :newline
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t]+/, Text
+        rule %r/\\\n/, Str::Escape
+      end
+
+      state :root do
+        rule %r/\n+/m, Text, :newline
+        rule %r/^(:)(\s*)([ru]{,2}""".*?""")/mi do
+          groups Punctuation, Text, Str::Doc
+        end
+
+        rule %r/\.\.\.\B$/, Name::Builtin::Pseudo
+
+        mixin :inline_whitespace
+
+        rule %r(#(.*)?\n?), Comment::Single, :newline
+        rule %r/[\[\]{}:(),;]/, Punctuation
+        rule %r/[.]/, Punctuation, :post_dot
+        rule %r/\\/, Str::Escape
+
+        rule %r/@#{dotted_identifier}/i, Name::Decorator
+
+        rule operator_words, Operator::Word
+        rule operators, Operator
+
+        rule %r/def\b/, Keyword, :funcname
+
+        rule %r/class\b/, Keyword, :classname
+
+        rule %r/`.*?`/, Str::Backtick
+        rule %r/([rtfbu]{0,2})('''|"""|['"])/i do |m|
+          groups Str::Affix, Str::Heredoc
+          current_string.register type: m[1].downcase, delim: m[2]
+          push :generic_string
+        end
+
+        # using negative lookbehind so we don't match property names
+        rule %r/(?<!\.)#{identifier}/ do |m|
+          if self.class.keywords.include?(m[0])
+            token Keyword
+          elsif self.class.exceptions.include?(m[0])
+            token Name::Exception
+          elsif self.class.builtins.include?(m[0])
+            token Name::Builtin
+          elsif self.class.builtins_pseudo.include?(m[0])
+            token Name::Builtin::Pseudo
+          else
+            token Name
+          end
+        end
+
+        rule identifier, Name
+
+        digits = /[0-9](_?[0-9])*/
+        decimal = /((#{digits})?\.#{digits}|#{digits}\.)/
+        exponent = /e[+-]?#{digits}/i
+        rule %r/#{decimal}(#{exponent})?j?/i, Num::Float
+        rule %r/#{digits}#{exponent}j?/i, Num::Float
+        rule %r/#{digits}j/i, Num::Float
+
+        rule %r/0b(_?[0-1])+/i, Num::Bin
+        rule %r/0o(_?[0-7])+/i, Num::Oct
+        rule %r/0x(_?[a-f0-9])+/i, Num::Hex
+        rule %r/\d+L/, Num::Integer::Long
+        rule %r/([1-9](_?[0-9])*|0(_?0)*)/, Num::Integer
+      end
+
+      state :import do
+        mixin :inline_whitespace
+        rule dotted_identifier, Name::Namespace, :pop!
+        rule(//) { pop! }
+      end
+
+      state :from do
+        mixin :inline_whitespace
+
+        rule dotted_identifier do
+          token Name::Namespace
+          goto :from_import
+        end
+
+        rule(//) { pop! }
+      end
+
+      # import after from, meaning we don't push the :import state
+      state :from_import do
+        mixin :inline_whitespace
+        rule %r/import\b/, Keyword::Namespace, :pop!
+        rule(//) { pop! }
+      end
+
+      state :post_dot do
+        mixin :inline_whitespace
+        rule %r/([A-Z]\w*)(?=#{inline_ws}[(])/m, Name::Class
+        rule %r/(#{identifier})(?=#{inline_ws}[(])/m, Name::Function
+        rule(//) { pop! }
+      end
+
+      state :newline do
+        mixin :inline_whitespace
+
+        rule %r/from\b/, Keyword::Namespace, :from
+        rule %r/import\b/, Keyword::Namespace, :import
+
+        # [jneen] This lookahead is a best-effort hack, since soft keywords are
+        # technically not possible to detect in the lexing stage. If we see an
+        # operator like `and`, `or`, inline `if`, etc which would expect an
+        # expression beforehand, we know that it is almost certainly not a keyword.
+        inline_ops = /#{operator_words}|if\b|#{operators}/
+        rule %r/(?:case|match)(?=#{inline_ws}#{inline_ops})/, Name::Other, :pop!
+
+        rule %r/(?:case|match)(?=#{inline_content}:#{inline_ws}[#\n])/ do |m|
+          token Keyword
+          if m[0] == 'case'
+            goto :case_pattern
+          else
+            pop!
+          end
+        end
+
+        rule(//) { pop! }
+      end
+
+      state :funcname do
+        mixin :inline_whitespace
+        rule identifier, Name::Function, :pop!
+      end
+
+      state :classname do
+        mixin :inline_whitespace
+        rule identifier, Name::Class, :pop!
+      end
+
+      state :case_pattern do
+        rule %r/\n/ do
+          token Text
+          goto :newline
+        end
+
+        rule %r/_\b/, Keyword
+        mixin :root
+      end
+
+      state :raise do
+        rule %r/from\b/, Keyword
+        rule %r/raise\b/, Keyword
+        rule %r/yield\b/, Keyword
+        rule %r/\n/, Text, :pop!
+        rule %r/;/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :yield do
+        mixin :raise
+      end
+
+      state :generic_string do
+        rule %r/\n/, Str, :generic_string_newline
+        rule %r/[^'"\\{\n]+/, Str
+        rule %r/{{/, Str
+
+        rule %r/'''|"""|['"]/ do |m|
+          token Str::Heredoc
+          if current_string.delim? m[0]
+            current_string.remove
+            pop!
+          end
+        end
+
+        rule %r/(?=\\)/, Str, :generic_escape
+
+        rule %r/{/ do |m|
+          if current_string.type? "f"
+            token Str::Interpol
+            push :generic_interpol
+          else
+            token Str
+          end
+        end
+      end
+
+      state :generic_string_newline do
+        rule %r/[ \t]+/, Str
+        rule %r/(>>>|\.\.\.)\B/ do
+          token Generic::Prompt
+          goto :doctest
+        end
+        rule(//) { pop! }
+      end
+
+      state :generic_escape do
+        rule %r(\\
+          ( [\\abfnrtv"']
+          | \n
+          | newline
+          | N{[a-zA-Z][a-zA-Z ]+[a-zA-Z]}
+          | u[a-fA-F0-9]{4}
+          | U[a-fA-F0-9]{8}
+          | x[a-fA-F0-9]{2}
+          | [0-7]{1,3}
+          )
+        )x do
+          current_string.type?("r") ? token(Str) : token(Str::Escape)
+          pop!
+        end
+
+        rule %r/\\./, Str, :pop!
+      end
+
+      state :doctest do
+        rule %r/\n\n/, Text, :pop!
+
+        rule %r/'''|"""/ do
+          token Str::Heredoc
+          pop!(2) if in_state?(:generic_string) # pop :doctest and :generic_string
+        end
+
+        mixin :root
+      end
+
+      state :generic_interpol do
+        rule %r/[^{}!:]+/ do |m|
+          recurse m[0]
+        end
+        rule %r/![asr]/, Str::Interpol
+        rule %r/:/, Str::Interpol
+        rule %r/{/, Str::Interpol, :generic_interpol
+        rule %r/}/, Str::Interpol, :pop!
+      end
+
+      class StringRegister < Array
+        def delim?(delim)
+          self.last[1] == delim
+        end
+
+        def register(type: "u", delim: "'")
+          self.push [type, delim]
+        end
+
+        def remove
+          self.pop
+        end
+
+        def type?(type)
+          self.last[0].include? type
+        end
+      end
+
+      private_constant :StringRegister
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Q < RegexLexer
+      title 'Q'
+      desc 'The Q programming language (kx.com)'
+      tag 'q'
+      aliases 'kdb+'
+      filenames '*.q'
+      mimetypes 'text/x-q', 'application/x-q'
+
+      identifier = /\.?[a-z][a-z0-9_.]*/i
+
+      def self.keywords
+        @keywords ||= %w[do if while select update delete exec from by]
+      end
+
+      def self.word_operators
+        @word_operators ||= %w[
+          and or except inter like each cross vs sv within where in asof bin binr cor cov cut ej fby
+          div ij insert lj ljf mavg mcount mdev mmax mmin mmu mod msum over prior peach pj scan scov setenv ss
+          sublist uj union upsert wavg wsum xasc xbar xcol xcols xdesc xexp xgroup xkey xlog xprev xrank
+        ]
+      end
+
+      def self.builtins
+        @builtins ||= %w[
+          first enlist value type get set count string key max min sum prd last flip distinct raze neg
+          desc differ dsave dev eval exit exp fills fkeys floor getenv group gtime hclose hcount hdel hopen hsym
+          iasc idesc inv keys load log lsq ltime ltrim maxs md5 med meta mins next parse plist prds prev rand rank ratios
+          read0 read1 reciprocal reverse rload rotate rsave rtrim save sdev show signum sin sqrt ssr sums svar system
+          tables tan til trim txf ungroup var view views wj wj1 ww
+        ]
+      end
+
+      state :root do
+        # q allows a file to start with a shebang
+        rule %r/#!(.*?)$/, Comment::Preproc, :top
+        rule %r//, Text, :top
+      end
+
+      state :top do
+        # indented lines at the top of the file are ignored by q
+        rule %r/^[ \t\r]+.*$/, Comment::Special
+        rule %r/\n+/, Text
+        rule %r//, Text, :base
+      end
+
+      state :base do
+        rule %r/\n+/m, Text
+        rule(/^.\)/, Keyword::Declaration)
+
+        # Identifiers, word operators, etc.
+        rule %r/#{identifier}/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.word_operators.include? m[0]
+            token Operator::Word
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif /^\.[zQqho]\./ =~ m[0]
+            token Name::Constant
+          else
+            token Name
+          end
+        end
+
+        # White space and comments
+        rule(%r{\s+/.*}, Comment::Single)
+        rule(/[ \t\r]+/, Text::Whitespace)
+        rule(%r{^/$.*?^\\$}m, Comment::Multiline)
+        rule(%r{^\/[^\n]*$(\n[^\S\n]+.*$)*}, Comment::Multiline)
+        # til EOF comment
+        rule(/^\\$/, Comment, :bottom)
+        rule(/^\\\\\s+/, Keyword, :bottom)
+
+        # Literals
+        ## strings
+        rule(/"/, Str, :string)
+        ## timespan/stamp constants
+        rule(/(?:\d+D|\d{4}\.[01]\d\.[0123]\d[DT])(?:[012]\d:[0-5]\d(?::[0-5]\d(?:\.\d+)?)?|([012]\d)?)[zpn]?\b/,
+             Literal::Date)
+        ## time/minute/second constants
+        rule(/[012]\d:[0-5]\d(?::[0-5]\d(\.\d+)?)?[uvtpn]?\b/, Literal::Date)
+        ## date constants
+        rule(/\d{4}\.[01]\d\.[0-3]\d[dpnzm]?\b/, Literal::Date)
+        ## special values
+        rule(/0[nNwW][hijefcpmdznuvt]?/, Keyword::Constant)
+
+        # operators to match before numbers
+        rule(%r{'|\/:|\\:|':|\\|\/|0:|1:|2:}, Operator)
+
+        ## numbers
+        rule(/(\d+[.]\d*|[.]\d+)(e[+-]?\d+)?[ef]?/, Num::Float)
+        rule(/\d+e[+-]?\d+[ef]?/, Num::Float)
+        rule(/\d+[ef]/, Num::Float)
+        rule(/0x[0-9a-f]+/i, Num::Hex)
+        rule(/[01]+b/, Num::Bin)
+        rule(/[0-9]+[hij]?/, Num::Integer)
+        ## symbols and paths
+        rule(%r{(`:[:a-z0-9._\/]*|`(?:[a-z0-9.][:a-z0-9._]*)?)}i, Str::Symbol)
+        rule(/(?:<=|>=|<>|::)|[?:$%&|@._#*^\-+~,!><=]:?/, Operator)
+
+        rule %r/[{}\[\]();]/, Punctuation
+
+        # commands
+        rule(/\\.*\n/, Text)
+
+      end
+
+      state :string do
+        rule %r/\\"/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\nr]|[01][0-7]{2})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\/, Str # stray backslash
+      end
+
+      state :bottom do
+        rule %r/.+\z/m, Comment::Multiline
+      end
+    end
+  end
+end