nano-max-hub 0.0.1

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

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# NOTE: This is for Lean 3 (community fork).
+module Rouge
+  module Lexers
+    class Lean < RegexLexer
+      title 'Lean'
+      desc 'The Lean programming language (leanprover.github.io)'
+      tag 'lean'
+      aliases 'lean'
+      filenames '*.lean'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abbreviation
+          add_rewrite
+          alias
+          assume
+          axiom
+          begin
+          by
+          calc
+          calc_refl
+          calc_subst
+          calc_trans
+          #check
+          coercion
+          conjecture
+          constant
+          constants
+          context
+          corollary
+          def
+          definition
+          end
+          #eval
+          example
+          export
+          expose
+          exposing
+          exit
+          extends
+          from
+          fun
+          have
+          help
+          hiding
+          hott
+          hypothesis
+          import
+          include
+          including
+          inductive
+          infix
+          infixl
+          infixr
+          inline
+          instance
+          irreducible
+          lemma
+          match
+          namespace
+          notation
+          opaque
+          opaque_hint
+          open
+          options
+          parameter
+          parameters
+          postfix
+          precedence
+          prefix
+          #print
+          private
+          protected
+          #reduce
+          reducible
+          renaming
+          repeat
+          section
+          set_option
+          show
+          tactic_hint
+          theorem
+          universe
+          universes
+          using
+          variable
+          variables
+          with
+        )
+      end
+
+      def self.types
+        @types ||= %w(
+          Sort
+          Prop
+          Type
+        )
+      end
+
+      def self.operators
+        @operators ||= %w(
+          != # & && \* \+ - / @ ! ` -\. ->
+          \. \.\. \.\.\. :: :> ; ;; <
+          <- = == > _ \| \|\| ~ => <= >=
+          /\ \/ ∀ Π λ ↔ ∧ ∨ ≠ ≤ ≥ ⊎
+          ¬ ⁻¹ ⬝ ▸ → ∃ ℕ ℤ ≈ × ⌞ ⌟ ≡ ⟨ ⟩
+        )
+      end
+
+      state :root do
+        # comments starting after some space
+        rule %r/\s*--+\s+.*?$/, Comment::Doc
+
+        rule %r/"/, Str, :string
+        rule %r/\d+/, Num::Integer
+
+        # special commands or keywords
+        rule(/#?\w+/) do |m|
+          match = m[0]
+          if self.class.keywords.include?(match)
+            token Keyword
+          elsif self.class.types.include?(match)
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        # special unicode keywords
+        rule %r/[λ]/, Keyword
+
+        # ----------------
+        # operators rules
+        # ----------------
+
+        rule %r/\:=?/, Text
+        rule %r/\.[0-9]*/, Operator
+
+        rule %r(#{Lean.operators.join('|')}), Operator
+
+        # unmatched symbols
+        rule %r/[\s\(\),\[\]αβ‹›]+/, Text
+
+        # show missing matches
+        rule %r/./, Error
+
+      end
+
+      state :string do
+        rule %r/"/, Str, :pop!
+        rule %r/\\/, Str::Escape, :escape
+        rule %r/[^\\"]+/, Str
+      end
+
+      state :escape do
+        rule %r/[nrt"'\\]/, Str::Escape, :pop!
+        rule %r/x[\da-f]+/i, Str::Escape, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,284 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Liquid < RegexLexer
+      title "Liquid"
+      desc 'Liquid is a templating engine for Ruby (liquidmarkup.org)'
+      tag 'liquid'
+      filenames '*.liquid'
+      mimetypes 'text/html+liquid'
+
+      state :root do
+        rule %r/[^\{]+/, Text
+
+        rule %r/(\{%-?)(\s*)/ do
+          groups Comment::Preproc, Text::Whitespace
+          push :logic
+        end
+
+        rule %r/(\{\{-?)(\s*)/ do
+          groups Comment::Preproc, Text::Whitespace
+          push :output
+        end
+
+        rule %r/\{/, Text
+      end
+
+      state :end_logic do
+        rule(/(\s*)(-?%\})/) do
+          groups Text::Whitespace, Comment::Preproc
+          reset_stack
+        end
+
+        rule(/\n\s*/) do
+          token Text::Whitespace
+          if in_state? :liquid
+            pop! until state? :liquid
+          end
+        end
+
+        mixin :whitespace
+      end
+
+      state :end_output do
+        rule(/(\s*)(-?\}\})/) do
+          groups Text::Whitespace, Comment::Preproc
+          reset_stack
+        end
+      end
+
+      state :liquid do
+        mixin :end_logic
+        mixin :logic
+      end
+
+      state :logic do
+        rule %r/(liquid)\b/, Name::Tag, :liquid
+
+        # builtin logic blocks
+        rule %r/(if|elsif|unless|case)\b/, Name::Tag, :condition
+        rule %r/(when)\b/, Name::Tag, :value
+        rule %r/(else|ifchanged|end\w+)\b/, Name::Tag, :end_logic
+        rule %r/(break|continue)\b/, Keyword::Reserved, :end_logic
+
+        # builtin iteration blocks
+        rule %r/(for|tablerow)(\s+)(\S+)(\s+)(in)(\s+)/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
+                 Name::Tag, Text::Whitespace
+          push :iteration_args
+        end
+
+        # other builtin blocks
+        rule %r/(capture|(?:in|de)crement)(\s+)([a-zA-Z_](?:\w|-(?!%))*)/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable
+          push :end_logic
+        end
+
+        rule %r/(comment)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Comment::Preproc
+          push :comment
+        end
+
+        rule %r/(raw)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Comment::Preproc
+          push :raw
+        end
+
+        # builtin tags
+        rule %r/(assign|echo)\b/, Name::Tag, :assign
+
+        rule %r/(include|render)(\s+)([\/\w-]+(?:\.[\w-]+)+\b)?/ do
+          groups Name::Tag, Text::Whitespace, Text
+          push :include
+        end
+
+        rule %r/(cycle)(\s+)(?:([\w-]+|'[^']*'|"[^"]*")(\s*)(:))?(\s*)/ do |m|
+          token_class = case m[3]
+          when %r/'[^']*'/ then Str::Single
+          when %r/"[^"]*"/ then Str::Double
+          else Name::Attribute
+          end
+          groups Name::Tag, Text::Whitespace, token_class,
+                 Text::Whitespace, Punctuation, Text::Whitespace
+          push :tag_args
+        end
+
+        # custom tags or blocks
+        rule %r/(\w+)\b/, Name::Tag, :block_args
+
+        mixin :end_logic
+      end
+
+      state :output do
+        rule %r/(\|)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :filters
+          push :filter
+        end
+
+        mixin :end_output
+        mixin :static
+        mixin :variable
+      end
+
+      state :condition do
+        rule %r/([=!]=|[<>]=?)/, Operator
+        rule %r/(and|or|contains)\b/, Operator::Word
+
+        mixin :value
+      end
+
+      state :value do
+        mixin :end_logic
+        mixin :static
+        mixin :variable
+      end
+
+      state :iteration_args do
+        rule %r/(reversed|continue)\b/, Name::Attribute
+        rule %r/\(/, Punctuation, :range
+
+        mixin :tag_args
+      end
+
+      state :block_args do
+        rule %r/(\{\{-?)/, Comment::Preproc, :output_embed
+
+        rule %r/(\|)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :filters
+          push :filter
+        end
+
+        mixin :tag_args
+      end
+
+      state :tag_args do
+        mixin :end_logic
+        mixin :args
+      end
+
+      state :comment do
+        rule %r/[^\{]+/, Comment
+
+        rule %r/(\{%-?)(\s*)(endcomment)(\s*)(-?%\})/ do
+          groups Comment::Preproc, Text::Whitespace, Name::Tag, Text::Whitespace, Comment::Preproc
+          reset_stack
+        end
+
+        rule %r/\{/, Comment
+      end
+
+      state :raw do
+        rule %r/[^\{]+/, Text
+
+        rule %r/(\{%-?)(\s*)(endraw)(\s*)(-?%\})/ do
+          groups Comment::Preproc, Text::Whitespace, Name::Tag, Text::Whitespace, Comment::Preproc
+          reset_stack
+        end
+
+        rule %r/\{/, Text
+      end
+
+      state :assign do
+        rule %r/=/, Operator
+        rule %r/\(/, Punctuation, :range
+
+        rule %r/(\|)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :filters
+          push :filter
+        end
+
+        mixin :value
+      end
+
+      state :include do
+        rule %r/(\{\{-?)/, Comment::Preproc, :output_embed
+        rule %r/(with|for|as)\b/, Keyword::Reserved
+
+        mixin :tag_args
+      end
+
+      state :output_embed do
+        rule %r/(\|)(\s*)([a-zA-Z_](?:\w|-(?!}))*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/-?\}\}/, Comment::Preproc, :pop!
+
+        mixin :args
+      end
+
+      state :range do
+        rule %r/\.\./, Punctuation
+        rule %r/\)/, Punctuation, :pop!
+
+        mixin :whitespace
+        mixin :number
+        mixin :variable
+      end
+
+      state :filters do
+        rule %r/(\|)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :filter
+        end
+
+        mixin :end_logic
+        mixin :end_output
+        mixin :args
+      end
+
+      state :filter do
+        rule %r/[a-zA-Z_](?:\w|-(?![%}]))*/, Name::Function, :pop!
+
+        mixin :whitespace
+      end
+
+      state :args do
+        mixin :static
+
+        rule %r/([a-zA-Z_][\w-]*)(\s*)(=|:)/ do
+          groups Name::Attribute, Text::Whitespace, Operator
+        end
+
+        mixin :variable
+      end
+
+      state :static do
+        rule %r/(false|true|nil)\b/, Keyword::Constant
+        rule %r/'[^']*'/, Str::Single
+        rule %r/"[^"]*"/, Str::Double
+        rule %r/[,:]/, Punctuation
+
+        mixin :whitespace
+        mixin :number
+      end
+
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/#.*?(?=$|-?[}%]})/, Comment
+      end
+
+      state :number do
+        rule %r/-/, Operator
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
+      end
+
+      state :variable do
+        rule %r/(\.)(\s*)(first|last|size)\b(?![?!\/])/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/\.(?= *\w)|\[|\]/, Punctuation
+        rule %r/(empty|blank|(for|tablerow)loop\.(parentloop\.)*\w+)\b(?![?!\/])/, Name::Builtin
+        rule %r/[a-zA-Z_][\w-]*\b-?(?![?!\/])/, Name::Variable
+        rule %r/\S+/, Text
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LiterateCoffeescript < RegexLexer
+      tag 'literate_coffeescript'
+      title "Literate CoffeeScript"
+      desc 'Literate coffeescript'
+      aliases 'litcoffee'
+      filenames '*.litcoffee'
+
+      def markdown
+        @markdown ||= Markdown.new(options)
+      end
+
+      def coffee
+        @coffee ||= Coffeescript.new(options)
+      end
+
+      start { markdown.reset!; coffee.reset! }
+
+      state :root do
+        rule %r/^(    .*?\n)+/m do
+          delegate coffee
+        end
+
+        rule %r/^([ ]{0,3}(\S.*?|)\n)*/m do
+          delegate markdown
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LiterateHaskell < RegexLexer
+      title "Literate Haskell"
+      desc 'Literate haskell'
+      tag 'literate_haskell'
+      aliases 'lithaskell', 'lhaskell', 'lhs'
+      filenames '*.lhs'
+      mimetypes 'text/x-literate-haskell'
+
+      def haskell
+        @haskell ||= Haskell.new(options)
+      end
+
+      start { haskell.reset! }
+
+      # TODO: support TeX versions as well.
+      state :root do
+        rule %r/\s*?\n(?=>)/, Text, :code
+        rule %r/.*?\n/, Text
+        rule %r/.+\z/, Text
+      end
+
+      state :code do
+        rule %r/(>)( .*?(\n|\z))/ do |m|
+          token Name::Label, m[1]
+          delegate haskell, m[2]
+        end
+
+        rule %r/\s*\n(?=\s*[^>])/, Text, :pop!
+      end
+    end
+  end
+end