nano-max-hub 0.0.1

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

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Lustre < RegexLexer
+      title "Lustre"
+      desc 'The Lustre programming language (Verimag)'
+      tag 'lustre'
+      filenames '*.lus'
+      mimetypes 'text/x-lustre'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          extern unsafe assert const current enum function let node operator
+          returns step struct tel type var model package needs provides uses is
+          body end include merge
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(
+          div and xor mod or not nor if then else fby pre when with
+        )
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(int real bool)
+      end
+
+      operator = %r([,!$%&*+./:<=>?@^|~#-]+)
+      id = /[a-z_][\w']*/i
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/false|true/, Keyword::Constant
+        rule %r(\-\-.*), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        rule id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule %r/[(){}\[\];]+/, Punctuation
+        rule operator, Operator
+
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/\d[\d_]*/, Num::Integer
+
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[.]'/, Str::Char
+        rule %r/"/, Str::Double, :string
+        rule %r/[~?]#{id}/, Name::Variable
+      end
+
+      state :string do
+        rule %r/[^\\"]+/, Str::Double
+        mixin :escape_sequence
+        rule %r/\\\n/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :escape_sequence do
+        rule %r/\\[\\"'ntbr]/, Str::Escape
+        rule %r/\\\d{3}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+#
+# adapted from lustre.rf (adapted from ocaml.rb), hence some ocaml-ism migth remains
+
+require_relative 'lustre'
+
+module Rouge
+  module Lexers
+    class Lutin < Lustre
+      title "Lutin"
+      desc 'The Lutin programming language (Verimag)'
+      tag 'lutin'
+      filenames '*.lut'
+      mimetypes 'text/x-lutin'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          let in node extern system returns weak strong assert raise try catch
+          trap do exist erun run type ref exception include false true
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(
+           div and xor mod or not nor if then else pre)
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(int real bool trace loop fby)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class M68k < RegexLexer
+      tag 'm68k'
+
+      title "M68k"
+      desc "Motorola 68k Assembler"
+
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abcd add adda addi addq addx and andi asl asr
+
+          bcc bcs beq bge bgt bhi ble bls blt bmi bne bpl bvc bvs bhs blo
+          bchg bclr bfchg bfclr bfests bfextu bfffo bfins bfset bftst bkpt bra bse bsr btst
+
+          callm cas cas2 chk chk2 clr cmp cmpa cmpi cmpm cmp2
+
+          dbcc dbcs dbeq dbge dbgt dbhi dble dbls dblt dbmi dbne dbpl dbvc dbvs dbhs dblo
+          dbra dbf dbt divs divsl divu divul
+
+          eor eori exg ext extb
+
+          illegal jmp jsr lea link lsl lsr
+
+          move movea move16 movem movep moveq muls mulu
+
+          nbcd neg negx nop not or ori
+
+          pack pea rol ror roxl roxr rtd rtm rtr rts
+
+          sbcd
+
+          seq sne spl smi svc svs st sf sge sgt sle slt scc shi sls scs shs slo
+          sub suba subi subq subx swap
+
+          tas trap trapcc TODO trapv tst
+
+          unlk unpk
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          dc ds dcb
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          include incdir incbin end endf endfunc endmain endproc fpu func machine main mmu opword proc set opt section
+          rept endr
+          ifeq ifne ifgt ifge iflt ifle iif ifd ifnd ifc ifnc elseif else endc
+          even cnop fail
+          output radix __G2 __LK
+          list nolist plen llen ttl subttl spc page listchar format
+          equ equenv equr reg
+          rsreset rsset offset
+          cargs
+          fequ.s fequ.d fequ.x fequ.p fequ.w fequ.l fopt
+          macro endm mexit narg
+        )
+      end
+
+      def self.builtins
+        @builtins ||=Set.new %w(
+          d0 d1 d2 d3 d4 d5 d6 d7
+          a0 a1 a2 a3 a4 a5 a6 a7 a7'
+          pc usp ssp ccr
+        )
+      end
+
+      start { push :expr_bol }
+
+      state :expr_bol do
+        mixin :inline_whitespace
+        rule(//) { pop! }
+      end
+
+      state :inline_whitespace do
+        rule %r/\s+/, Text
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text, :expr_bol
+        rule %r(^\*(\\.|.)*?$), Comment::Single, :expr_bol
+        rule %r(;(\\.|.)*?$), Comment::Single, :expr_bol
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        rule(//) { push :statements }
+      end
+
+      state :statements do
+        mixin :whitespace
+        rule %r/"/, Str, :string
+        rule %r/#/, Name::Decorator
+        rule %r/^\.?[a-zA-Z0-9_]+:?/, Name::Label
+        rule %r/\.[bswl]\s/i, Name::Decorator
+        rule %r('(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
+        rule %r/\$[0-9a-f]+/i, Num::Hex
+        rule %r/@[0-8]+/i, Num::Oct
+        rule %r/%[01]+/i, Num::Bin
+        rule %r/\d+/i, Num::Integer
+        rule %r([*~&+=\|?:<>/-]), Operator
+        rule %r/\\./, Comment::Preproc
+        rule %r/[(),.]/, Punctuation
+        rule %r/\[[a-zA-Z0-9]*\]/, Punctuation
+
+        rule id do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name.downcase
+            token Keyword
+          elsif self.class.keywords_type.include? name.downcase
+            token Keyword::Type
+          elsif self.class.reserved.include? name.downcase
+            token Keyword::Reserved
+          elsif self.class.builtins.include? name.downcase
+            token Name::Builtin
+          elsif name =~ /[a-zA-Z0-9]+/
+            token Name::Variable
+          else
+            token Name
+          end
+        end
+      end
+
+      state :string do
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\\n/, Str
+        rule %r/\\/, Str # stray backslash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Magik < RegexLexer
+      title "Magik"
+      desc "Smallworld Magik"
+      tag 'magik'
+      filenames '*.magik'
+      mimetypes 'text/x-magik', 'application/x-magik'
+
+      def self.keywords
+        @keywords ||= %w(
+           _package
+           _pragma
+           _block _endblock
+           _handling _default
+           _protect _protection _endprotect
+           _try _with _when _endtry
+           _catch _endcatch
+           _throw
+           _lock _endlock
+           _if _then _elif _else _endif
+           _for _over _while _loop _finally _endloop _loopbody _continue _leave
+           _return
+           _class
+           _local _constant _recursive _global _dynamic _import
+           _private _iter _abstract _method _endmethod
+           _proc _endproc
+           _gather _scatter _allresults _optional
+           _thisthread _self _clone _super
+           _primitive
+           _unset _true _false _maybe
+           _is _isnt _not _and _or _xor _cf _andif _orif
+           _div _mod
+        )
+      end
+
+      def self.string_double
+        @string_double ||= /"[^"\n]*?"/
+      end
+      def self.string_single
+        @string_single ||= /'[^'\n]*?'/
+      end
+
+      def self.digits
+        @digits ||= /[0-9]+/
+      end
+      def self.radix
+        @radix ||= /r[0-9a-z]/i
+      end
+      def self.exponent
+        @exponent ||= /(e|&)[+-]?#{Magik.digits}/i
+      end
+      def self.decimal
+        @decimal ||= /\.#{Magik.digits}/
+      end
+      def self.number
+        @number = /#{Magik.digits}(#{Magik.radix}|#{Magik.exponent}|#{Magik.decimal})*/
+      end
+
+      def self.character
+        @character ||= /%u[0-9a-z]{4}|%[^\s]+/i
+      end
+
+      def self.simple_identifier
+        @simple_identifier ||= /(?>(?:[a-z0-9_!?]|\\.)+)/i
+      end
+      def self.piped_identifier
+        @piped_identifier ||= /\|[^\|\n]*\|/
+      end
+      def self.identifier
+        @identifier ||= /(?:#{Magik.simple_identifier}|#{Magik.piped_identifier})+/i
+      end
+      def self.package_identifier
+        @package_identifier ||= /#{Magik.identifier}:#{Magik.identifier}/
+      end
+      def self.symbol
+        @symbol ||= /:#{Magik.identifier}/i
+      end
+      def self.global_ref
+        @global_ref ||= /@[\s]*#{Magik.identifier}:#{Magik.identifier}/
+      end
+      def self.label
+        @label = /@[\s]*#{Magik.identifier}/
+      end
+
+      state :root do
+        rule %r/##(.*)?/, Comment::Doc
+        rule %r/#(.*)?/, Comment::Single
+
+        rule %r/(_method)(\s+)/ do
+          groups Keyword, Text::Whitespace
+          push :method_name
+        end
+
+        rule %r/(?:#{Magik.keywords.join('|')})\b/, Keyword
+
+        rule Magik.string_double, Literal::String
+        rule Magik.string_single, Literal::String
+        rule Magik.symbol, Str::Symbol
+        rule Magik.global_ref, Name::Label
+        rule Magik.label, Name::Label
+        rule Magik.character, Literal::String::Char
+        rule Magik.number, Literal::Number
+        rule Magik.package_identifier, Name
+        rule Magik.identifier, Name
+
+        rule %r/[\[\]{}()\.,;]/, Punctuation
+        rule %r/\$/, Punctuation
+        rule %r/(<<|^<<)/, Operator
+        rule %r/(>>)/, Operator
+        rule %r/[-~+\/*%=&^<>]|!=/, Operator
+
+        rule %r/[\s]+/, Text::Whitespace
+      end
+
+      state :method_name do
+        rule %r/(#{Magik.identifier})(\.)(#{Magik.identifier})/ do
+          groups Name::Class, Punctuation, Name::Function
+          pop!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Make < RegexLexer
+      title "Make"
+      desc "Makefile syntax"
+      tag 'make'
+      aliases 'makefile', 'mf', 'gnumake', 'bsdmake'
+      filenames '*.make', '*.mak', '*.mk', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile', '*,fe1'
+      mimetypes 'text/x-makefile'
+
+      def self.functions
+        @functions ||= %w(
+          abspath addprefix addsuffix and basename call dir error eval file
+          filter filter-out findstring firstword flavor foreach if join lastword
+          notdir or origin patsubst realpath shell sort strip subst suffix value
+          warning wildcard word wordlist words
+        )
+      end
+
+      def initialize(opts={})
+        super
+        @shell = Shell.new(opts)
+      end
+
+      start { @shell.reset! }
+
+      state :root do
+        rule %r/\s+/, Text
+
+        rule %r/#.*?\n/, Comment
+
+        rule %r/([-s]?include)((?:[\t ]+[^\t\n #]+)+)/ do
+          groups Keyword, Literal::String::Other
+        end
+
+        rule %r/((?:ifn?def|ifn?eq|unexport)\b)([\t ]+)([^#\n]+)/ do
+          groups Keyword, Text, Name::Variable
+        end
+
+        rule %r/(else\b)([\t ]+)((?:ifn?def|ifn?eq)\b)([\t ]+)([^#\n]+)/ do
+          groups Keyword, Text, Keyword, Text, Name::Variable
+        end
+
+        rule %r/(?:else|endif|endef|endfor)[\t ]*(?=[#\n])/, Keyword
+
+        rule %r/(export)([\t ]+)(?=[\w\${}()\t -]+\n)/ do
+          groups Keyword, Text
+          push :export
+        end
+
+        rule %r/export[\t ]+/, Keyword
+
+        # assignment
+        rule %r/(override\b)*([\t ]*)([\w${}().-]+)([\t ]*)([!?:+]?=)/m do |m|
+          groups Name::Builtin, Text, Name::Variable, Text, Operator
+          push :shell_line
+        end
+
+        rule %r/"(\\\\|\\.|[^"\\])*"/, Str::Double
+        rule %r/'(\\\\|\\.|[^'\\])*'/, Str::Single
+        rule %r/([^\n:]+)(:+)([ \t]*)/ do
+          groups Name::Label, Operator, Text
+          push :block_header
+        end
+
+        rule %r/(override\b)*([\t ])*(define)([\t ]+)([^#\n]+)/ do
+          groups Name::Builtin, Text, Keyword, Text, Name::Variable
+        end
+
+        rule %r/(\$[({])([\t ]*)(#{Make.functions.join('|')})([\t ]+)/m do
+          groups Name::Function, Text, Name::Builtin, Text
+          push :shell_expr
+        end
+      end
+
+      state :export do
+        rule %r/[\w\${}()-]/, Name::Variable
+        rule %r/\n/, Text, :pop!
+        rule %r/[\t ]+/, Text
+      end
+
+      state :block_header do
+        rule %r/[^,\\\n#]+/, Name::Function
+        rule %r/,/, Punctuation
+        rule %r/#.*?/, Comment
+        rule %r/\\\n/, Text
+        rule %r/\\./, Text
+        rule %r/\n/ do
+          token Text
+          goto :block_body
+        end
+      end
+
+      state :block_body do
+        rule %r/(ifn?def|ifn?eq)([\t ]+)([^#\n]+)(#.*)?(\n)/ do
+          groups Keyword, Text, Name::Variable, Comment, Text
+        end
+
+        rule %r/(else|endif)([\t ]*)(#.*)?(\n)/ do
+          groups Keyword, Text, Comment, Text
+        end
+
+        rule %r/(\t[\t ]*)([@-]?)/ do
+          groups Text, Punctuation
+          push :shell_line
+        end
+
+        rule(//) { @shell.reset!; pop! }
+      end
+
+      state :shell do
+        # macro interpolation
+        rule %r/[\$]{1,2}[({]/, Punctuation, :macro_expr
+
+        # function invocation
+        rule %r/(\$[({])([\t ]*)(#{Make.functions.join('|')})([\t ]+)/m do
+          groups Punctuation, Text, Name::Builtin, Text
+          push :shell_expr
+        end
+
+        rule(/\\./m) { delegate @shell }
+        stop = /[\$]{1,2}\(|[\$]{1,2}\{|\(|\)|\}|\\|$/
+        rule(/.+?(?=#{stop})/m) { delegate @shell }
+        rule(stop) { delegate @shell }
+      end
+
+      state :macro_expr do
+        rule %r/[)}]/, Punctuation, :pop!
+        rule %r/\n/, Text, :pop!
+        mixin :shell
+      end
+
+      state :shell_expr do
+        rule(/[({]/) { delegate @shell; push }
+        rule %r/[)}]/, Punctuation, :pop!
+        mixin :shell
+      end
+
+      state :shell_line do
+        rule %r/\n/, Text, :pop!
+        mixin :shell
+      end
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Markdown < RegexLexer
+      title "Markdown"
+      desc "Markdown, a light-weight markup language for authors"
+
+      tag 'markdown'
+      aliases 'md', 'mkd'
+      filenames '*.markdown', '*.md', '*.mkd'
+      mimetypes 'text/x-markdown'
+
+      def html
+        @html ||= HTML.new(options)
+      end
+
+      start { html.reset! }
+
+      edot = /\\.|[^\\\n]/
+
+      state :root do
+        # YAML frontmatter
+        rule(/\A(---\s*\n.*?\n?)^(---\s*$\n?)/m) { delegate YAML }
+
+        rule %r/\\./, Str::Escape
+
+        rule %r/^[\S ]+\n(?:---*)\n/, Generic::Heading
+        rule %r/^[\S ]+\n(?:===*)\n/, Generic::Subheading
+
+        rule %r/^#(?=[^#]).*?$/, Generic::Heading
+        rule %r/^##*.*?$/, Generic::Subheading
+
+        rule %r/^([ \t]*)(`{3,}|~{3,})([^\n]*\n)((.*?)(\n\1)(\2))?/m do |m|
+          name = m[3].strip
+          sublexer =
+            begin
+              Lexer.find_fancy(name.empty? ? "guess" : name, m[5], @options)
+            rescue Guesser::Ambiguous => e
+              e.alternatives.first.new(@options)
+            end
+
+          sublexer ||= PlainText.new(@options.merge(:token => Str::Backtick))
+          sublexer.reset!
+
+          token Text, m[1]
+          token Punctuation, m[2]
+          token Name::Label, m[3]
+          if m[5]
+            delegate sublexer, m[5]
+          end
+
+          token Text, m[6]
+
+          if m[7]
+            token Punctuation, m[7]
+          else
+            push do
+              rule %r/^([ \t]*)(#{m[2]})/ do |mb|
+                pop!
+                token Text, mb[1]
+                token Punctuation, mb[2]
+              end
+              rule %r/^.*\n/ do |mb|
+                delegate sublexer, mb[1]
+              end
+            end
+          end
+        end
+
+        rule %r/\n\n((    |\t).*?\n|\n)+/, Str::Backtick
+
+        rule %r/(`+)(?:#{edot}|\n)+?\1/, Str::Backtick
+
+        # various uses of * are in order of precedence
+
+        # line breaks
+        rule %r/^(\s*[*]){3,}\s*$/, Punctuation
+        rule %r/^(\s*[-]){3,}\s*$/, Punctuation
+
+        # bulleted lists
+        rule %r/^\s*[*+-](?=\s)/, Punctuation
+
+        # numbered lists
+        rule %r/^\s*\d+\./, Punctuation
+
+        # blockquotes
+        rule %r/^\s*>.*?$/, Generic::Traceback
+
+        # link references
+        # [foo]: bar "baz"
+        rule %r(^
+          (\s*) # leading whitespace
+          (\[) (#{edot}+?) (\]) # the reference
+          (\s*) (:) # colon
+        )x do
+          groups Text, Punctuation, Str::Symbol, Punctuation, Text, Punctuation
+
+          push :title
+          push :url
+        end
+
+        # links and images
+        rule %r/(!?\[)(#{edot}*?|[^\]]*?)(\])(?=[\[(])/ do
+          groups Punctuation, Name::Variable, Punctuation
+          push :link
+        end
+
+        rule %r/[*]{2}[^* \n][^*\n]*[*]{2}/, Generic::Strong
+        rule %r/[*]{3}[^* \n][^*\n]*[*]{3}/, Generic::EmphStrong
+        rule %r/__#{edot}*?__/, Generic::Strong
+
+        rule %r/[*]#{edot}*?[*]/, Generic::Emph
+        rule %r/_#{edot}*?_/, Generic::Emph
+
+        # Automatic links
+        rule %r/<.*?@.+[.].+>/, Name::Variable
+        rule %r[<(https?|mailto|ftp)://#{edot}*?>], Name::Variable
+
+        rule %r/[^\\`\[*\n&<]+/, Text
+
+        # inline html
+        rule(/&\S*;/) { delegate html }
+        rule(/<#{edot}*?>/) { delegate html }
+        rule %r/[&<]/, Text
+
+        # An opening square bracket that is not a link
+        rule %r/\[/, Text
+
+        rule %r/\n/, Text
+      end
+
+      state :link do
+        rule %r/(\[)(#{edot}*?)(\])/ do
+          groups Punctuation, Str::Symbol, Punctuation
+          pop!
+        end
+
+        rule %r/[(]/ do
+          token Punctuation
+          push :inline_title
+          push :inline_url
+        end
+
+        rule %r/[ \t]+/, Text
+
+        rule(//) { pop! }
+      end
+
+      state :url do
+        rule %r/[ \t]+/, Text
+
+        # the url
+        rule %r/(<)(#{edot}*?)(>)/ do
+          groups Name::Tag, Str::Other, Name::Tag
+          pop!
+        end
+
+        rule %r/\S+/, Str::Other, :pop!
+      end
+
+      state :title do
+        rule %r/"#{edot}*?"/, Name::Namespace
+        rule %r/'#{edot}*?'/, Name::Namespace
+        rule %r/[(]#{edot}*?[)]/, Name::Namespace
+        rule %r/\s*(?=["'()])/, Text
+        rule(//) { pop! }
+      end
+
+      state :inline_title do
+        rule %r/[)]/, Punctuation, :pop!
+        mixin :title
+      end
+
+      state :inline_url do
+        rule %r/[^<\s)]+/, Str::Other, :pop!
+        rule %r/\s+/m, Text
+        mixin :url
+      end
+    end
+  end
+end