nano-clean-pkg 0.0.1

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

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class IgorPro < RegexLexer
+      tag 'igorpro'
+      filenames '*.ipf'
+      mimetypes 'text/x-igorpro'
+
+      title "IgorPro"
+      desc "WaveMetrics Igor Pro"
+
+      KEYWORDS = Set.new %w(
+        structure endstructure
+        threadsafe static
+        macro proc window menu function end
+        if else elseif endif switch strswitch endswitch
+        break return continue
+        for endfor do while
+        case default
+        try catch endtry
+        abortonrte abortonvalue
+      )
+
+      PREPROCESSOR_WORDS = Set.new %w(
+        pragma include
+        define ifdef ifndef undef
+        if elif else endif
+      )
+
+      DECLARATIONS = Set.new %w(
+        variable string wave strconstant constant
+        nvar svar dfref funcref struct
+        char uchar int16 uint16 int32 uint32 int64 uint64 float double
+      )
+
+      CONSTANTS = Set.new %w(nan inf)
+
+      lazy { require_relative 'igorpro/builtins' }
+
+      object = /[a-z][a-z0-9_\.]*/i
+      noLineBreak = /(?:[ \t]|(?:\\\s*[\r\n]))+/
+      operator = %r([\#$~!%^&*+=\|?:<>/-])
+      punctuation = /[{}()\[\],.;]/
+      number_float= /0x[a-f0-9]+/i
+      number_hex  = /\d+\.\d+(e[\+\-]?\d+)?/
+      number_int  = /[\d]+(?:_\d+)*/
+
+      state :root do
+        rule %r(//), Comment, :comments
+
+        rule object do |m|
+          obj = m[0].downcase
+
+          if obj.include?('function')
+            token Keyword::Declaration
+            push :parse_function
+          elsif DECLARATIONS.include?(obj)
+            token Keyword::Declaration
+            push :parse_variables
+          elsif KEYWORDS.include?(obj)
+            token Keyword
+          elsif CONSTANTS.include?(obj)
+            token Keyword::Constant
+          elsif FUNCTIONS.include?(obj)
+            token Name::Builtin
+          elsif OPERATIONS.include?(obj)
+            token Keyword::Reserved
+            push :operationFlags
+          elsif obj.match?(/\A(v|s|w)_[a-z]+[a-z0-9]*/o)
+            token Name::Constant
+          else
+            token Name
+          end
+        end
+
+        mixin :preprocessor
+        mixin :waveFlag
+
+        mixin :characters
+        mixin :numbers
+        mixin :whitespace
+      end
+
+      state :preprocessor do
+        rule %r((\#)(#{object})) do |m|
+          if PREPROCESSOR_WORDS.include? m[2].downcase
+            token Comment::Preproc
+          else
+            token Punctuation, m[1] #i.e. ModuleFunctions
+            token Name, m[2]
+          end
+        end
+      end
+
+      state :assignment do
+        mixin :whitespace
+        rule %r/\"/, Literal::String::Double, :string1 #punctuation for string
+        mixin :string2
+        rule number_float, Literal::Number::Float, :pop!
+        rule number_int, Literal::Number::Integer, :pop!
+        rule %r/[\(\[\{][^\)\]\}]+[\)\]\}]/, Generic, :pop!
+        rule %r/[^\s\/\(]+/, Generic, :pop!
+        rule(//) { pop! }
+      end
+
+      state :parse_variables do
+        mixin :whitespace
+        rule %r/[=]/, Punctuation, :assignment
+        rule object, Name::Variable
+        rule %r/[\[\]]/, Punctuation # optional variables in functions
+        rule %r/[,]/, Punctuation, :parse_variables
+        rule %r/\)/, Punctuation, :pop! # end of function
+        rule %r([/][a-z]+)i, Keyword::Pseudo, :parse_variables
+        rule(//) { pop! }
+      end
+
+      state :parse_function do
+        rule %r([/][a-z]+)i, Keyword::Pseudo # only one flag
+        mixin :whitespace
+        rule object, Name::Function
+        rule %r/[\(]/, Punctuation, :parse_variables
+        rule(//) { pop! }
+      end
+
+      state :operationFlags do
+        rule noLineBreak, Text
+        rule %r/[=]/, Punctuation, :assignment
+        rule %r([/][a-z]+)i, Keyword::Pseudo, :operationFlags
+        rule %r/(as)(\s*)(#{object})/i do
+          groups Keyword::Type, Text, Name::Label
+        end
+        rule(//) { pop! }
+      end
+
+      # inline variable assignments (i.e. for Make) with strict syntax
+      state :waveFlag do
+        rule %r(
+          (/(?:wave|X|Y))
+          (\s*)(=)(\s*)
+          (#{object})
+          )ix do |m|
+          token Keyword::Pseudo, m[1]
+          token Text, m[2]
+          token Punctuation, m[3]
+          token Text, m[4]
+          token Name::Variable, m[5]
+        end
+      end
+
+      state :characters do
+        rule %r/\s/, Text
+        rule operator, Operator
+        rule punctuation, Punctuation
+        rule %r/\"/, Literal::String::Double, :string1 #punctuation for string
+        mixin :string2
+      end
+
+      state :numbers do
+        rule number_float, Literal::Number::Float
+        rule number_hex, Literal::Number::Hex
+        rule number_int, Literal::Number::Integer
+      end
+
+      state :whitespace do
+        rule noLineBreak, Text
+      end
+
+      state :string1 do
+        rule %r/%\w\b/, Literal::String::Other
+        rule %r/\\\\/, Literal::String::Escape
+        rule %r/\\\"/, Literal::String::Escape
+        rule %r/\\/, Literal::String::Escape
+        rule %r/[^"]/, Literal::String
+        rule %r/\"/, Literal::String::Double, :pop! #punctuation for string
+      end
+
+      state :string2 do
+        rule %r/\'[^']*\'/, Literal::String::Single
+      end
+
+      state :comments do
+        rule %r{([/]\s*)([@]\w+\b)}i do
+          # doxygen comments
+          groups Comment, Comment::Special
+        end
+        rule %r/[^\r\n]/, Comment
+        rule(//) { pop! }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class INI < RegexLexer
+      title "INI"
+      desc 'the INI configuration format'
+      tag 'ini'
+
+      filenames '*.ini', '*.INI', '*.gitconfig', '*.cfg', '.editorconfig', '*.inf'
+      mimetypes 'text/x-ini', 'text/inf'
+
+      identifier = /[\w\-.]+/
+
+      state :basic do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/[;#].*?\n/, Comment
+        rule %r/\\\n/, Str::Escape
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/(#{identifier})(\s*)(=)/ do
+          groups Name::Property, Text::Whitespace, Punctuation
+          push :value
+        end
+
+        rule %r/\[.*?\]/, Name::Namespace
+
+        # standalone option, supported by some INI parsers
+        rule %r/(.+?)/, Name::Attribute
+      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/\\./m, Str::Escape
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class IO < RegexLexer
+      tag 'io'
+      title "Io"
+      desc 'The IO programming language (http://iolanguage.com)'
+      mimetypes 'text/x-iosrc'
+      filenames '*.io'
+
+      def self.detect?(text)
+        return true if text.shebang? 'io'
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(nil false true)
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          args call clone do doFile doString else elseif for if list
+          method return super then
+        )
+      end
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r(//.*), Comment::Single
+        rule %r(#.*), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+        rule %r(/[+]), Comment::Multiline, :nested_comment
+
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+
+        rule %r(:?:=), Keyword
+        rule %r/[()]/, Punctuation
+
+        rule %r([-=;,*+><!/|^.%&\[\]{}]), Operator
+
+        rule %r/[A-Z]\w*/, Name::Class
+
+        rule %r/[a-z_]\w*/ do |m|
+          name = m[0]
+
+          if self.class.constants.include? name
+            token Keyword::Constant
+          elsif self.class.builtins.include? name
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, Num::Float
+        rule %r/\d+/, Num::Integer
+
+        rule %r/@@?/, Keyword
+      end
+
+      state :nested_comment do
+        rule %r([^/+]+)m, Comment::Multiline
+        rule %r(/[+]), Comment::Multiline, :nested_comment
+        rule %r([+]/), Comment::Multiline, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'console'
+require_relative 'ruby'
+
+module Rouge
+  module Lexers
+    class IRBLexer < ConsoleLexer
+      tag 'irb'
+      aliases 'pry'
+
+      desc 'Shell sessions in IRB or Pry'
+
+      # unlike the superclass, we do not accept any options
+      @option_docs = {}
+
+      def output_lexer
+        @output_lexer ||= IRBOutputLexer.new(@options)
+      end
+
+      def lang_lexer
+        @lang_lexer ||= Ruby.new(@options)
+      end
+
+      def prompt_regex
+        %r(
+          ^.*?
+          (
+            (irb|pry).*?[>"*] |
+            [>"*]>
+          )
+        )x
+      end
+
+      def allow_comments?
+        true
+      end
+    end
+
+    class IRBOutputLexer < Ruby
+      tag 'irb_output'
+
+      start do
+        push :stdout
+      end
+
+      state :has_irb_output do
+        rule %r(=>), Punctuation, :pop!
+        rule %r/.+?(\n|$)/, Generic::Output
+      end
+
+      state :irb_error do
+        rule %r/.+?(\n|$)/, Generic::Error
+        mixin :has_irb_output
+      end
+
+      state :stdout do
+        rule %r/\w+?(Error|Exception):.+?(\n|$)/, Generic::Error, :irb_error
+        mixin :has_irb_output
+      end
+
+      prepend :root do
+        rule %r/#</, Keyword::Type, :irb_object
+      end
+
+      state :irb_object do
+        rule %r/>/, Keyword::Type, :pop!
+        mixin :root
+      end
+    end
+  end
+end

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

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+# Lexer adapted from https://github.com/pygments/pygments/blob/ad55974ce83b85dbb333ab57764415ab84169461/pygments/lexers/theorem.py
+
+module Rouge
+  module Lexers
+    class Isabelle < RegexLexer
+      title "Isabelle"
+      desc 'Isabelle theories (isabelle.in.tum.de)'
+      tag 'isabelle'
+      aliases 'isa', 'Isabelle'
+      filenames '*.thy'
+      mimetypes 'text/x-isabelle'
+
+      def self.keyword_minor
+        @keyword_minor ||= Set.new %w(
+          and assumes attach avoids binder checking
+          class_instance class_relation code_module congs
+          constant constrains datatypes defines file fixes
+          for functions hints identifier if imports in
+          includes infix infixl infixr is keywords lazy
+          module_name monos morphisms no_discs_sels notes
+          obtains open output overloaded parametric permissive
+          pervasive rep_compat shows structure type_class
+          type_constructor unchecked unsafe where
+        )
+      end
+
+      def self.keyword_diag
+        @keyword_diag ||= Set.new %w(
+          ML_command ML_val class_deps code_deps code_thms
+          display_drafts find_consts find_theorems find_unused_assms
+          full_prf help locale_deps nitpick pr prf
+          print_abbrevs print_antiquotations print_attributes
+          print_binds print_bnfs print_bundles
+          print_case_translations print_cases print_claset
+          print_classes print_codeproc print_codesetup
+          print_coercions print_commands print_context
+          print_defn_rules print_dependencies print_facts
+          print_induct_rules print_inductives print_interps
+          print_locale print_locales print_methods print_options
+          print_orders print_quot_maps print_quotconsts
+          print_quotients print_quotientsQ3 print_quotmapsQ3
+          print_rules print_simpset print_state print_statement
+          print_syntax print_theorems print_theory print_trans_rules
+          prop pwd quickcheck refute sledgehammer smt_status
+          solve_direct spark_status term thm thm_deps thy_deps
+          try try0 typ unused_thms value values welcome
+          print_ML_antiquotations print_term_bindings values_prolog
+        )
+      end
+
+      def self.keyword_thy
+        @keyword_thy ||= Set.new %w(theory begin end)
+      end
+
+      def self.keyword_section
+        @keyword_section ||= Set.new %w(header chapter)
+      end
+
+      def self.keyword_subsection
+        @keyword_subsection ||= Set.new %w(section subsection subsubsection sect subsect subsubsect)
+      end
+
+      def self.keyword_theory_decl
+        @keyword_theory_decl ||= Set.new %w(
+          ML ML_file abbreviation adhoc_overloading arities
+          atom_decl attribute_setup axiomatization bundle
+          case_of_simps class classes classrel codatatype
+          code_abort code_class code_const code_datatype
+          code_identifier code_include code_instance code_modulename
+          code_monad code_printing code_reflect code_reserved
+          code_type coinductive coinductive_set consts context
+          datatype datatype_new datatype_new_compat declaration
+          declare default_sort defer_recdef definition defs
+          domain domain_isomorphism domaindef equivariance
+          export_code extract extract_type fixrec fun
+          fun_cases hide_class hide_const hide_fact hide_type
+          import_const_map import_file import_tptp import_type_map
+          inductive inductive_set instantiation judgment lemmas
+          lifting_forget lifting_update local_setup locale
+          method_setup nitpick_params no_adhoc_overloading
+          no_notation no_syntax no_translations no_type_notation
+          nominal_datatype nonterminal notation notepad oracle
+          overloading parse_ast_translation parse_translation
+          partial_function primcorec primrec primrec_new
+          print_ast_translation print_translation quickcheck_generator
+          quickcheck_params realizability realizers recdef record
+          refute_params setup setup_lifting simproc_setup
+          simps_of_case sledgehammer_params spark_end spark_open
+          spark_open_siv spark_open_vcg spark_proof_functions
+          spark_types statespace syntax syntax_declaration text
+          text_raw theorems translations type_notation
+          type_synonym typed_print_translation typedecl hoarestate
+          install_C_file install_C_types wpc_setup c_defs c_types
+          memsafe SML_export SML_file SML_import approximate
+          bnf_axiomatization cartouche datatype_compat
+          free_constructors functor nominal_function
+          nominal_termination permanent_interpretation
+          binds defining smt2_status term_cartouche
+          boogie_file text_cartouche
+        )
+      end
+
+      def self.keyword_theory_script
+        @keyword_theory_script ||= Set.new %w(inductive_cases inductive_simps)
+      end
+
+      def self.keyword_theory_goal
+        @keyword_theory_goal ||= Set.new %w(
+          ax_specification bnf code_pred corollary cpodef
+          crunch crunch_ignore
+          enriched_type function instance interpretation lemma
+          lift_definition nominal_inductive nominal_inductive2
+          nominal_primrec pcpodef primcorecursive
+          quotient_definition quotient_type recdef_tc rep_datatype
+          schematic_corollary schematic_lemma schematic_theorem
+          spark_vc specification subclass sublocale termination
+          theorem typedef wrap_free_constructors
+        )
+      end
+
+      def self.keyword_qed
+        @keyword_qed ||= Set.new %w(by done qed)
+      end
+
+      def self.keyword_abandon_proof
+        @keyword_abandon_proof ||= Set.new %w(sorry oops)
+      end
+
+      def self.keyword_proof_goal
+        @keyword_proof_goal ||= Set.new %w(have hence interpret)
+      end
+
+      def self.keyword_proof_block
+        @keyword_proof_block ||= Set.new %w(next proof)
+      end
+
+      def self.keyword_proof_chain
+        @keyword_proof_chain ||= Set.new %w(finally from then ultimately with)
+      end
+
+      def self.keyword_proof_decl
+        @keyword_proof_decl ||= Set.new %w(
+          ML_prf also include including let moreover note
+          txt txt_raw unfolding using write
+        )
+      end
+
+      def self.keyword_proof_asm
+        @keyword_proof_asm ||= Set.new %w(assume case def fix presume)
+      end
+
+      def self.keyword_proof_asm_goal
+        @keyword_proof_asm_goal ||= Set.new %w(guess obtain show thus)
+      end
+
+      def self.keyword_proof_script
+        @keyword_proof_script ||= Set.new %w(apply apply_end apply_trace back defer prefer)
+      end
+
+      state :root do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\(\*/, Comment, :comment
+        rule %r/\{\*|‹/, Text, :text
+
+        rule %r/::|\[|\]|-|[:()_=,|+!?]/, Operator
+        rule %r/[{}.]|\.\./, Operator::Word
+
+        def word(keywords)
+          return %r/\b(#{keywords.join('|')})\b/
+        end
+
+        rule %r/[a-zA-Z]\w*/ do |m|
+          sym = m[0]
+
+          if self.class.keyword_minor.include?(sym) ||
+            self.class.keyword_proof_script.include?(sym)
+            token Keyword::Pseudo
+          elsif self.class.keyword_diag.include?(sym)
+            token Keyword::Type
+          elsif self.class.keyword_thy.include?(sym) ||
+            self.class.keyword_theory_decl.include?(sym) ||
+            self.class.keyword_qed.include?(sym) ||
+            self.class.keyword_proof_goal.include?(sym) ||
+            self.class.keyword_proof_block.include?(sym) ||
+            self.class.keyword_proof_decl.include?(sym) ||
+            self.class.keyword_proof_chain.include?(sym) ||
+            self.class.keyword_proof_asm.include?(sym) ||
+            self.class.keyword_proof_asm_goal.include?(sym)
+            token Keyword
+          elsif self.class.keyword_section.include?(sym)
+            token Generic::Heading
+          elsif self.class.keyword_subsection.include?(sym)
+            token Generic::Subheading
+          elsif self.class.keyword_theory_goal.include?(sym) ||
+            self.class.keyword_theory_script.include?(sym)
+            token Keyword::Namespace
+          elsif self.class.keyword_abandon_proof.include?(sym)
+            token Generic::Error
+          else
+            token Name
+          end
+        end
+
+        rule %r/\\<\w*>/, Str::Symbol
+
+        rule %r/'[^\W\d][.\w']*/, Name::Variable
+
+        rule %r/0[xX][\da-fA-F][\da-fA-F_]*/, Num::Hex
+        rule %r/0[oO][0-7][0-7_]*/, Num::Oct
+        rule %r/0[bB][01][01_]*/, Num::Bin
+
+        rule %r/"/, Str, :string
+        rule %r/`/, Str::Other, :fact
+        # Everything except for (most) operators whitespaces may be name
+        rule %r/[^\s:|\[\]\-()=,+!?{}._][^\s:|\[\]\-()=,+!?{}]*/, Name
+      end
+
+      state :comment do
+        rule %r/[^(*)]+/, Comment
+        rule %r/\(\*/, Comment, :comment
+        rule %r/\*\)/, Comment, :pop!
+        rule %r/[(*)]/, Comment
+      end
+
+      state :text do
+        rule %r/[^{*}‹›]+/, Text
+        rule %r/\{\*|‹/, Text, :text
+        rule %r/\*\}|›/, Text, :pop!
+        rule %r/[{*}]/, Text
+      end
+
+      state :string do
+        rule %r/[^"\\]+/, Str
+        rule %r/\\<\w*>/, Str::Symbol
+        rule %r/\\"/, Str
+        rule %r/\\/, Str
+        rule %r/"/, Str, :pop!
+      end
+
+      state :fact do
+        rule %r/[^`\\]+/, Str::Other
+        rule %r/\\<\w*>/, Str::Symbol
+        rule %r/\\`/, Str::Other
+        rule %r/\\/, Str::Other
+        rule %r/`/, Str::Other, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ISBL < RegexLexer
+      title "ISBL"
+      desc "The ISBL programming language"
+      tag 'isbl'
+      filenames '*.isbl'
+
+      def self.keywords
+        @keywords = Set.new %w(
+          and и else иначе endexcept endfinally endforeach конецвсе endif конецесли endwhile
+          конецпока except exitfor finally foreach все if если in в not не or или try while пока
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :dotted do
+        mixin :whitespace
+        rule %r/\p{Alnum}+/i do |m|
+          token(in_state?(:type) ? Keyword::Type : Name)
+
+          pop!
+        end
+      end
+
+      state :type do
+        mixin :whitespace
+        rule %r/\p{Word}+/, Name, :pop!
+        rule %r/[.]/, Punctuation, :dotted
+        rule(//) { pop! }
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r/[:]/, Punctuation, :type
+        rule %r/[.]/, Punctuation, :dotted
+        rule %r/[\[\]();]/, Punctuation
+        rule %r([&*+=<>/-]), Operator
+        rule %r/[\p{Alpha}_!]\p{Word}*(?=[(])/i, Name::Function
+        rule %r/[\p{Alpha}_!]\p{Word}*/i do |m|
+          if self.class.keywords.include?(m[0].downcase)
+            token Keyword
+          else
+            token Name::Variable
+          end
+        end
+        rule %r/\b(\d+(\.\d+)?)\b/, Literal::Number
+        rule %r(["].*?["])m, Literal::String::Double
+        rule %r(['].*?['])m, Literal::String::Single
+      end
+    end
+  end
+end