nano-clean-pkg 0.0.1

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

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Awk < RegexLexer
+      title "Awk"
+      desc "pattern-directed scanning and processing language"
+
+      tag 'awk'
+      filenames '*.awk'
+      mimetypes 'application/x-awk'
+
+      def self.detect?(text)
+        return true if text.shebang?('awk')
+      end
+
+      id = /[$a-zA-Z_][a-zA-Z0-9_]*/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          if else while for do break continue return next nextfile delete
+          exit print printf getline
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(function)
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(BEGIN END)
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          CONVFMT FS NF NR FNR FILENAME RS OFS ORS OFMT SUBSEP ARGC ARGV
+          ENVIRON
+        )
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          exp log sqrt sin cos atan2 length rand srand int substr index match
+          split sub gsub sprintf system tolower toupper
+        )
+      end
+
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r(#.*?$), Comment::Single
+      end
+
+      state :expr_start do
+        mixin :comments_and_whitespace
+        rule %r(/) do
+          token Str::Regex
+          goto :regex
+        end
+        rule %r//, Text, :pop!
+      end
+
+      state :regex do
+        rule %r(/) do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r([^/]\n), Error, :pop!
+
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_end do
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        # specially highlight / in a group to indicate that it doesn't
+        # close the regex
+        rule %r(/), Str::Escape
+
+        rule %r([^/]\n) do
+          token Error
+          pop! 2
+        end
+
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :bad_regex do
+        rule %r/[^\n]+/, Error, :pop!
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+        rule %r((?<=\n)(?=\s|/)), Text, :expr_start
+        rule %r([-<>+*/%\^!=]=?|in\b|\+\+|--|\|), Operator, :expr_start
+        rule %r(&&|\|\||~!?), Operator, :expr_start
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
+
+        rule %r/[?]/ do
+          token Punctuation
+          push :ternary
+          push :expr_start
+        end
+
+        rule %r/[{}]/, Punctuation, :statement
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+            push :expr_start
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :expr_start
+          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
+          elsif m[0] =~ /^\$/
+            token Name::Variable
+          else
+            token Name::Other
+          end
+        end
+
+        rule %r/[0-9]+\.[0-9]+/, Num::Float
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\[\\"]|[^"])*"/, Str::Double
+        rule %r/:/, Punctuation
+      end
+
+      state :statement do
+        rule %r/[{}]/, Punctuation
+        mixin :expr_start
+      end
+
+      state :ternary do
+        rule %r/:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
+        mixin :root
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Batchfile < RegexLexer
+      title "Batchfile"
+      desc "Windows Batch File"
+
+      tag 'batchfile'
+      aliases 'bat', 'batch', 'dosbatch', 'winbatch'
+      filenames '*.bat', '*.cmd'
+
+      mimetypes 'application/bat', 'application/x-bat', 'application/x-msdos-program'
+
+      def self.keywords
+        @keywords ||= %w(
+          if else for in do goto call exit
+        )
+      end
+
+      def self.operator_words
+        @operator_words ||= %w(
+          exist defined errorlevel cmdextversion not equ neq lss leq gtr geq
+        )
+      end
+
+      def self.devices
+        @devices ||= %w(
+          con prn aux nul com1 com2 com3 com4 com5 com6 com7 com8 com9 lpt1 lpt2
+          lpt3 lpt4 lpt5 lpt6 lpt7 lpt8 lpt9
+        )
+      end
+
+      def self.builtin_commands
+        @builtin_commands ||= %w(
+          assoc attrib break bcdedit cacls cd chcp chdir chkdsk chkntfs choice
+          cls cmd color comp compact convert copy date del dir diskpart doskey
+          dpath driverquery echo endlocal erase fc find findstr format fsutil
+          ftype gpresult graftabl help icacls label md mkdir mklink mode more
+          move openfiles path pause popd print prompt pushd rd recover ren
+          rename replace rmdir robocopy setlocal sc schtasks shift shutdown sort
+          start subst systeminfo takeown tasklist taskkill time timeout title
+          tree type ver verify vol xcopy waitfor wmic
+        )
+      end
+
+      def self.other_commands
+        @other_commands ||= %w(
+          addusers admodcmd ansicon arp at bcdboot bitsadmin browstat certreq
+          certutil change cidiag cipher cleanmgr clip cmdkey compress convertcp
+          coreinfo csccmd csvde cscript curl debug defrag delprof deltree devcon
+          diamond dirquota diruse diskshadow diskuse dism dnscmd dsacls dsadd
+          dsget dsquery dsmod dsmove dsrm dsmgmt dsregcmd edlin eventcreate
+          expand extract fdisk fltmc forfiles freedisk ftp getmac gpupdate
+          hostname ifmember inuse ipconfig kill lgpo lodctr logman logoff
+          logtime makecab mapisend mbsacli mem mountvol moveuser msg mshta
+          msiexec msinfo32 mstsc nbtstat net net1 netdom netsh netstat nlsinfo
+          nltest now nslookup ntbackup ntdsutil ntoskrnl ntrights nvspbind
+          pathping perms ping portqry powercfg pngout pnputil printbrm prncnfg
+          prnmngr procdump psexec psfile psgetsid psinfo pskill pslist
+          psloggedon psloglist pspasswd psping psservice psshutdown pssuspend
+          qbasic qgrep qprocess query quser qwinsta rasdial reg reg1 regdump
+          regedt32 regsvr32 regini reset restore rundll32 rmtshare route rpcping
+          run runas scandisk setspn setx sfc share shellrunas shortcut sigcheck
+          sleep slmgr strings subinacl sysmon telnet tftp tlist touch tracerpt
+          tracert tscon tsdiscon tskill tttracer typeperf tzutil undelete
+          unformat verifier vmconnect vssadmin w32tm wbadmin wecutil wevtutil
+          wget where whoami windiff winrm winrs wpeutil wpr wusa wuauclt wscript
+        )
+      end
+
+      def self.attributes
+        @attributes ||= %w(
+          on off disable enableextensions enabledelayedexpansion
+        )
+      end
+
+      state :basic do
+        # Comments
+        rule %r/@?\brem\b.*$/i, Comment
+
+        # Empty Labels
+        rule %r/^::.*$/, Comment
+
+        # Labels
+        rule %r/:[a-z]+/i, Name::Label
+
+        rule %r/([a-z]\w*)(\.exe|com|bat|cmd|msi)?/i do |m|
+          if self.class.devices.include? m[1]
+            groups Keyword::Reserved, Error
+          elsif self.class.keywords.include? m[1]
+            groups Keyword, Error
+          elsif self.class.operator_words.include? m[1]
+            groups Operator::Word, Error
+          elsif self.class.builtin_commands.include? m[1]
+            token Name::Builtin
+          elsif self.class.other_commands.include? m[1]
+            token Name::Builtin
+          elsif self.class.attributes.include? m[1]
+            groups Name::Attribute, Error
+          elsif "set".casecmp m[1]
+            groups Keyword::Declaration, Error
+          else
+            token Text
+          end
+        end
+
+        rule %r/((?:[\/\+]|--?)[a-z]+)\s*/i, Name::Attribute
+
+        mixin :expansions
+
+        rule %r/[<>&|(){}\[\]\-+=;,~?*]/, Operator
+      end
+
+      state :escape do
+        rule %r/\^./m, Str::Escape
+      end
+
+      state :expansions do
+        # Normal and Delayed expansion
+        rule %r/[%!]+([a-z_$@#]+)[%!]+/i, Name::Variable
+        # For Variables
+        rule %r/(\%+~?[a-z]+\d?)/i, Name::Variable::Magic
+      end
+
+      state :double_quotes do
+        mixin :escape
+        rule %r/["]/, Str::Double, :pop!
+        mixin :expansions
+        rule %r/[^\^"%!]+/, Str::Double
+      end
+
+      state :single_quotes do
+        mixin :escape
+        rule %r/[']/, Str::Single, :pop!
+        mixin :expansions
+        rule %r/[^\^'%!]+/, Str::Single
+      end
+
+      state :backtick do
+        mixin :escape
+        rule %r/[`]/, Str::Backtick, :pop!
+        mixin :expansions
+        rule %r/[^\^`%!]+/, Str::Backtick
+      end
+
+      state :data do
+        rule %r/\s+/, Text
+        rule %r/0x[0-9a-f]+/i, Literal::Number::Hex
+        rule %r/[0-9]/, Literal::Number
+        rule %r/["]/, Str::Double, :double_quotes
+        rule %r/[']/, Str::Single, :single_quotes
+        rule %r/[`]/, Str::Backtick, :backtick
+        rule %r/[^\s&|()\[\]{}\^=;!%+\-,"'`~?*]+/, Text
+        mixin :escape
+      end
+
+      state :root do
+        mixin :basic
+        mixin :data
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class BBCBASIC < RegexLexer
+      title "BBCBASIC"
+      desc "BBC BASIC syntax"
+      tag 'bbcbasic'
+      filenames '*,fd1'
+
+      def self.punctuation
+        @punctuation ||= %w(
+          [,;'~] SPC TAB
+        )
+      end
+
+      def self.function
+        @function ||= %w(
+          ABS ACS ADVAL ASC ASN ATN BEATS BEAT BGET# CHR\$ COS COUNT DEG DIM
+          EOF# ERL ERR EVAL EXP EXT# FN GET\$# GET\$ GET HIMEM INKEY\$ INKEY
+          INSTR INT LEFT\$ LEN LN LOG LOMEM MID\$ OPENIN OPENOUT OPENUP PAGE
+          POINT POS PTR# RAD REPORT\$ RIGHT\$ RND SGN SIN SQR STR\$ STRING\$ SUM
+          SUMLEN TAN TEMPO TIME\$ TIME TOP USR VAL VPOS
+        )
+      end
+
+      def self.statement
+        @statement ||= %w(
+          BEATS BPUT# CALL CASE CHAIN CLEAR CLG CLOSE# CLS COLOR COLOUR DATA
+          ELSE ENDCASE ENDIF ENDPROC ENDWHILE END ENVELOPE FOR GCOL GOSUB GOTO
+          IF INSTALL LET LIBRARY MODE NEXT OFF OF ON ORIGIN OSCI OTHERWISE
+          OVERLAY PLOT PRINT# PRINT PROC QUIT READ REPEAT REPORT RETURN SOUND
+          STEP STEREO STOP SWAP SYS THEN TINT TO VDU VOICES VOICE UNTIL WAIT
+          WHEN WHILE WIDTH
+        )
+      end
+
+      def self.operator
+        @operator ||= %w(
+          << <= <> < >= >>> >> > [-!$()*+/=?^|] AND DIV EOR MOD NOT OR
+        )
+      end
+
+      def self.constant
+        @constant ||= %w(
+          FALSE TRUE
+        )
+      end
+
+      state :expression do
+        rule %r/#{BBCBASIC.function.join('|')}/o, Name::Builtin  # function or pseudo-variable
+        rule %r/#{BBCBASIC.operator.join('|')}/o, Operator
+        rule %r/#{BBCBASIC.constant.join('|')}/o, Name::Constant
+        rule %r/"[^"]*"/o, Literal::String
+        rule %r/[a-z_`][\w`]*[$%]?/io, Name::Variable
+        rule %r/@%/o, Name::Variable
+        rule %r/[\d.]+/o, Literal::Number
+        rule %r/%[01]+/o, Literal::Number::Bin
+        rule %r/&[\h]+/o, Literal::Number::Hex
+      end
+
+      state :root do
+        rule %r/(:+)( *)(\*)(.*)/ do
+          groups Punctuation, Text, Keyword, Text # CLI command
+        end
+        rule %r/(\n+ *)(\*)(.*)/ do
+          groups Text, Keyword, Text # CLI command
+        end
+        rule %r/(ELSE|OTHERWISE|REPEAT|THEN)( *)(\*)(.*)/ do
+          groups Keyword, Text, Keyword, Text # CLI command
+        end
+        rule %r/[ \n]+/o, Text
+        rule %r/:+/o, Punctuation
+        rule %r/[\[]/o, Keyword, :assembly1
+        rule %r/REM *>.*/o, Comment::Special
+        rule %r/REM.*/o, Comment
+        rule %r/(?:#{BBCBASIC.statement.join('|')}|CIRCLE(?: *FILL)?|DEF *(?:FN|PROC)|DRAW(?: *BY)?|DIM(?!\()|ELLIPSE(?: *FILL)?|ERROR(?: *EXT)?|FILL(?: *BY)?|INPUT(?:#| *LINE)?|LINE(?: *INPUT)?|LOCAL(?: *DATA| *ERROR)?|MOUSE(?: *COLOUR| *OFF| *ON| *RECTANGLE| *STEP| *TO)?|MOVE(?: *BY)?|ON(?! *ERROR)|ON *ERROR *(?:LOCAL|OFF)?|POINT(?: *BY)?(?!\()|RECTANGE(?: *FILL)?|RESTORE(?: *DATA| *ERROR)?|TRACE(?: *CLOSE| *ENDPROC| *OFF| *STEP(?: *FN| *ON| *PROC)?| *TO)?)/o, Keyword
+        mixin :expression
+        rule %r/#{BBCBASIC.punctuation.join('|')}/o, Punctuation
+      end
+
+      # Assembly statements are parsed as
+      # {label} {directive|opcode |']' {expressions}} {comment}
+      # Technically, you don't need whitespace between opcodes and arguments,
+      # but this is rare in uncrunched source and trying to enumerate all
+      # possible opcodes here is impractical so we colour it as though
+      # the whitespace is required. Opcodes and directives can only easily be
+      # distinguished from the symbols that make up expressions by looking at
+      # their position within the statement. Similarly, ']' is treated as a
+      # keyword at the start of a statement or as punctuation elsewhere. This
+      # requires a two-state state machine.
+
+      state :assembly1 do
+        rule %r/ +/o, Text
+        rule %r/]/o, Keyword, :pop!
+        rule %r/[:\n]/o, Punctuation
+        rule %r/\.[a-z_`][\w`]*%? */io, Name::Label
+        rule %r/(?:REM|;)[^:\n]*/o, Comment
+        rule %r/[^ :\n]+/o, Keyword, :assembly2
+      end
+
+      state :assembly2 do
+        rule %r/ +/o, Text
+        rule %r/[:\n]/o, Punctuation, :pop!
+        rule %r/(?:REM|;)[^:\n]*/o, Comment, :pop!
+        mixin :expression
+        rule %r/[!#,@\[\]^{}]/, Punctuation
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# Regular expressions based on https://github.com/SaswatPadhi/prismjs-bibtex
+# and https://github.com/alecthomas/chroma/blob/master/lexers/b/bibtex.go
+
+module Rouge
+  module Lexers
+    class BibTeX < RegexLexer
+      title 'BibTeX'
+      desc "BibTeX"
+      tag 'bibtex'
+      aliases 'bib'
+      filenames '*.bib'
+
+      valid_punctuation = Regexp.quote("@!$&.\\:;<>?[]^`|~*/+-")
+      valid_name = /[a-z_#{valid_punctuation}][\w#{valid_punctuation}]*/io
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/@(#{valid_name})/o do |m|
+          match = m[1].downcase
+
+          if match == "comment"
+            token Comment
+          elsif match == "preamble"
+            token Name::Class
+            push :closing_brace
+            push :value
+            push :opening_brace
+          elsif match == "string"
+            token Name::Class
+            push :closing_brace
+            push :field
+            push :opening_brace
+          else
+            token Name::Class
+            push :closing_brace
+            push :command_body
+            push :opening_brace
+          end
+        end
+
+        rule %r/.+/, Comment
+      end
+
+      state :opening_brace do
+        mixin :whitespace
+        rule %r/[{(]/, Punctuation, :pop!
+      end
+
+      state :closing_brace do
+        mixin :whitespace
+        rule %r/[})]/, Punctuation, :pop!
+      end
+
+      state :command_body do
+        mixin :whitespace
+        rule %r/[^\s\,\}]+/ do
+          token Name::Label
+          pop!
+          push :fields
+        end
+      end
+
+      state :fields do
+        mixin :whitespace
+        rule %r/,/, Punctuation, :field
+        rule(//) { pop! }
+      end
+
+      state :field do
+        mixin :whitespace
+        rule valid_name do
+          token Name::Attribute
+          push :value
+          push :equal_sign
+        end
+        rule(//) { pop! }
+      end
+
+      state :equal_sign do
+        mixin :whitespace
+        rule %r/=/, Punctuation, :pop!
+      end
+
+      state :value do
+        mixin :whitespace
+        rule valid_name, Name::Variable
+        rule %r/"/, Literal::String, :quoted_string
+        rule %r/\{/, Literal::String, :braced_string
+        rule %r/\d+/, Literal::Number
+        rule %r/#/, Punctuation
+        rule(//) { pop! }
+      end
+
+      state :quoted_string do
+        rule %r/\{/, Literal::String, :braced_string
+        rule %r/"/, Literal::String, :pop!
+        rule %r/[^\{\"]+/, Literal::String
+      end
+
+      state :braced_string do
+        rule %r/\{/, Literal::String, :braced_string
+        rule %r/\}/, Literal::String, :pop!
+        rule %r/[^\{\}]+/, Literal::String
+      end
+
+      state :whitespace do
+        rule %r/\s+/, Text
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+module Rouge
+  module Lexers
+    class Bicep < Rouge::RegexLexer
+      tag 'bicep'
+      filenames '*.bicep'
+
+      title "Bicep"
+      desc 'Bicep is a domain-specific language (DSL) that uses declarative syntax to deploy Azure resources.'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          as assert existing extends extension false for from func if import in metadata module
+          none null output param provider resource targetScope test true type using var void with
+        )
+      end
+
+      def self.datatypes
+        @datatypes ||= Set.new %w(array bool int object string)
+      end
+
+      def self.functions
+        @functions ||= Set.new %w(
+          array base64 base64ToJson base64ToString bool cidrHost cidrSubnet concat contains dataUri
+          dataUriToString dateTimeAdd dateTimeFromEpoch dateTimeToEpoch deployer deployment empty endsWith
+          environment extensionResourceId fail filter first flatten format getSecret groupBy guid indexOf int
+          intersection items join json last lastIndexOf length list* listAccountSas listKeys listSecrets loadFileAsBase64
+          loadJsonContent loadTextContent loadYamlContent managementGroup managementGroupResourceId map mapValue max min
+          newGuid objectKeys padLeft parseCidr pickZones range readEnvironmentVariable reduce reference replace resourceGroup
+          resourceId shallowMerge skip sort split startsWith string subscription subscriptionResourceId substring take tenant
+          tenantResourceId toLogicalZone toLower toObject toPhysicalZone toUpper trim union uniqueString uri uriComponent
+          uriComponentToString utcNow
+        )
+      end
+
+      operators = %w(+ - * / % < <= > >= == != =~ !~ && || ! ?? ... .?)
+
+      punctuations = %w(( ) { } [ ] , : ; = .)
+
+      state :root do
+        mixin :comments
+
+        # Match strings
+        rule %r/'/, Str::Single, :string
+
+        # Match numbers
+        rule %r/\b\d+\b/, Num
+
+        # Rules for sets of reserved keywords
+        rule %r/\b\w+\b/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.datatypes.include? m[0]
+            token Keyword::Type
+          elsif self.class.functions.include? m[0]
+            token Name::Function
+          else
+            token Name
+          end
+        end
+
+        # Match operators
+        rule %r/#{operators.map { |o| Regexp.escape(o) }.join('|')}/, Operator
+
+        # Enter a state when encountering an opening curly bracket
+        rule %r/{/, Punctuation::Indicator, :block
+
+        # Match punctuation
+        rule %r/#{punctuations.map { |p| Regexp.escape(p) }.join('|')}/, Punctuation
+
+        # Match identifiers
+        rule %r/[a-zA-Z_]\w*/, Name
+
+        # Match decorators
+        rule %r/@[a-zA-Z_]\w*/, Name::Decorator
+
+        # Ignore whitespace
+        rule %r/\s+/, Text
+      end
+
+      state :comments do
+        rule %r(//[^\n\r]+), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+      end
+
+      state :string do
+        rule %r/[^'$}]+/, Str::Single
+        rule %r/\$(?!\{)/, Str::Single
+        rule %r/\$[\{]/, Str::Interpol, :interp
+        rule %r/\'/, Str::Single, :pop!
+        rule %r/\$+/, Str::Single
+      end
+
+      state :interp do
+        rule %r/\}/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      # State for matching code blocks between curly brackets
+      state :block do
+        # Match property names
+        rule %r/\b([a-zA-Z_]\w*)\b(?=\s*:)/, Name::Property
+
+        # Match closing curly brackets
+        rule %r/}/, Punctuation::Indicator, :pop!
+
+        # Include the root state for nested tokens
+        mixin :root
+      end
+    end
+  end
+end