nano-clean-pkg 0.0.1

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

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'hcl'
+
+module Rouge
+  module Lexers
+    class Terraform < Hcl
+      title "Terraform"
+      desc "Terraform HCL Interpolations"
+
+      tag 'terraform'
+      aliases 'tf'
+      filenames '*.tf', '*.tfvars', '*.tofu'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          terraform module provider variable resource data provisioner output
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          var local
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w()
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      def self.builtins
+        @builtins ||= %w()
+      end
+
+      state :strings do
+        rule %r/\\./, Str::Escape
+        rule %r/(\$[\$]+|%[%]+)(\{)/, Str
+        rule %r/\$\{/ do
+          token Punctuation
+          push :interpolation
+        end
+      end
+
+      state :dq do
+        rule %r/[^\\"\$]+/, Str::Double
+        mixin :strings
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        rule %r/[^\\'\$]+/, Str::Single
+        mixin :strings
+        rule %r/'/, Str::Single, :pop!
+      end
+
+      state :heredoc do
+        rule %r/\n/, Str::Heredoc, :heredoc_nl
+        rule %r/[^$\n]+/, Str::Heredoc
+        rule %r/[$]/, Str::Heredoc
+        mixin :strings
+      end
+
+      state :interpolation do
+        rule %r/\}/ do
+          token Punctuation
+          pop!
+        end
+
+        mixin :expression
+      end
+
+      state :regexps do
+        rule %r/"\// do
+          token Str::Delimiter
+          goto :regexp_inner
+        end
+      end
+
+      state :regexp_inner do
+        rule %r/[^"\/\\]+/, Str::Regex
+        rule %r/\\./, Str::Regex
+        rule %r/\/"/, Str::Delimiter, :pop!
+        rule %r/["\/]/, Str::Regex
+      end
+
+      id = /[$a-z_\-][a-z0-9_\-]*/io
+
+      state :expression do
+        mixin :regexps
+        mixin :primitives
+        rule %r/\s+/, Text
+
+        rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | == | != )x, Operator
+        rule %r([-<>+*%&|\^/!=?:]=?), Operator
+        rule %r/[(\[,]/, Punctuation
+        rule %r/[)\].]/, Punctuation
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          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
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class TeX < RegexLexer
+      title "TeX"
+      desc "The TeX typesetting system"
+      tag 'tex'
+      aliases 'TeX', 'LaTeX', 'latex'
+
+      filenames '*.tex', '*.aux', '*.toc', '*.sty', '*.cls'
+      mimetypes 'text/x-tex', 'text/x-latex'
+
+      def self.detect?(text)
+        return true if text =~ /\A\s*\\(documentclass|input|documentstyle|relax|ProvidesPackage|ProvidesClass)/
+      end
+
+      command = /\\([a-z]+|\s+|.)/i
+
+      state :general do
+        rule %r/%.*$/, Comment
+        rule %r/[{}&_^]/, Punctuation
+      end
+
+      state :root do
+        rule %r/\\\[/, Punctuation, :displaymath
+        rule %r/\\\(/, Punctuation, :inlinemath
+        rule %r/\$\$/, Punctuation, :displaymath
+        rule %r/\$/, Punctuation, :inlinemath
+        rule %r/\\(begin|end)\{.*?\}/, Name::Tag
+
+        rule %r/(\\verb)\b(\S)(.*?)(\2)/ do
+          groups Name::Builtin, Keyword::Pseudo, Str::Other, Keyword::Pseudo
+        end
+
+        rule command, Keyword, :command
+        mixin :general
+        rule %r/[^\\$%&_^{}]+/, Text
+      end
+
+      state :math do
+        rule command, Name::Variable
+        mixin :general
+        rule %r/[0-9]+/, Num
+        rule %r/[-=!+*\/()\[\]]/, Operator
+        rule %r/[^=!+*\/()\[\]\\$%&_^{}0-9-]+/, Name::Builtin
+      end
+
+      state :inlinemath do
+        rule %r/\\\)/, Punctuation, :pop!
+        rule %r/\$/, Punctuation, :pop!
+        mixin :math
+      end
+
+      state :displaymath do
+        rule %r/\\\]/, Punctuation, :pop!
+        rule %r/\$\$/, Punctuation, :pop!
+        rule %r/\$/, Name::Builtin
+        mixin :math
+      end
+
+      state :command do
+        rule %r/\[.*?\]/, Name::Attribute
+        rule %r/\*/, Keyword
+        rule(//) { pop! }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Thrift < RegexLexer
+      title "Thrift"
+      desc "Apache Thrift interface definition language"
+      tag 'thrift'
+      aliases 'apache-thrift'
+      filenames '*.thrift'
+      mimetypes 'text/x-thrift', 'application/x-thrift'
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          include cpp_include namespace const typedef enum struct union
+          exception service
+        )
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          async cpp_type extends oneway optional required throws
+          xsd_all xsd_attrs xsd_nillable xsd_optional
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          binary bool byte double i8 i16 i32 i64 list map set string uuid void
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(false true)
+      end
+
+      id = /[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z0-9_]+)*/
+      namespace_name = /[a-zA-Z_][a-zA-Z0-9_.-]*/
+      double = /[+-]?(?:(?:\d+\.\d+|\.\d+)(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+)/
+
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r/#.*$/, Comment::Single
+        rule %r{//.*$}, Comment::Single
+        rule %r{/\*}, Comment::Multiline, :comment
+      end
+
+      state :comment do
+        rule %r/[^*]+/, Comment::Multiline
+        rule %r/\*+\//, Comment::Multiline, :pop!
+        rule %r/\*+/, Comment::Multiline
+      end
+
+      state :namespace_scope do
+        mixin :comments_and_whitespace
+
+        rule %r/\*/ do
+          token Punctuation
+          goto :namespace_name
+        end
+
+        rule id do
+          token Keyword::Namespace
+          goto :namespace_name
+        end
+
+        rule(//) { pop! }
+      end
+
+      state :namespace_name do
+        mixin :comments_and_whitespace
+
+        rule namespace_name do
+          token Name::Namespace
+          pop!
+        end
+
+        rule(//) { pop! }
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+
+        rule %r/(namespace)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :namespace_scope
+        end
+
+        rule %r/((?:enum|exception|service|struct|union))(\s+)(#{id})/ do
+          groups Keyword::Declaration, Text, Name::Class
+        end
+
+        rule %r/"(?:\\.|[^"\\\n])*"/, Str::Double
+        rule %r/'(?:\\.|[^'\\\n])*'/, Str::Single
+
+        rule %r/[+-]?0x[0-9a-f]+/i, Num::Hex
+        rule double, Num::Float
+        rule %r/[+-]?\d+/, Num::Integer
+
+        rule id do |m|
+          if self.class.declarations.include?(m[0])
+            token Keyword::Declaration
+          elsif self.class.keywords.include?(m[0])
+            token Keyword
+          elsif self.class.types.include?(m[0])
+            token Keyword::Type
+          elsif self.class.constants.include?(m[0])
+            token Keyword::Constant
+          else
+            token Name
+          end
+        end
+
+        rule %r/[&=+\-]/, Operator
+        rule %r/[:;,{}\(\)<>\[\]]/, Punctuation
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class TOML < RegexLexer
+      title "TOML"
+      desc 'the TOML configuration format (https://github.com/toml-lang/toml)'
+      tag 'toml'
+
+      filenames '*.toml', 'Pipfile', 'poetry.lock'
+      mimetypes 'text/x-toml'
+
+      state :root do
+        mixin :whitespace
+
+        mixin :key
+
+        rule %r/(=)(\s*)/ do
+          groups Operator, Text::Whitespace
+          push :value
+        end
+
+        rule %r/\[\[?/, Keyword, :table_key
+      end
+
+      state :key do
+        rule %r/[A-Za-z0-9_-]+/, Name
+
+        rule %r/"/, Str, :dq
+        rule %r/'/, Str, :sq
+        rule %r/\./, Punctuation
+      end
+
+      state :table_key do
+        rule %r/[A-Za-z0-9_-]+/, Name
+
+        rule %r/"/, Str, :dq
+        rule %r/'/, Str, :sq
+        rule %r/\./, Keyword
+        rule %r/\]\]?/, Keyword, :pop!
+        rule %r/[ \t]+/, Text::Whitespace
+      end
+
+      state :value do
+        rule %r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date, :pop!
+        rule %r/\d\d:\d\d:\d\d(\.\d+)?/, Literal::Date, :pop!
+        rule %r/[+-]?\d+(?:_\d+)*\.\d+(?:_\d+)*(?:[eE][+-]?\d+(?:_\d+)*)?/, Num::Float, :pop!
+        rule %r/[+-]?\d+(?:_\d+)*[eE][+-]?\d+(?:_\d+)*/, Num::Float, :pop!
+        rule %r/[+-]?(?:nan|inf)/, Num::Float, :pop!
+        rule %r/0x\h+(?:_\h+)*/, Num::Hex, :pop!
+        rule %r/0o[0-7]+(?:_[0-7]+)*/, Num::Oct, :pop!
+        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin, :pop!
+        rule %r/[+-]?\d+(?:_\d+)*/, Num::Integer, :pop!
+
+        rule %r/"""/, Str, [:pop!, :mdq]
+        rule %r/"/, Str, [:pop!, :dq]
+        rule %r/'''/, Str, [:pop!, :msq]
+        rule %r/'/, Str, [:pop!, :sq]
+
+        rule %r/(true|false)/, Keyword::Constant, :pop!
+        rule %r/\[/, Punctuation, [:pop!, :array]
+        rule %r/\{/, Punctuation, [:pop!, :inline]
+      end
+
+      state :dq do
+        rule %r/"/, Str, :pop!
+        rule %r/\n/, Error, :pop!
+        mixin :esc_str
+        rule %r/[^\\"\n]+/, Str
+      end
+
+      state :mdq do
+        rule %r/"""/, Str, :pop!
+        mixin :esc_str
+        rule %r/[^\\"]+/, Str
+        rule %r/"+/, Str
+      end
+
+      state :sq do
+        rule %r/'/, Str, :pop!
+        rule %r/\n/, Error, :pop!
+        rule %r/[^'\n]+/, Str
+      end
+
+      state :msq do
+        rule %r/'''/, Str, :pop!
+        rule %r/[^']+/, Str
+        rule %r/'+/, Str
+      end
+
+      state :esc_str do
+        rule %r/\\[0t\tn\n "\\r]/, Str::Escape
+      end
+
+      state :array do
+        mixin :whitespace
+        rule %r/,/, Punctuation
+
+        rule %r/\]/, Punctuation, :pop!
+
+        rule %r//, Token, :value
+      end
+
+      state :inline do
+        rule %r/[ \t]+/, Text::Whitespace
+
+        mixin :key
+        rule %r/(=)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :value
+        end
+
+        rule %r/,/, Punctuation
+        rule %r/\}/, Punctuation, :pop!
+      end
+
+      state :whitespace do
+        rule %r/\s+/, Text
+        rule %r/#.*?$/, Comment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'jsx'
+require_relative 'typescript/common'
+
+module Rouge
+  module Lexers
+    class TSX < JSX
+      extend TypescriptCommon
+
+      title 'TSX'
+      desc 'TypeScript-compatible JSX (www.typescriptlang.org/docs/handbook/jsx.html)'
+
+      tag 'tsx'
+      filenames '*.tsx'
+
+      prepend :element_name do
+        rule %r/(\w+)(,)/ do
+          groups Name::Other, Punctuation
+          pop! 3
+        end
+
+        rule %r/</, Punctuation, :type
+      end
+
+      state :type do
+        mixin :object
+        rule %r/>/, Punctuation, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class TTCN3 < RegexLexer
+      title "TTCN3"
+      desc "The TTCN3 programming language (ttcn-3.org)"
+
+      tag 'ttcn3'
+      filenames '*.ttcn', '*.ttcn3'
+      mimetypes 'text/x-ttcn3', 'text/x-ttcn'
+
+      def self.keywords
+        @keywords ||= %w(
+          module import group type port component signature external
+          execute const template function altstep testcase var timer if
+          else select case for while do label goto start stop return
+          break int2char int2unichar int2bit int2enum int2hex int2oct
+          int2str int2float float2int char2int char2oct unichar2int
+          unichar2oct bit2int bit2hex bit2oct bit2str hex2int hex2bit
+          hex2oct hex2str oct2int oct2bit oct2hex oct2str oct2char
+          oct2unichar str2int str2hex str2oct str2float enum2int
+          any2unistr lengthof sizeof ispresent ischosen isvalue isbound
+          istemplatekind regexp substr replace encvalue decvalue
+          encvalue_unichar decvalue_unichar encvalue_o decvalue_o
+          get_stringencoding remove_bom rnd hostid send receive
+          setverdict
+        )
+      end
+
+      def self.reserved
+        @reserved ||= %w(
+          all alt apply assert at configuration conjunct const control
+          delta deterministic disjunct duration fail finished fuzzy from
+          history implies inconc inv lazy mod mode notinv now omit
+          onentry onexit par pass prev realtime seq setstate static
+          stepsize stream timestamp until values wait
+        )
+      end
+
+      def self.types
+        @types ||= %w(
+          anytype address boolean bitstring charstring hexstring octetstring
+          component enumerated float integer port record set of union universal
+        )
+      end
+
+      id = /[a-zA-Z_]\w*/
+      digit = /\d_+\d|\d/
+      bin_digit = /[01]_+[01]|[01]/
+      oct_digit = /[0-7]_+[0-7]|[0-7]/
+      hex_digit = /\h_+\h|\h/
+
+      state :statements do
+        rule %r/\n+/m, Text
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
+
+        rule %r(//(\\.|.)*?$), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+
+        rule %r/"/, Str, :string
+        rule %r/'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
+
+        rule %r/#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/i, Num::Float
+        rule %r/'#{bin_digit}+'B/i, Num::Bin
+        rule %r/'#{hex_digit}+'H/i, Num::Hex
+        rule %r/'#{oct_digit}+'O/i, Num::Oct
+        rule %r/#{digit}+/i, Num::Integer
+
+        rule %r([~!%^&*+:=\|?<>/-]), Operator
+        rule %r/[()\[\]{},.;:]/, Punctuation
+
+        rule %r/(?:true|false|null)\b/, Name::Builtin
+
+        rule id do |m|
+          name = m[0]
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.class.types.include? name
+            token Keyword::Type
+          elsif self.class.reserved.include? name
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+      end
+
+      state :root do
+        rule %r/module\b/, Keyword::Declaration, :module
+        rule %r/import\b/, Keyword::Namespace, :import
+
+        mixin :statements
+      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
+
+      state :module do
+        rule %r/\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r/\s+/m, Text
+        rule %r/[\w.]+\*?/, Name::Namespace, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Tulip < RegexLexer
+      desc 'the tulip programming language (twitter.com/tuliplang)'
+      tag 'tulip'
+      aliases 'tulip'
+
+      filenames '*.tlp'
+
+      mimetypes 'text/x-tulip', 'application/x-tulip'
+
+      def self.detect?(text)
+        return true if text.shebang? 'tulip'
+      end
+
+      id = /[a-z][\w-]*/i
+      upper_id = /[A-Z][\w-]*/
+
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r/#.*?$/, Comment
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+
+        rule %r/@#{id}/, Keyword
+
+
+        rule %r/(\\#{id})([{])/ do
+          groups Name::Function, Str
+          push :nested_string
+        end
+
+        rule %r/([+]#{id})([{])/ do
+          groups Name::Decorator, Str
+          push :nested_string
+        end
+
+        rule %r/\\#{id}/, Name::Function
+        rule %r/[+]#{id}/, Name::Decorator
+
+        rule %r/"[{]/, Str, :dqi
+        rule %r/"/, Str, :dq
+
+        rule %r/'{/, Str, :nested_string
+        rule %r/'#{id}/, Str
+
+        rule %r/[.]#{id}/, Name::Tag
+        rule %r/[$]#{id}?/, Name::Variable
+        rule %r/-#{id}:?/, Name::Label
+        rule %r/%#{id}/, Name::Function
+        rule %r/`#{id}/, Operator::Word
+
+        rule %r/[?~%._>,!\[\]:{}()=;\/-]/, Punctuation
+
+        rule %r/[0-9]+([.][0-9]+)?/, Num
+
+        rule %r/#{id}/, Name
+
+        rule %r/</, Comment::Preproc, :angle_brackets
+      end
+
+      state :dq do
+        rule %r/[^\\"]+/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/\\./, Str::Escape
+      end
+
+      state :dqi do
+        rule %r/[$][(]/, Str::Interpol, :interp_root
+        rule %r/[{]/, Str, :dqi
+        rule %r/[}]/, Str, :pop!
+        rule %r/[^{}$]+/, Str
+        rule %r/./, Str
+      end
+
+      state :interp_root do
+        rule %r/[)]/, Str::Interpol, :pop!
+        mixin :interp
+      end
+
+      state :interp do
+        rule %r/[(]/, Punctuation, :interp
+        rule %r/[)]/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :nested_string do
+        rule %r/\\./, Str::Escape
+        rule(/{/) { token Str; push :nested_string }
+        rule(/}/) { token Str; pop! }
+        rule(/[^{}\\]+/) { token Str }
+      end
+
+      state :angle_brackets do
+        mixin :comments_and_whitespace
+        rule %r/>/, Comment::Preproc, :pop!
+        rule %r/[*:]/, Punctuation
+        rule %r/#{upper_id}/, Keyword::Type
+        rule %r/#{id}/, Name::Variable
+      end
+    end
+  end
+end