nano-clean-pkg 0.0.1

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'html'
+
+module Rouge
+  module Lexers
+    class Vue < HTML
+      desc 'Vue.js single-file components'
+      tag 'vue'
+      aliases 'vuejs'
+      filenames '*.vue'
+
+      mimetypes 'text/x-vue', 'application/x-vue'
+
+      def initialize(*)
+        super
+        @js = Javascript.new(options)
+      end
+
+      def lookup_lang(lang)
+        lang.downcase!
+        lang = lang.gsub(/["']*/, '')
+        case lang
+        when 'html' then HTML
+        when 'css' then CSS
+        when 'javascript' then Javascript
+        when 'sass' then Sass
+        when 'scss' then Scss
+        when 'coffee' then Coffeescript
+          # TODO: add more when the lexers are done
+        else
+          PlainText
+        end
+      end
+
+      start { @js.reset! }
+
+      prepend :root do
+        rule %r/(<)(\s*)(template)/ do
+          groups Name::Tag, Text, Keyword
+          @lang = HTML
+          push :template
+          push :lang_tag
+        end
+
+        rule %r/(<)(\s*)(style)/ do
+          groups Name::Tag, Text, Keyword
+          @lang = CSS
+          push :style
+          push :lang_tag
+        end
+
+        rule %r/(<)(\s*)(script)/ do
+          groups Name::Tag, Text, Keyword
+          @lang = Javascript
+          push :script
+          push :lang_tag
+        end
+      end
+
+      prepend :tag do
+        rule %r/[a-zA-Z0-9_:#\[\]()*.-]+\s*=\s*/m, Name::Attribute, :attr
+      end
+
+      state :style do
+        rule %r/(<\s*\/\s*)(style)(\s*>)/ do
+          groups Name::Tag, Keyword, Name::Tag
+          pop!
+        end
+
+        mixin :style_content
+        mixin :embed
+      end
+
+      state :script do
+        rule %r/(<\s*\/\s*)(script)(\s*>)/ do
+          groups Name::Tag, Keyword, Name::Tag
+          pop!
+        end
+
+        mixin :script_content
+        mixin :embed
+      end
+
+      state :lang_tag do
+        rule %r/(lang\s*=)(\s*)("(?:\\.|[^\\])*?"|'(\\.|[^\\])*?'|[^\s>]+)/ do |m|
+          groups Name::Attribute, Text, Str
+          @lang = lookup_lang(m[3])
+        end
+
+        mixin :tag
+      end
+
+      state :template do
+        rule %r((<\s*/\s*)(template)(\s*>)) do
+          groups Name::Tag, Keyword, Name::Tag
+          pop!
+        end
+
+        rule %r/{{/ do
+          token Str::Interpol
+          push :template_interpol
+          @js.reset!
+        end
+
+        mixin :embed
+      end
+
+      state :template_interpol do
+        rule %r/}}/, Str::Interpol, :pop!
+        rule %r/}/, Error
+        mixin :template_interpol_inner
+      end
+
+      state :template_interpol_inner do
+        rule(/{/) { delegate @js; push }
+        rule(/}/) { delegate @js; pop! }
+        rule(/[^{}]+/) { delegate @js }
+      end
+
+      state :embed do
+        rule(/[^{<]+/) { delegate @lang }
+        rule(/[<{][^<{]*/) { delegate @lang }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Wollok < RegexLexer
+      title 'Wollok'
+      desc 'Wollok lang'
+      tag 'wollok'
+      filenames '*.wlk', '*.wtest', '*.wpgm'
+
+      keywords = %w(new super return if else var const override constructor)
+
+      entity_name = /[a-zA-Z][a-zA-Z0-9]*/
+      variable_naming = /_?#{entity_name}/
+
+      state :whitespaces_and_comments do
+        rule %r/\s+/m, Text::Whitespace
+        rule %r(//.*$), Comment::Single
+        rule %r(/\*(.|\s)*?\*/)m, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespaces_and_comments
+        rule %r/(import)(.+$)/ do
+          groups Keyword::Reserved, Text
+        end
+        rule %r/(class|object|mixin)/, Keyword::Reserved, :foo
+        rule %r/test|program/, Keyword::Reserved #, :chunk_naming
+        rule %r/(package)(\s+)(#{entity_name})/ do
+          groups Keyword::Reserved, Text::Whitespace, Name::Class
+        end
+        rule %r/{|}/, Text
+        mixin :keywords
+        mixin :symbols
+        mixin :objects
+      end
+
+      state :foo do
+        mixin :whitespaces_and_comments
+        rule %r/inherits|mixed|with|and/, Keyword::Reserved
+        rule %r/#{entity_name}(?=\s*{)/ do |m|
+          token Name::Class
+          entities << m[0]
+          pop!
+        end
+        rule %r/#{entity_name}/ do |m|
+          token Name::Class
+          entities << m[0]
+        end
+      end
+
+      state :keywords do
+        def any(expressions)
+          /#{expressions.map { |keyword| "#{keyword}\\b" }.join('|')}/
+        end
+
+        rule %r/self\b/, Name::Builtin::Pseudo
+        rule any(keywords), Keyword::Reserved
+        rule %r/(method)(\s+)(#{variable_naming})/ do
+          groups Keyword::Reserved, Text::Whitespace, Text
+        end
+      end
+
+      state :objects do
+        rule variable_naming do |m|
+          variable = m[0]
+          if entities.include?(variable) || ('A'..'Z').cover?(variable[0])
+            token Name::Class
+          else
+            token Keyword::Variable
+          end
+        end
+        rule %r/\.#{entity_name}/, Text
+        mixin :literals
+      end
+
+      state :literals do
+        mixin :whitespaces_and_comments
+        rule %r/[0-9]+\.?[0-9]*/, Literal::Number
+        rule %r/"[^"]*"/m, Literal::String
+        rule %r/\[|\#{/, Punctuation, :lists
+      end
+
+      state :lists do
+        rule %r/,/, Punctuation
+        rule %r/]|}/, Punctuation, :pop!
+        mixin :objects
+      end
+
+      state :symbols do
+        rule %r/\+\+|--|\+=|-=|\*\*|!/, Operator
+        rule %r/\+|-|\*|\/|%/, Operator
+        rule %r/<=|=>|===|==|<|>/, Operator
+        rule %r/and\b|or\b|not\b/, Operator
+        rule %r/\(|\)|=/, Text
+        rule %r/,/, Punctuation
+      end
+
+      private
+
+      def entities
+        @entities ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class XML < RegexLexer
+      title "XML"
+      desc %q(<desc for="this-lexer">XML</desc>)
+      tag 'xml'
+      filenames '*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl', '*.svg',
+                '*.plist'
+      mimetypes 'text/xml', 'application/xml', 'image/svg+xml',
+                'application/rss+xml', 'application/atom+xml'
+
+      # Documentation: https://www.w3.org/TR/xml11/#charsets and https://www.w3.org/TR/xml11/#sec-suggested-names
+
+      def self.detect?(text)
+        return false if text.doctype?(/html/)
+        return true if text =~ /\A<\?xml\b/
+        return true if text.doctype?
+      end
+
+      state :root do
+        rule %r/[^<&]+/, Text
+        rule %r/&\S*?;/, Name::Entity
+        rule %r/<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
+        rule %r/<!--/, Comment, :comment
+        rule %r/<\?.*?\?>/, Comment::Preproc
+        rule %r/<![^>]*>/, Comment::Preproc
+
+        # open tags
+        rule %r(<\s*[\p{L}:_][\p{Word}\p{Cf}:.·-]*)m, Name::Tag, :tag
+
+        # self-closing tags
+        rule %r(<\s*/\s*[\p{L}:_][\p{Word}\p{Cf}:.·-]*\s*>)m, Name::Tag
+      end
+
+      state :comment do
+        rule %r/[^-]+/m, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
+      end
+
+      state :tag do
+        rule %r/\s+/m, Text
+        rule %r/[\p{L}:_][\p{Word}\p{Cf}:.·-]*\s*=/m, Name::Attribute, :attr
+        rule %r(/?\s*>), Name::Tag, :pop!
+      end
+
+      state :attr do
+        rule %r/\s+/m, Text
+        rule %r/".*?"|'.*?'|[^\s>]+/m, Str, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Xojo < RegexLexer
+      title "Xojo"
+      desc "Xojo"
+      tag 'xojo'
+      aliases 'realbasic'
+      filenames '*.xojo_code', '*.xojo_window', '*.xojo_toolbar', '*.xojo_menu', '*.xojo_image', '*.rbbas', '*.rbfrm', '*.rbmnu', '*.rbres', '*.rbtbar'
+
+      keywords = %w(
+          addhandler aggregates array asc assigns attributes begin break
+          byref byval call case catch class const continue color ctype declare
+          delegate dim do downto each else elseif end enum event exception
+          exit extends false finally for function global goto if
+          implements inherits interface lib loop mod module
+          new next nil object of optional paramarray
+          private property protected public raise raiseevent rect redim
+          removehandler return select shared soft static step sub super
+          then to true try until using var wend while
+        )
+
+      keywords_type = %w(
+          boolean byte cfstringref cgfloat cstring currency date datetime double int8 int16
+          int32 int64 integer ostype pair pstring ptr short single
+          string structure variant uinteger uint8 uint16 uint32 uint64
+          ushort windowptr wstring
+        )
+
+      operator_words = %w(
+          addressof weakaddressof and as in is isa mod not or xor
+        )
+
+      state :root do
+        rule %r/\s+/, Text::Whitespace
+
+        rule %r/rem\b.*?$/i, Comment::Single
+        rule %r((?://|').*$), Comment::Single
+        rule %r/\#tag Note.*?\#tag EndNote/mi, Comment::Preproc
+        rule %r/\s*[#].*$/x, Comment::Preproc
+
+        rule %r/".*?"/, Literal::String::Double
+        rule %r/[(){}!#,:]/, Punctuation
+
+        rule %r/\b(?:#{keywords.join('|')})\b/i, Keyword
+        rule %r/\b(?:#{keywords_type.join('|')})\b/i, Keyword::Declaration
+
+        rule %r/\b(?:#{operator_words.join('|')})\b/i, Operator
+        rule %r/[+-]?(\d+\.\d*|\d*\.\d+)/i, Literal::Number::Float
+        rule %r/[+-]?\d+/, Literal::Number::Integer
+        rule %r/&[CH][0-9a-f]+/i, Literal::Number::Hex
+        rule %r/&O[0-7]+/i, Literal::Number::Oct
+
+        rule %r/\b[\w\.]+\b/i, Text
+        rule(%r(<=|>=|<>|[=><\+\-\*\/\\]), Operator)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class XPath < RegexLexer
+      title 'XPath'
+      desc 'XML Path Language (XPath) 3.1'
+      tag 'xpath'
+      filenames '*.xpath'
+
+      # Terminal literals:
+      # https://www.w3.org/TR/xpath-31/#terminal-symbols
+      def self.digits
+        @digits ||= %r/[0-9]+/
+      end
+
+      def self.decimalLiteral
+        @decimalLiteral ||= %r/\.#{digits}|#{digits}\.[0-9]*/
+      end
+
+      def self.doubleLiteral
+        @doubleLiteral ||= %r/(\.#{digits})|#{digits}(\.[0-9]*)?[eE][+-]?#{digits}/
+      end
+
+      def self.stringLiteral
+        @stringLiteral ||= %r/("(("")|[^"])*")|('(('')|[^'])*')/
+      end
+
+      def self.ncName
+        @ncName ||= %r/[a-z_][a-z_\-.0-9]*/i
+      end
+
+      def self.qName
+        @qName ||= %r/(?:#{ncName})(?::#{ncName})?/
+      end
+
+      def self.uriQName
+        @uriQName ||= %r/Q\{[^{}]*\}#{ncName}/
+      end
+
+      def self.eqName
+        @eqName ||= %r/(?:#{uriQName}|#{qName})/
+      end
+
+      def self.commentStart
+        @commentStart ||= %r/\(:/
+      end
+
+      def self.openParen
+        @openParen ||= %r/\((?!:)/
+      end
+
+      # Terminal symbols:
+      # https://www.w3.org/TR/xpath-30/#id-terminal-delimitation
+      def self.kindTest
+        @kindTest ||= Regexp.union %w(
+          element attribute schema-element schema-attribute
+          comment text node document-node namespace-node
+        )
+      end
+
+      def self.kindTestForPI
+        @kindTestForPI ||= Regexp.union %w(processing-instruction)
+      end
+
+      def self.axes
+        @axes ||= Regexp.union %w(
+          child descendant attribute self descendant-or-self
+          following-sibling following namespace
+          parent ancestor preceding-sibling preceding ancestor-or-self
+        )
+      end
+
+      def self.operators
+        @operators ||= Regexp.union %w(, => = := : >= >> > <= << < - * != + // / || |)
+      end
+
+      def self.keywords
+        @keywords ||= Regexp.union %w(let for some every if then else return in satisfies)
+      end
+
+      def self.word_operators
+        @word_operators ||= Regexp.union %w(
+          and or eq ge gt le lt ne is
+          div mod idiv
+          intersect except union
+          to
+        )
+      end
+
+      def self.constructorTypes
+        @constructorTypes ||= Regexp.union %w(function array map empty-sequence)
+      end
+
+      # Mixin states:
+
+      state :commentsAndWhitespace do
+        rule XPath.commentStart, Comment, :comment
+        rule %r/\s+/m, Text::Whitespace
+      end
+
+      # Lexical states:
+      # https://www.w3.org/TR/xquery-xpath-parsing/#XPath-lexical-states
+      # https://lists.w3.org/Archives/Public/public-qt-comments/2004Aug/0127.html
+      # https://www.w3.org/TR/xpath-30/#id-revision-log
+      # https://www.w3.org/TR/xpath-31/#id-revision-log
+
+      state :root do
+        mixin :commentsAndWhitespace
+
+        # Literals
+        rule XPath.doubleLiteral, Num::Float
+        rule XPath.decimalLiteral, Num::Float
+        rule XPath.digits, Num
+        rule XPath.stringLiteral, Literal::String
+
+        # Variables
+        rule %r/\$/, Name::Variable, :varname
+
+        # Operators
+        rule XPath.operators, Operator
+        rule %r/#{XPath.word_operators}\b/, Operator::Word
+        rule %r/#{XPath.keywords}\b/, Keyword
+        rule %r/[?,{}()\[\]]/, Punctuation
+
+        # Functions
+        rule %r/(function)(\s*)(#{XPath.openParen})/ do # function declaration
+          groups Keyword, Text::Whitespace, Punctuation
+        end
+        rule %r/(map|array|empty-sequence)/, Keyword # constructors
+        rule %r/(#{XPath.kindTest})(\s*)(#{XPath.openParen})/ do  # kindtest
+          groups Keyword, Text::Whitespace, Punctuation
+          push :kindtest
+        end
+        rule %r/(#{XPath.kindTestForPI})(\s*)(#{XPath.openParen})/ do # processing instruction kindtest
+          groups Keyword, Text::Whitespace, Punctuation
+          push :kindtestforpi
+        end
+        rule %r/(#{XPath.eqName})(\s*)(#{XPath.openParen})/ do # function call
+          groups Name::Function, Text::Whitespace, Punctuation
+        end
+        rule %r/(#{XPath.eqName})(\s*)(#)(\s*)(\d+)/ do # namedFunctionRef
+          groups Name::Function, Text::Whitespace, Name::Function, Text::Whitespace, Name::Function
+        end
+
+        # Type commands
+        rule %r/(cast|castable)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          push :singletype
+        end
+        rule %r/(treat)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          push :itemtype
+        end
+        rule %r/(instance)(\s+)(of)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          push :itemtype
+        end
+        rule %r/(as)\b/ do
+          token Keyword
+          push :itemtype
+        end
+
+        # Paths
+        rule %r/(#{XPath.ncName})(\s*)(:)(\s*)(\*)/ do
+          groups Name::Tag, Text::Whitespace, Punctuation, Text::Whitespace, Operator
+        end
+        rule %r/(\*)(\s*)(:)(\s*)(#{XPath.ncName})/ do
+          groups Operator, Text::Whitespace, Punctuation, Text::Whitespace, Name::Tag
+        end
+        rule %r/(#{XPath.axes})(\s*)(::)/ do
+          groups Keyword, Text::Whitespace, Operator
+        end
+        rule %r/\.\.|\.|\*/, Operator
+        rule %r/@/, Name::Attribute, :attrname
+        rule XPath.eqName, Name::Tag
+      end
+
+      state :singletype do
+        mixin :commentsAndWhitespace
+
+        # Type name
+        rule XPath.eqName do
+          token Keyword::Type
+          pop!
+        end
+      end
+
+      state :itemtype do
+        mixin :commentsAndWhitespace
+
+        # Type tests
+        rule %r/(#{XPath.kindTest})(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+          # go to kindtest then occurrenceindicator
+          goto :occurrenceindicator
+          push :kindtest
+        end
+        rule %r/(#{XPath.kindTestForPI})(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+          # go to kindtestforpi then occurrenceindicator
+          goto :occurrenceindicator
+          push :kindtestforpi
+        end
+        rule %r/(item)(\s*)(#{XPath.openParen})(\s*)(\))/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation, Text::Whitespace, Punctuation
+          goto :occurrenceindicator
+        end
+        rule %r/(#{XPath.constructorTypes})(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+        end
+
+        # Type commands
+        rule %r/(cast|castable)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          goto :singletype
+        end
+        rule %r/(treat)(\s+)(as)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          goto :itemtype
+        end
+        rule %r/(instance)(\s+)(of)/ do
+          groups Keyword, Text::Whitespace, Keyword
+          goto :itemtype
+        end
+        rule %r/(as)\b/, Keyword
+
+        # Operators
+        rule XPath.operators do
+          token Operator
+          pop!
+        end
+        rule %r/#{XPath.word_operators}\b/ do
+          token Operator::Word
+          pop!
+        end
+        rule %r/#{XPath.keywords}\b/ do
+          token Keyword
+          pop!
+        end
+        rule %r/[\[),]/ do
+          token Punctuation
+          pop!
+        end
+
+        # Other types (e.g. xs:double)
+        rule XPath.eqName do
+          token Keyword::Type
+          goto :occurrenceindicator
+        end
+      end
+
+      # For pseudo-parameters for the KindTest productions
+      state :kindtest do
+        mixin :commentsAndWhitespace
+
+        # Pseudo-parameters:
+        rule %r/[?*]/, Operator
+        rule %r/,/, Punctuation
+        rule %r/(element|schema-element)(\s*)(#{XPath.openParen})/ do
+          groups Keyword::Type, Text::Whitespace, Punctuation
+          push :kindtest
+        end
+        rule XPath.eqName, Name::Tag
+
+        # End of pseudo-parameters
+        rule %r/\)/, Punctuation, :pop!
+      end
+
+      # Similar to :kindtest, but recognizes NCNames instead of EQNames
+      state :kindtestforpi do
+        mixin :commentsAndWhitespace
+
+        # Pseudo-parameters
+        rule XPath.ncName, Name
+        rule XPath.stringLiteral, Literal::String
+
+        # End of pseudo-parameters
+        rule %r/\)/, Punctuation, :pop!
+      end
+
+      state :occurrenceindicator do
+        mixin :commentsAndWhitespace
+
+        # Occurrence indicator
+        rule %r/[?*+]/ do
+          token Operator
+          pop!
+        end
+
+        # Otherwise, lex it in root state:
+        rule %r/(?![?*+])/ do
+          pop!
+        end
+      end
+
+      state :varname do
+        mixin :commentsAndWhitespace
+
+        # Function call
+        rule %r/(#{XPath.eqName})(\s*)(#{XPath.openParen})/ do
+          groups Name::Variable, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # Variable name
+        rule XPath.eqName, Name::Variable, :pop!
+      end
+
+      state :attrname do
+        mixin :commentsAndWhitespace
+
+        # Attribute name
+        rule XPath.eqName, Name::Attribute, :pop!
+        rule %r/\*/, Operator, :pop!
+      end
+
+      state :comment do
+        # Comment end
+        rule %r/:\)/, Comment, :pop!
+
+        # Nested comment
+        rule XPath.commentStart, Comment, :comment
+
+        # Comment contents
+        rule %r/[^:(]+/m, Comment
+        rule %r/[:(]/, Comment
+      end
+    end
+  end
+end