nano-max-hub 0.0.1

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

@@ -0,0 +1,438 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Praat < RegexLexer
+      title "Praat"
+      desc "The Praat scripting language (praat.org)"
+
+      tag 'praat'
+
+      filenames '*.praat', '*.proc', '*.psc'
+
+      def self.detect?(text)
+        return true if text.shebang? 'praat'
+      end
+
+      def self.keywords
+        @keywords ||= %w(
+          if then else elsif elif endif fi for from to endfor endproc while
+          endwhile repeat until select plus minus demo assert stopwatch
+          nocheck nowarn noprogress editor endeditor clearinfo
+        )
+      end
+
+      def self.functions_string
+        @functions_string ||= %w(
+          backslashTrigraphsToUnicode$ chooseDirectory$ chooseReadFile$
+          chooseWriteFile$ date$ demoKey$ do$ environment$ extractLine$ extractWord$
+          fixed$ info$ left$ mid$ percent$ readFile$ replace$ replace_regex$ right$
+          selected$ string$ unicodeToBackslashTrigraphs$
+        )
+      end
+
+      def self.functions_numeric
+        @functions_numeric ||= %w(
+          abs appendFile appendFileLine appendInfo appendInfoLine arccos arccosh
+          arcsin arcsinh arctan arctan2 arctanh barkToHertz beginPause
+          beginSendPraat besselI besselK beta beta2 binomialP binomialQ boolean
+          ceiling chiSquareP chiSquareQ choice comment cos cosh createDirectory
+          deleteFile demoClicked demoClickedIn demoCommandKeyPressed
+          demoExtraControlKeyPressed demoInput demoKeyPressed
+          demoOptionKeyPressed demoShiftKeyPressed demoShow demoWaitForInput
+          demoWindowTitle demoX demoY differenceLimensToPhon do editor endPause
+          endSendPraat endsWith erb erbToHertz erf erfc exitScript exp
+          extractNumber fileReadable fisherP fisherQ floor gaussP gaussQ hash
+          hertzToBark hertzToErb hertzToMel hertzToSemitones imax imin
+          incompleteBeta incompleteGammaP index index_regex integer invBinomialP
+          invBinomialQ invChiSquareQ invFisherQ invGaussQ invSigmoid invStudentQ
+          length ln lnBeta lnGamma log10 log2 max melToHertz min minusObject
+          natural number numberOfColumns numberOfRows numberOfSelected
+          objectsAreIdentical option optionMenu pauseScript
+          phonToDifferenceLimens plusObject positive randomBinomial randomGauss
+          randomInteger randomPoisson randomUniform real readFile removeObject
+          rindex rindex_regex round runScript runSystem runSystem_nocheck
+          selectObject selected semitonesToHertz sentence sentencetext sigmoid
+          sin sinc sincpi sinh soundPressureToPhon sqrt startsWith studentP
+          studentQ tan tanh text variableExists word writeFile writeFileLine
+          writeInfo writeInfoLine
+        )
+      end
+
+      def self.functions_array
+        @functions_array ||= %w(
+          linear# randomGauss# randomInteger# randomUniform# zero#
+        )
+      end
+
+      def self.functions_matrix
+        @functions_matrix ||= %w(
+          linear## mul## mul_fast## mul_metal## mul_nt## mul_tn## mul_tt## outer## peaks##
+          randomGamma## randomGauss## randomInteger## randomUniform## softmaxPerRow##
+          solve## transpose## zero##
+        )
+      end
+
+      def self.functions_string_vector
+        @functions_string_vector ||= %w(
+          empty$# fileNames$# folderNames$# readLinesFromFile$# splitByWhitespace$#
+        )
+      end
+
+      def self.functions_builtin
+        @functions_builtin ||=
+          self.functions_string |
+          self.functions_numeric |
+          self.functions_array |
+          self.functions_matrix |
+          self.functions_string_vector
+      end
+
+      def self.objects
+        @objects ||= %w(
+          Activation AffineTransform AmplitudeTier Art Artword Autosegment
+          BarkFilter BarkSpectrogram CCA Categories Cepstrogram Cepstrum
+          Cepstrumc ChebyshevSeries ClassificationTable Cochleagram Collection
+          ComplexSpectrogram Configuration Confusion ContingencyTable Corpus
+          Correlation Covariance CrossCorrelationTable CrossCorrelationTableList
+          CrossCorrelationTables DTW DataModeler Diagonalizer Discriminant
+          Dissimilarity Distance Distributions DurationTier EEG ERP ERPTier
+          EditCostsTable EditDistanceTable Eigen Excitation Excitations
+          ExperimentMFC FFNet FeatureWeights FileInMemory FilesInMemory Formant
+          FormantFilter FormantGrid FormantModeler FormantPoint FormantTier
+          GaussianMixture HMM HMM_Observation HMM_ObservationSequence HMM_State
+          HMM_StateSequence HMMObservation HMMObservationSequence HMMState
+          HMMStateSequence Harmonicity ISpline Index Intensity IntensityTier
+          IntervalTier KNN KlattGrid KlattTable LFCC LPC Label LegendreSeries
+          LinearRegression LogisticRegression LongSound Ltas MFCC MSpline ManPages
+          Manipulation Matrix MelFilter MelSpectrogram MixingMatrix Movie Network
+          OTGrammar OTHistory OTMulti PCA PairDistribution ParamCurve Pattern
+          Permutation Photo Pitch PitchModeler PitchTier PointProcess Polygon
+          Polynomial PowerCepstrogram PowerCepstrum Procrustes RealPoint RealTier
+          ResultsMFC Roots SPINET SSCP SVD Salience ScalarProduct Similarity
+          SimpleString SortedSetOfString Sound Speaker Spectrogram Spectrum
+          SpectrumTier SpeechSynthesizer SpellingChecker Strings StringsIndex
+          Table TableOfReal TextGrid TextInterval TextPoint TextTier Tier
+          Transition VocalTract VocalTractTier Weight WordList
+        )
+      end
+
+      def self.variables_numeric
+        @variables_numeric ||= %w(
+          all average e left macintosh mono pi praatVersion right stereo
+          undefined unix windows
+        )
+      end
+
+      def self.variables_string
+        @variables_string ||= %w(
+          praatVersion$ tab$ shellDirectory$ homeDirectory$
+          preferencesDirectory$ newline$ temporaryDirectory$
+          defaultDirectory$
+        )
+      end
+
+      def self.object_attributes
+        @object_attributes ||= %w(
+          ncol nrow xmin ymin xmax ymax nx ny dx dy
+        )
+      end
+
+      state :root do
+        rule %r/(\s+)(#.*?$)/ do
+          groups Text, Comment::Single
+        end
+
+        rule %r/^#.*?$/, Comment::Single
+        rule %r/;[^\n]*/, Comment::Single
+        rule %r/\s+/, Text
+
+        rule %r/(\bprocedure)(\s+)/ do
+          groups Keyword, Text
+          push :procedure_definition
+        end
+
+        rule %r/(\bcall)(\s+)/ do
+          groups Keyword, Text
+          push :procedure_call
+        end
+
+        rule %r/@/, Name::Function, :procedure_call
+
+        mixin :function_call
+
+        rule %r/\b(?:select all)\b/, Keyword
+
+        rule %r/(\bform\b)(\s+)([^\n]+)/ do
+          groups Keyword, Text, Literal::String
+          push :old_form
+        end
+
+        rule %r/(print(?:line|tab)?|echo|exit|asserterror|pause|send(?:praat|socket)|include|execute|system(?:_nocheck)?)(\s+)/ do
+          groups Keyword, Text
+          push :string_unquoted
+        end
+
+        rule %r/(goto|label)(\s+)(\w+)/ do
+          groups Keyword, Text, Name::Label
+        end
+
+        mixin :variable_name
+        mixin :number
+        mixin :vector_literal
+
+        rule %r/"/, Literal::String, :string
+
+        rule %r/\b([A-Z][a-zA-Z0-9]+)(?=\s+\S+\n)/ do |m|
+          match = m[0]
+          if self.class.objects.include?(match)
+            token Name::Class
+            push :string_unquoted
+          else
+            token Keyword
+          end
+        end
+
+        rule %r/\b(?=[A-Z])/, Text, :command
+        rule %r/(\.{3}|[)(,\$])/, Punctuation
+
+        rule %r/[a_z]+/ do |m|
+          match = m[0]
+          if self.class.keywords.include?(match)
+            token Keyword
+          else
+            token Text
+          end
+        end
+      end
+
+      state :command do
+        rule %r/( ?([^\s:\.'])+ ?)/, Keyword
+        mixin :string_interpolated
+
+        rule %r/\.{3}/ do
+          token Keyword
+          pop!
+          push :old_arguments
+        end
+
+        rule %r/:/ do
+          token Keyword
+          pop!
+          push :comma_list
+        end
+
+        rule %r/[\s]/, Text, :pop!
+      end
+
+      state :procedure_call do
+        mixin :string_interpolated
+
+        rule %r/(:|\s*\()/, Punctuation, :pop!
+
+        rule %r/'/, Name::Function
+        rule %r/[^:\('\s]+/, Name::Function
+
+        rule %r/(?=\s+)/ do
+          token Text
+          pop!
+          push :old_arguments
+        end
+      end
+
+      state :procedure_definition do
+        rule %r/(:|\s*\()/, Punctuation, :pop!
+
+        rule %r/[^:\(\s]+/, Name::Function
+
+        rule %r/(\s+)/, Text, :pop!
+      end
+
+      state :function_call do
+        rule %r/\b([a-z][a-zA-Z0-9_.]+)(\$#|##|\$|#)?(?=\s*[:(])/ do |m|
+          match = m[0]
+          if self.class.functions_builtin.include?(match)
+            token Name::Function
+            push :function
+          elsif self.class.keywords.include?(match)
+            token Keyword
+          else
+            token Operator::Word
+          end
+        end
+      end
+
+      state :function do
+        rule %r/\s+/, Text
+
+        rule %r/(?::|\s*\()/ do
+          token Text
+          pop!
+          push :comma_list
+        end
+      end
+
+      state :comma_list do
+        rule %r/(\s*\n\s*)(\.{3})/ do
+          groups Text, Punctuation
+        end
+
+        rule %r/\s*[\]\})\n]/, Text, :pop!
+
+        rule %r/\s+/, Text
+        rule %r/"/, Literal::String, :string
+        rule %r/\b(if|then|else|fi|endif)\b/, Keyword
+
+        mixin :function_call
+        mixin :variable_name
+        mixin :operator
+        mixin :number
+        mixin :vector_literal
+
+        rule %r/[()]/, Text
+        rule %r/,/, Punctuation
+      end
+
+      state :old_arguments do
+        rule %r/\n/, Text, :pop!
+
+        mixin :variable_name
+        mixin :operator
+        mixin :number
+
+        rule %r/"/, Literal::String, :string
+        rule %r/[^\n]/, Text
+      end
+
+      state :number do
+        rule %r/\n/, Text, :pop!
+        rule %r/\b\d+(\.\d*)?([eE][-+]?\d+)?%?/, Literal::Number
+      end
+
+      state :variable_name do
+        mixin :operator
+        mixin :number
+
+        rule %r/\b([A-Z][a-zA-Z0-9]+)_/ do |m|
+          match = m[1]
+          if (['Object'] | self.class.objects).include?(match)
+            token Name::Builtin
+            push :object_reference
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r/\.?[a-z][a-zA-Z0-9_.]*(\$#|##|\$|#)?/ do |m|
+          match = m[0]
+          if self.class.variables_string.include?(match) ||
+             self.class.variables_numeric.include?(match)
+            token Name::Builtin
+          elsif self.class.keywords.include?(match)
+            token Keyword
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r/[\[\]]/, Text, :comma_list
+        mixin :string_interpolated
+      end
+
+      state :vector_literal do
+        rule %r/(\{)/, Text, :comma_list
+      end
+
+      state :object_reference do
+        mixin :string_interpolated
+        rule %r/([a-z][a-zA-Z0-9_]*|\d+)/, Name::Builtin
+
+        rule %r/\.([a-z]+)\b/ do |m|
+          match = m[1]
+          if self.class.object_attributes.include?(match)
+            token Name::Builtin
+            pop!
+          end
+        end
+
+        rule %r/\$/, Name::Builtin
+        rule %r/\[/, Text, :pop!
+      end
+
+      state :operator do
+        # This rule incorrectly matches === or +++++, which are not operators
+        rule %r/([+\/*<>=!-]=?|[&*|][&*|]?|\^|<>)/, Operator
+        rule %r/(?<![\w.])(and|or|not|div|mod)(?![\w.])/, Operator::Word
+      end
+
+      state :string_interpolated do
+        rule %r/'[\._a-z][^\[\]'":]*(\[([\d,]+|"[\w,]+")\])?(:[0-9]+)?'/, Literal::String::Interpol
+      end
+
+      state :string_unquoted do
+        rule %r/\n\s*\.{3}/, Punctuation
+        rule %r/\n/, Text, :pop!
+        rule %r/\s/, Text
+
+        mixin :string_interpolated
+
+        rule %r/'/, Literal::String
+        rule %r/[^'\n]+/, Literal::String
+      end
+
+      state :string do
+        rule %r/\n\s*\.{3}/, Punctuation
+        rule %r/"/, Literal::String, :pop!
+
+        mixin :string_interpolated
+
+        rule %r/'/, Literal::String
+        rule %r/[^'"\n]+/, Literal::String
+      end
+
+      state :old_form do
+        rule %r/(\s+)(#.*?$)/ do
+          groups Text, Comment::Single
+        end
+
+        rule %r/\s+/, Text
+
+        rule %r/(optionmenu|choice)([ \t]+\S+:[ \t]+)/ do
+          groups Keyword, Text
+          push :number
+        end
+
+        rule %r/(option|button)([ \t]+)/ do
+          groups Keyword, Text
+          push :string_unquoted
+        end
+
+        rule %r/(sentence|text)([ \t]+\S+)/ do
+          groups Keyword, Text
+          push :string_unquoted
+        end
+
+        rule %r/(word)([ \t]+\S+[ \t]*)(\S+)?([ \t]+.*)?/ do
+          groups Keyword, Text, Literal::String, Text
+        end
+
+        rule %r/(boolean)(\s+\S+\s*)(0|1|"?(?:yes|no)"?)/ do
+          groups Keyword, Text, Name::Variable
+        end
+
+        rule %r/(real|natural|positive|integer)([ \t]+\S+[ \t]*)([+-]?)/ do
+          groups Keyword, Text, Operator
+          push :number
+        end
+
+        rule %r/(comment)(\s+)/ do
+          groups Keyword, Text
+          push :string_unquoted
+        end
+
+        rule %r/\bendform\b/, Keyword, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Prolog < RegexLexer
+      title "Prolog"
+      desc "The Prolog programming language (http://en.wikipedia.org/wiki/Prolog)"
+      tag 'prolog'
+      aliases 'prolog'
+      filenames '*.pro', '*.P', '*.prolog', '*.pl'
+      mimetypes 'text/x-prolog'
+
+      start { push :bol }
+
+      state :bol do
+        rule %r/#.*/, Comment::Single
+        rule(//) { pop! }
+      end
+
+      state :basic do
+        rule %r/\s+/, Text
+        rule %r/%.*/, Comment::Single
+        rule %r/\/\*/, Comment::Multiline, :nested_comment
+
+        rule %r/[\[\](){}|.,;!]/, Punctuation
+        rule %r/:-|-->/, Punctuation
+
+        rule %r/"[^"]*"/, Str::Double
+
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num
+      end
+
+      state :atoms do
+        rule %r/[[:lower:]]([[:word:]])*/, Str::Symbol
+        rule %r/'[^']*'/, Str::Symbol
+      end
+
+      state :operators do
+        rule %r/(<|>|=<|>=|==|=:=|=|\/|\/\/|\*|\+|-)(?=\s|[a-zA-Z0-9\[])/,
+          Operator
+        rule %r/is/, Operator
+        rule %r/(mod|div|not)/, Operator
+        rule %r/[#&*+-.\/:<=>?@^~]+/, Operator
+      end
+
+      state :variables do
+        rule %r/[A-Z]+\w*/, Name::Variable
+        rule %r/_[[:word:]]*/, Name::Variable
+      end
+
+      state :root do
+        mixin :basic
+        mixin :atoms
+        mixin :variables
+        mixin :operators
+      end
+
+      state :nested_comment do
+        rule %r(/\*), Comment::Multiline, :push
+        rule %r/\s*\*[^*\/]+/, Comment::Multiline
+        rule %r(\*/), Comment::Multiline, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Prometheus < RegexLexer
+      desc 'prometheus'
+      tag 'prometheus'
+      aliases 'prometheus'
+      filenames '*.prometheus'
+
+      mimetypes 'text/x-prometheus', 'application/x-prometheus'
+
+      def self.functions
+        @functions ||= Set.new %w(
+          abs absent ceil changes clamp_max clamp_min count_scalar day_of_month
+          day_of_week days_in_month delta deriv drop_common_labels exp floor
+          histogram_quantile holt_winters hour idelta increase irate label_replace
+          ln log2 log10 month predict_linear rate resets round scalar sort
+          sort_desc sqrt time vector year avg_over_time min_over_time
+          max_over_time sum_over_time count_over_time quantile_over_time
+          stddev_over_time stdvar_over_time
+        )
+      end
+
+      state :root do
+        mixin :strings
+        mixin :whitespace
+
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+[smhdwy]?/, Num::Integer
+
+        mixin :operators
+
+        rule %r/(ignoring|on)(\()/ do
+          groups Keyword::Pseudo, Punctuation
+          push :label_list
+        end
+        rule %r/(group_left|group_right)(\()/ do
+          groups Keyword::Type, Punctuation
+        end
+        rule %r/(bool|offset)\b/, Keyword
+        rule %r/(without|by)\b/, Keyword, :label_list
+        rule %r/[\w:]+/ do |m|
+          if self.class.functions.include?(m[0])
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        mixin :metrics
+      end
+
+      state :metrics do
+        rule %r/[a-zA-Z0-9_-]+/, Name
+
+        rule %r/[\(\)\]:.,]/, Punctuation
+        rule %r/\{/, Punctuation, :filters
+        rule %r/\[/, Punctuation
+      end
+
+      state :strings do
+        rule %r/"/, Str::Double, :double_string_escaped
+        rule %r/'/, Str::Single, :single_string_escaped
+        rule %r/`.*`/, Str::Backtick
+      end
+
+      [
+        [:double, Str::Double, '"'],
+        [:single, Str::Single, "'"]
+      ].each do |name, tok, fin|
+        state :"#{name}_string_escaped" do
+          rule %r/\\[\\abfnrtv#{fin}]/, Str::Escape
+          rule %r/[^\\#{fin}]+/m, tok
+          rule %r/#{fin}/, tok, :pop!
+        end
+      end
+
+      state :filters do
+        mixin :inline_whitespace
+        rule %r/,/, Punctuation
+        mixin :labels
+        mixin :filter_matching_operators
+        mixin :strings
+        rule %r/}/, Punctuation, :pop!
+      end
+
+      state :label_list do
+        rule %r/\(/, Punctuation
+        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/,/, Punctuation
+        mixin :whitespace
+        rule %r/\)/, Punctuation, :pop!
+      end
+
+      state :labels do
+        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
+      end
+
+      state :operators do
+        rule %r([+\-\*/%\^]), Operator  # Arithmetic
+        rule %r(=|==|!=|<|>|<=|>=), Operator # Comparison
+        rule %r/and|or|unless/, Operator # Logical/Set
+        rule %r/(sum|min|max|avg|stddev|stdvar|count|count_values|bottomk|topk)\b/, Name::Function
+      end
+
+      state :filter_matching_operators do
+        rule %r/!(=|~)|=~?/, Operator
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t\r]+/, Text
+      end
+
+      state :whitespace do
+        mixin :inline_whitespace
+        rule %r/\n\s*/m, Text
+        rule %r/#.*?$/, Comment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Properties < RegexLexer
+      title ".properties"
+      desc '.properties config files for Java'
+      tag 'properties'
+
+      filenames '*.properties'
+      mimetypes 'text/x-java-properties'
+
+      identifier = /[\w.-]+/
+
+      state :basic do
+        rule %r/[!#].*?\n/, Comment
+        rule %r/\s+/, Text
+        rule %r/\\\n/, Str::Escape
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/(#{identifier})(\s*)([=:])/ do
+          groups Name::Property, Text, Punctuation
+          push :value
+        end
+      end
+
+      state :value do
+        rule %r/\n/, Text, :pop!
+        mixin :basic
+        rule %r/"/, Str, :dq
+        rule %r/'.*?'/, Str
+        mixin :esc_str
+        rule %r/[^\\\n]+/, Str
+      end
+
+      state :dq do
+        rule %r/"/, Str, :pop!
+        mixin :esc_str
+        rule %r/[^\\"]+/m, Str
+      end
+
+      state :esc_str do
+        rule %r/\\u[0-9]{4}/, Str::Escape
+        rule %r/\\./m, Str::Escape
+      end
+    end
+  end
+end