nano-clean-pkg 0.0.1

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

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Rego < RegexLexer
+      title "Rego"
+      desc "The Rego open-policy-agent (OPA) policy language (openpolicyagent.org)"
+      tag 'rego'
+      filenames '*.rego'
+
+      def self.constants
+        @constants ||= Set.new %w(
+          true false null
+        )
+      end
+
+      def self.operators
+        @operators ||= Set.new %w(
+          as default else import not package some with
+        )
+      end
+
+      state :basic do
+        rule %r/\s+/, Text
+        rule %r/#.*/, Comment::Single
+
+        rule %r/[\[\](){}|.,;!]/, Punctuation
+
+        rule %r/"[^"]*"/, Str::Double
+
+        rule %r/-?\d+\.\d+([eE][+-]?\d+)?/, Num::Float
+        rule %r/-?\d+([eE][+-]?\d+)?/, Num
+
+        rule %r/\\u[0-9a-fA-F]{4}/, Num::Hex
+        rule %r/\\["\/bfnrt]/, Str::Escape
+      end
+
+      state :operators do
+        rule %r/(=|!=|>=|<=|>|<|\+|-|\*|%|\/|\||&|:=)/, Operator
+        rule %r/[\/:?@^~]+/, Operator
+      end
+
+      state :root do
+        mixin :basic
+        mixin :operators
+
+        rule %r/[[:word:]]+/ do |m|
+          if self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.operators.include? m[0]
+            token Operator::Word
+          else
+            token Name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'ocaml/common'
+
+module Rouge
+  module Lexers
+    class ReScript < OCamlCommon
+      title "ReScript"
+      desc "The ReScript programming language (rescript-lang.org)"
+      tag 'rescript'
+      filenames '*.res', '*.resi'
+      mimetypes 'text/x-rescript'
+
+      def self.keywords
+        @keywords ||= Set.new(%w(
+          open let rec and as exception assert lazy if else
+          for in to downto while switch when external type private
+          mutable constraint include module of with try import export
+        ))
+      end
+
+      def self.types
+        @types ||= Set.new(%w(
+          bool int float char string
+          unit list array option ref exn format
+        ))
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new(%w(mod land lor lxor lsl lsr asr or))
+      end
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r([,.:?~\\]), Text
+
+        # Boolean Literal
+        rule %r/\btrue|false\b/, Keyword::Constant
+
+        # Module chain
+        rule %r/#{@@upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+
+        # Decorator
+        rule %r/@#{@@id}(\.#{@@id})*/, Name::Decorator
+
+        # Poly variant
+        rule %r/\##{@@id}/, Name::Class
+
+        # Variant or Module
+        rule @@upper_id, Name::Class
+
+        # Comments
+        rule %r(//.*), Comment::Single
+        rule %r(/\*), Comment::Multiline, :comment
+
+        # Keywords and identifiers
+        rule @@id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.types.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        # Braces
+        rule %r/[(){}\[\];]+/, Punctuation
+
+        # Operators
+        rule %r([;_!$%&*+/<=>@^|-]+), Operator
+
+        # Numbers
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/0x\h[\h_]*/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/\d[\d_]*/, Num::Integer
+
+        # String and Char
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[^'\/]'/, Str::Char
+        rule %r/'/, Keyword
+        rule %r/"/, Str::Double, :string
+
+        # Interpolated string
+        rule %r/`/ do
+          token Str::Double
+          push :interpolated_string
+        end
+      end
+
+      state :comment do
+        rule %r([^/\*]+), Comment::Multiline
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r([*/]), Comment::Multiline
+      end
+
+      state :interpolated_string do
+        rule %r/[$]{/, Punctuation, :interpolated_expression
+        rule %r/`/, Str::Double, :pop!
+        rule %r/\\[$`]/, Str::Escape
+        rule %r/[^$`\\]+/, Str::Double
+        rule %r/[\\$]/, Str::Double
+      end
+
+      state :interpolated_expression do
+        rule %r/}/, Punctuation, :pop!
+        mixin :root
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class RML < RegexLexer
+      title "RML"
+      desc "A system agnostic domain-specific language for runtime monitoring and verification (https://rmlatdibris.github.io/)"
+      tag 'rml'
+      filenames '*.rml'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          matches not with empty
+          all if else true false
+        )
+      end
+
+      def self.arithmetic_keywords
+        @arithmetic_keywords ||= Set.new %w(
+          abs sin cos tan min max
+        )
+      end
+
+      id_char = /[a-zA-Z0-9_]/
+      uppercase_id = /[A-Z]#{id_char}*/
+      lowercase_id = /[a-z]#{id_char}*/
+
+      ellipsis = /(\.){3}/
+      int = /[0-9]+/
+      float = /#{int}\.#{int}/
+      string = /'(\\'|[ a-zA-Z0-9_.])*'/
+
+      whitespace = /[ \t\r\n]+/
+      comment = /\/\/[^\r\n]*/
+
+      state :common_rules do
+        rule %r/#{whitespace}/, Text
+        rule %r/#{comment}/, Comment::Single
+        rule %r/#{string}/, Literal::String
+        rule %r/#{float}/, Num::Float
+        rule %r/#{int}/, Num::Integer
+      end
+
+      state :root do
+        mixin :common_rules
+        rule %r/(#{lowercase_id})(\()/ do
+          groups Name::Function, Operator
+          push :event_type_params
+        end
+        rule %r/#{lowercase_id}/ do |m|
+          if m[0] == 'with'
+            token Keyword
+            push :data_expression_with
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name::Function
+          end
+        end
+        rule %r/\(|\{|\[/, Operator, :event_type_params
+        rule %r/[_\|]/, Operator
+        rule %r/#{uppercase_id}/, Name::Class, :equation_block_expression
+        rule %r/;/, Operator
+      end
+
+      state :event_type_params do
+        mixin :common_rules
+        rule %r/\(|\{|\[/, Operator, :push
+        rule %r/\)|\}|\]/, Operator, :pop!
+        rule %r/#{lowercase_id}(?=:)/, Name::Entity
+        rule %r/(#{lowercase_id})/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Literal::String::Regex
+          end
+        end
+        rule %r/#{ellipsis}/, Literal::String::Symbol
+        rule %r/[_\|;,:]/, Operator
+      end
+
+      state :equation_block_expression do
+        mixin :common_rules
+        rule %r/[<,>]/, Operator
+        rule %r/#{lowercase_id}/, Literal::String::Regex
+        rule %r/=/ do
+          token Operator
+          goto :exp
+        end
+        rule %r/;/, Operator, :pop!
+      end
+
+      state :exp do
+        mixin :common_rules
+        rule %r/(if)(\()/ do
+          groups Keyword, Operator
+          push :data_expression
+        end
+        rule %r/let|var/, Keyword, :equation_block_expression
+        rule %r/(#{lowercase_id})(\()/ do
+          groups Name::Function, Operator
+          push :event_type_params
+        end
+        rule %r/(#{lowercase_id})/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name::Function
+          end
+        end
+        rule %r/#{uppercase_id}(?=<)/, Name::Class, :data_expression
+        rule %r/#{uppercase_id}/, Name::Class
+        rule %r/[=(){}*+\/\\\|!>?]/, Operator
+        rule %r/;/, Operator, :pop!
+      end
+
+      state :data_expression do
+        mixin :common_rules
+        rule %r/#{lowercase_id}/ do |m|
+          if (self.class.arithmetic_keywords | self.class.keywords).include? m[0]
+            token Keyword
+          else
+            token Literal::String::Regex
+          end
+        end
+        rule %r/\(/, Operator, :push
+        rule %r/\)/, Operator, :pop!
+        rule %r/(>)(?=[^A-Z;]+[A-Z;>])/, Operator, :pop!
+        rule %r/[*^?!%&\[\]<>\|+=:,.\/\\_-]/, Operator
+        rule %r/;/, Operator, :pop!
+      end
+
+      state :data_expression_with do
+        mixin :common_rules
+        rule %r/>/, Operator
+        mixin :data_expression
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class RobotFramework < RegexLexer
+      tag 'robot_framework'
+      aliases 'robot', 'robot-framework'
+
+      title "Robot Framework"
+      desc 'Robot Framework is a generic open source automation testing framework (robotframework.org)'
+
+      filenames '*.robot', '*.resource'
+      mimetypes 'text/x-robot'
+
+      def initialize(opts = {})
+        super(opts)
+        @col = 0
+        @next = nil
+        @is_template = false
+      end
+
+      def self.settings_with_keywords
+        @settings_with_keywords ||= Set.new [
+          "library", "resource", "setup", "teardown", "template", "suite setup",
+          "suite teardown", "task setup", "task teardown", "task template",
+          "test setup", "test teardown", "test template", "variables"
+        ]
+      end
+
+      def self.settings_with_args
+        @settings_with_args ||= Set.new [
+          "arguments", "default tags", "documentation", "force tags",
+          "metadata", "return", "tags", "timeout", "task timeout",
+          "test timeout"
+        ]
+      end
+
+      id = %r/(?:\\|[^|$@&% \t\n])+(?: (?:\\.|[^|$@&% \t\n])+)*/
+      bdd = %r/(?:Given|When|Then|And|But) /i
+      sep = %r/ +\| +|[ ]{2,}|\t+/
+
+      start do
+        push :prior_text
+      end
+
+      state :prior_text do
+        rule %r/^[^*].*/, Text
+        rule(//) { pop! }
+      end
+
+      # Mixins
+
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+      end
+
+      state :section_include do
+        mixin :end_section
+        mixin :sep
+        mixin :newline
+      end
+
+      state :end_section do
+        rule(/(?=^(?:\| )?\*)/) { pop! }
+      end
+
+      state :return do
+        rule(//) { pop! }
+      end
+
+      state :sep do
+        rule %r/\| /, Text::Whitespace
+
+        rule sep do
+          token Text::Whitespace
+          @col = @col + 1
+          if @next
+            push @next
+          elsif @is_template
+            push :args
+          elsif @col == 1
+            @next = :keyword
+            push :keyword
+          else
+            push :args
+          end
+          push :cell_start
+        end
+
+        rule %r/\.\.\. */ do
+          token Text::Whitespace
+          @col = @col + 1
+          push :args
+        end
+
+        rule %r/ ?\|/, Text::Whitespace
+      end
+
+      state :newline do
+        rule %r/\n/ do
+          token Text::Whitespace
+          @col = 0
+          @next = nil
+          push :cell_start
+        end
+      end
+
+      # States
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/^(?:\| )?\*[* ]*([A-Z]+(?: [A-Z]+)?).*/i do |m|
+          token Generic::Heading, m[0]
+          case m[1].chomp("s").downcase
+          when "setting" then push :section_settings
+          when "test case" then push :section_tests
+          when "task" then push :section_tasks
+          when "keyword" then push :section_keywords
+          when "variable" then push :section_variables
+          end
+        end
+      end
+
+      state :section_settings do
+        mixin :section_include
+
+        rule %r/([A-Z]+(?: [A-Z]+)?)(:?)/i do |m|
+          match = m[1].downcase
+          @next = if self.class.settings_with_keywords.include? match
+            :keyword
+          elsif self.class.settings_with_args.include? match
+            :args
+          end
+          groups Name::Builtin::Pseudo, Punctuation
+        end
+      end
+
+      state :section_tests do
+        mixin :section_include
+
+        rule %r/[$@&%{}]+/, Name::Label
+        rule %r/( )(?![ |])/, Name::Label
+
+        rule id do
+          @is_template = false
+          token Name::Label
+        end
+      end
+
+      state :section_tasks do
+        mixin :section_tests
+      end
+
+      state :section_keywords do
+        mixin :section_include
+
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          push :var
+        end
+
+        rule %r/[$@&%{}]+/, Name::Label
+        rule %r/( )(?![ |])/, Name::Label
+
+        rule id, Name::Label
+      end
+
+      state :section_variables do
+        mixin :section_include
+
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :args
+          push :var
+        end
+      end
+
+      state :cell_start do
+        rule %r/#.*/, Comment
+        mixin :return
+      end
+
+      state :keyword do
+        rule %r/(\[)([A-Z]+(?: [A-Z]+)?)(\])/i do |m|
+          groups Punctuation, Name::Builtin::Pseudo, Punctuation
+
+          match = m[2].downcase
+          @is_template = true if match == "template"
+          if self.class.settings_with_keywords.include? match
+            @next = :keyword
+          elsif self.class.settings_with_args.include? match
+            @next = :args
+          end
+
+          pop!
+        end
+
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :keyword unless @next.nil?
+          push :var
+        end
+
+        rule %r/FOR/i do
+          token Name::Function
+          @next = :keyword unless @next.nil?
+        end
+
+        rule %r/( )(?![ |])/, Name::Function
+
+        rule bdd, Name::Builtin
+        rule id do
+          token Name::Function
+          @next = nil
+        end
+
+        mixin :return
+      end
+
+      state :args do
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :keyword unless @next.nil?
+          push :var
+        end
+
+        rule %r/[$@&%]+/, Str
+        rule %r/( )(?![ |])/, Str
+        rule id, Str
+
+        mixin :return
+      end
+
+      state :var do
+        rule %r/(\})( )(=)/ do
+          groups Name::Variable, Text::Whitespace, Punctuation
+          pop!
+        end
+        rule %r/[$@&%]\{/, Name::Variable, :var
+        rule %r/[{\[]/, Name::Variable, :var
+        rule %r/[}\]]/, Name::Variable, :pop!
+        rule %r/[^$@&%{}\[\]]+/, Name::Variable
+        rule %r/\}\[/, Name::Variable
+      end
+    end
+  end
+end