nano-max-hub 0.0.1

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

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Elm < RegexLexer
+      title "Elm"
+      desc "The Elm programming language (http://elm-lang.org/)"
+
+      tag 'elm'
+      filenames '*.elm'
+      mimetypes 'text/x-elm'
+
+      # Keywords are logically grouped by lines
+      keywords = %w(
+        module exposing port
+        import as
+        type alias
+        if then else
+        case of
+        let in
+      )
+
+      state :root do
+        # Whitespaces
+        rule %r/\s+/m, Text
+        # Single line comments
+        rule %r/--.*/, Comment::Single
+        # Multiline comments
+        rule %r/{-/, Comment::Multiline, :multiline_comment
+
+        # Keywords
+        rule %r/\b(#{keywords.join('|')})\b/, Keyword
+
+        # Variable or a function
+        rule %r/[a-z]\w*/, Name
+        # Underscore is a name for a variable, when it won't be used later
+        rule %r/_/, Name
+        # Type
+        rule %r/[A-Z]\w*/, Keyword::Type
+
+        # Two symbol operators: -> :: // .. && || ++ |> <| << >> == /= <= >=
+        rule %r/(->|::|\/\/|\.\.|&&|\|\||\+\+|\|>|<\||>>|<<|==|\/=|<=|>=)/, Operator
+        # One symbol operators: + - / * % = < > ^ | !
+        rule %r/[+-\/*%=<>^\|!]/, Operator
+        # Lambda operator
+        rule %r/\\/, Operator
+        # Not standard Elm operators, but these symbols can be used for custom inflix operators. We need to highlight them as operators as well.
+        rule %r/[@\#$&~?]/, Operator
+
+        # Single, double quotes, and triple double quotes
+        rule %r/"""/, Str, :multiline_string
+        rule %r/'(\\.|.)'/, Str::Char
+        rule %r/"/, Str, :double_quote
+
+        # Numbers
+        rule %r/0x[\da-f]+/i, Num::Hex
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/\d+\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule %r/\d+/, Num::Integer
+
+        # Punctuation: [ ] ( ) , ; ` { } :
+        rule %r/[\[\](),;`{}:]/, Punctuation
+      end
+
+      # Multiline and nested commenting
+      state :multiline_comment do
+        rule %r/-}/, Comment::Multiline, :pop!
+        rule %r/{-/, Comment::Multiline, :multiline_comment
+        rule %r/[^-{}]+/, Comment::Multiline
+        rule %r/[-{}]/, Comment::Multiline
+      end
+
+      # Double quotes
+      state :double_quote do
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/\\"/, Str::Escape
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      # Multiple line string with triple double quotes, e.g. """ multi """
+      state :multiline_string do
+        rule %r/\\"/, Str::Escape
+        rule %r/"""/, Str, :pop!
+        rule %r/[^"]+/, Str
+        rule %r/"/, Str
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Email < RegexLexer
+      tag 'email'
+      aliases 'eml', 'e-mail'
+      filenames '*.eml'
+      mimetypes 'message/rfc822'
+
+      title "Email"
+      desc "An email message"
+
+      start do
+        push :fields
+      end
+
+      state :fields do
+        rule %r/[:]/, Operator, :field_body
+        rule %r/[^\n\r:]+/, Name::Tag
+        rule %r/[\n\r]/, Name::Tag
+      end
+
+      state :field_body do
+        rule(/(\r?\n){2}/) { token Text; pop!(2) }
+        rule %r/\r?\n(?![ \v\t\f])/, Text, :pop!
+        rule %r/[^\n\r]+/, Name::Attribute
+        rule %r/[\n\r]/, Name::Attribute
+      end
+
+      state :root do
+        rule %r/\n/, Text
+        rule %r/^>.*/, Comment
+        rule %r/.+/, Text
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class EPP < TemplateLexer
+      title "EPP"
+      desc "Embedded Puppet template files"
+
+      tag 'epp'
+
+      filenames '*.epp'
+
+      def initialize(opts={})
+        super(opts)
+        @parent = lexer_option(:parent) { PlainText.new(opts) }
+        @puppet_lexer = Puppet.new(opts)
+      end
+
+      start do
+        parent.reset!
+        @puppet_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|(<%-|<%)(\s*\|)?/
+      close = /%%>|(\|\s*)?(-%>|%>)/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :puppet
+
+        rule %r/.+?(?=#{open})|.+/m do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/m, Comment
+      end
+
+      state :puppet do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/m do
+          delegate @puppet_lexer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ERB < TemplateLexer
+      title "ERB"
+      desc "Embedded ruby template files"
+
+      tag 'erb'
+      aliases 'eruby', 'rhtml'
+
+      filenames '*.erb', '*.erubis', '*.rhtml', '*.eruby'
+
+      def initialize(opts={})
+        @ruby_lexer = Ruby.new(opts)
+
+        super(opts)
+      end
+
+      start do
+        parent.reset!
+        @ruby_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|<%-|<%/
+      close = /%%>|-%>|%>/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :ruby
+
+        rule %r/.+?(?=#{open})|.+/m do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/m, Comment
+      end
+
+      state :ruby do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/m do
+          delegate @ruby_lexer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Erlang < RegexLexer
+      title "Erlang"
+      desc "The Erlang programming language (erlang.org)"
+      tag 'erlang'
+      aliases 'erl'
+      filenames '*.erl', '*.hrl'
+
+      mimetypes 'text/x-erlang', 'application/x-erlang'
+
+      keywords = %w(
+        after begin case catch cond end fun if
+        let of query receive try when
+      )
+
+      builtins = %w(
+        abs append_element apply atom_to_list binary_to_list
+        bitstring_to_list binary_to_term bit_size bump_reductions
+        byte_size cancel_timer check_process_code delete_module
+        demonitor disconnect_node display element erase exit
+        float float_to_list fun_info fun_to_list
+        function_exported garbage_collect get get_keys
+        group_leader hash hd integer_to_list iolist_to_binary
+        iolist_size is_atom is_binary is_bitstring is_boolean
+        is_builtin is_float is_function is_integer is_list
+        is_number is_pid is_port is_process_alive is_record
+        is_reference is_tuple length link list_to_atom
+        list_to_binary list_to_bitstring list_to_existing_atom
+        list_to_float list_to_integer list_to_pid list_to_tuple
+        load_module localtime_to_universaltime make_tuple md5
+        md5_final md5_update memory module_loaded monitor
+        monitor_node node nodes open_port phash phash2
+        pid_to_list port_close port_command port_connect
+        port_control port_call port_info port_to_list
+        process_display process_flag process_info purge_module
+        put read_timer ref_to_list register resume_process
+        round send send_after send_nosuspend set_cookie
+        setelement size spawn spawn_link spawn_monitor
+        spawn_opt split_binary start_timer statistics
+        suspend_process system_flag system_info system_monitor
+        system_profile term_to_binary tl trace trace_delivered
+        trace_info trace_pattern trunc tuple_size tuple_to_list
+        universaltime_to_localtime unlink unregister whereis
+      )
+
+      operators = %r{(\+\+?|--?|\*|/|<|>|/=|=:=|=/=|=<|>=|==?|<-|!|\?)}
+      word_operators = %w(
+        and andalso band bnot bor bsl bsr bxor
+        div not or orelse rem xor
+      )
+
+      atom_re = %r{(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')}
+
+      variable_re = %r{(?:[A-Z_][a-zA-Z0-9_]*)}
+
+      escape_re = %r{(?:\\(?:[bdefnrstv\'"\\/]|[0-7][0-7]?[0-7]?|\^[a-zA-Z]))}
+
+      macro_re = %r{(?:#{variable_re}|#{atom_re})}
+
+      base_re = %r{(?:[2-9]|[12][0-9]|3[0-6])}
+
+      state :root do
+        rule(/\s+/, Text)
+        rule(/%.*\n/, Comment)
+        rule(%r{(#{keywords.join('|')})\b}, Keyword)
+        rule(%r{(#{builtins.join('|')})\b}, Name::Builtin)
+        rule(%r{(#{word_operators.join('|')})\b}, Operator::Word)
+        rule(/^-/, Punctuation, :directive)
+        rule(operators, Operator)
+        rule(/"/, Str, :string)
+        rule(/<</, Name::Label)
+        rule(/>>/, Name::Label)
+        rule %r{(#{atom_re})(:)} do
+          groups Name::Namespace, Punctuation
+        end
+        rule %r{(?:^|(?<=:))(#{atom_re})(\s*)(\()} do
+          groups Name::Function, Text, Punctuation
+        end
+        rule(%r{[+-]?#{base_re}#[0-9a-zA-Z]+}, Num::Integer)
+        rule(/[+-]?\d+/, Num::Integer)
+        rule(/[+-]?\d+.\d+/, Num::Float)
+        rule(%r{[\]\[:_@\".{}()|;,]}, Punctuation)
+        rule(variable_re, Name::Variable)
+        rule(atom_re, Name)
+        rule(%r{\?#{macro_re}}, Name::Constant)
+        rule(%r{\$(?:#{escape_re}|\\[ %]|[^\\])}, Str::Char)
+        rule(%r{##{atom_re}(:?\.#{atom_re})?}, Name::Label)
+      end
+
+      state :string do
+        rule(escape_re, Str::Escape)
+        rule(/"/, Str, :pop!)
+        rule(%r{~[0-9.*]*[~#+bBcdefginpPswWxX]}, Str::Interpol)
+        rule(%r{[^"\\~]+}, Str)
+        rule(/~/, Str)
+      end
+
+      state :directive do
+        rule %r{(define)(\s*)(\()(#{macro_re})} do
+          groups Name::Entity, Text, Punctuation, Name::Constant
+          pop!
+        end
+        rule %r{(record)(\s*)(\()(#{macro_re})} do
+          groups Name::Entity, Text, Punctuation, Name::Label
+          pop!
+        end
+        rule(atom_re, Name::Entity, :pop!)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Escape < Lexer
+      tag 'escape'
+      aliases 'esc'
+
+      desc 'A generic lexer for including escaped content - see Formatter.enable_escape!'
+
+      option :start, 'the beginning of the escaped section, default "<!"'
+      option :end, 'the end of the escaped section, e.g. "!>"'
+      option :lang, 'the language to lex in unescaped sections'
+
+      attr_reader :start
+      attr_reader :end
+      attr_reader :lang
+
+      def initialize(*)
+        super
+        @start = string_option(:start) { '<!' }
+        @end = string_option(:end) { '!>' }
+        @lang = lexer_option(:lang) { PlainText.new }
+      end
+
+      def to_start_regex
+        @to_start_regex ||= /(.*?)(#{Regexp.escape(@start)})/m
+      end
+
+      def to_end_regex
+        @to_end_regex ||= /(.*?)(#{Regexp.escape(@end)})/m
+      end
+
+      def stream_tokens(str, &b)
+        stream = StringScanner.new(str, fixed_anchor: true)
+
+        loop do
+          if stream.scan(to_start_regex)
+            puts "pre-escape: #{stream[1].inspect}" if @debug
+            @lang.continue_lex(stream[1], &b)
+          else
+            # no more start delimiters, scan til the end
+            @lang.continue_lex(stream.rest, &b)
+            return
+          end
+
+          if stream.scan(to_end_regex)
+            yield Token::Tokens::Escape, stream[1]
+          else
+            yield Token::Tokens::Escape, stream.rest
+            return
+          end
+        end
+      end
+    end
+  end
+end