nano-clean-pkg 0.0.1

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

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Docker < RegexLexer
+      title "Docker"
+      desc "Dockerfile syntax"
+      tag 'docker'
+      aliases 'dockerfile', 'Dockerfile', 'containerfile', 'Containerfile'
+      filenames 'Dockerfile', 'Dockerfile.*', '*.Dockerfile', '*.docker', 'Containerfile', 'Containerfile.*', '*.Containerfile'
+      mimetypes 'text/x-dockerfile-config'
+
+      KEYWORDS = %w(
+        FROM MAINTAINER CMD LABEL EXPOSE ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ARG STOPSIGNAL HEALTHCHECK SHELL
+      ).join('|')
+
+      start { @shell = Shell.new(@options) }
+
+      state :root do
+        rule %r/\s+/, Text
+
+        rule %r/^(FROM)(\s+)(.*)(\s+)(AS)(\s+)(.*)/io do
+          groups Keyword, Text::Whitespace, Str, Text::Whitespace, Keyword, Text::Whitespace, Str
+        end
+
+        rule %r/^(ONBUILD)(\s+)(#{KEYWORDS})(.*)/io do
+          groups Keyword, Text::Whitespace, Keyword, Str
+        end
+
+        rule %r/^(#{KEYWORDS})\b(.*)/io do
+          groups Keyword, Str
+        end
+
+        rule %r/#.*?$/, Comment
+
+        rule %r/^(ONBUILD\s+)?RUN(\s+)/i do
+          token Keyword
+          push :run
+          @shell.reset!
+        end
+
+        rule %r/\w+/, Text
+        rule %r/[^\w]+/, Text
+        rule %r/./, Text
+      end
+
+      state :run do
+        rule %r/\n/, Text, :pop!
+        rule %r/\\./m, Str::Escape
+        rule(/(\\.|[^\n\\])+/) { delegate @shell }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dot < RegexLexer
+      title "DOT"
+      desc "graph description language"
+
+      tag 'dot'
+      aliases 'graphviz'
+      filenames '*.dot'
+      mimetypes 'text/vnd.graphviz'
+
+      start do
+        @html = HTML.new(options)
+      end
+
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r(#.*), Comment::Single
+        rule %r(//.*?$), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+      end
+
+      state :html do
+        rule %r/[^<>]+/ do
+          delegate @html
+        end
+        rule %r/<.+?>/m do
+          delegate @html
+        end
+        rule %r/>/, Punctuation, :pop!
+      end
+
+      state :ID do
+        rule %r/([a-zA-Z][a-zA-Z_0-9]*)(\s*)(=)/ do |m|
+          token Name, m[1]
+          token Text, m[2]
+          token Punctuation, m[3]
+        end
+        rule %r/[a-zA-Z][a-zA-Z_0-9]*/, Name::Variable
+        rule %r/([0-9]+)?\.[0-9]+/, Num::Float
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\"|[^"])*"/, Str::Double
+        rule %r/</ do
+          token Punctuation
+          @html.reset!
+          push :html
+        end
+      end
+
+      state :a_list do
+        mixin :comments_and_whitespace
+        mixin :ID
+        rule %r/[=;,]/, Punctuation
+        rule %r/\]/, Operator, :pop!
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+        rule %r/\b(strict|graph|digraph|subgraph|node|edge)\b/i, Keyword
+        rule %r/[{};:=]/, Punctuation
+        rule %r/-[->]/, Operator
+        rule %r/\[/, Operator, :a_list
+        mixin :ID
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dylan < RegexLexer
+      title 'Dylan'
+      desc 'Dylan Language (https://opendylan.org)'
+      tag 'dylan'
+      filenames '*.dylan'
+
+      # Definitions from the Dylan Reference Manual
+      # see:
+      # https://opendylan.org/books/drm/Modules
+      # https://opendylan.org/books/drm/Conditional_Execution
+      # https://opendylan.org/books/drm/Statement_Macros
+      reserved_words = Set.new %w(
+        begin block case class constant create define domain else
+        end exception for function generic handler if let library local
+        macro method module otherwise select unless until variable while
+      )
+
+      hash_word = Set.new %w(#t #f #next #rest #key #all-keys #include)
+      operators = Set.new %w(+ - * / ^ = == ~ ~= ~== < <= > >= & | :=)
+
+      state :root do
+        rule %r/^[\w.-]+:/, Comment::Preproc, :header
+        rule %r/\s+/, Text::Whitespace
+        rule(%r//) { goto :main }
+      end
+
+      # see https://opendylan.org/books/drm/Dylan_Interchange_Format
+      state :header do
+        rule(/.*?$/) { token Comment; goto :header_value }
+      end
+
+      state :header_value do
+        # line continuations are defined as any line that starts with whitespace
+        rule %r/^[ \t]+.*?$/, Comment
+        rule %r/\n+/, Comment
+        rule(//) { pop! }
+      end
+
+      state :main do
+        # Comments
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r/\s+/, Text::Whitespace
+
+        # Keywords
+        rule %r/\w+/ do |m|
+          if reserved_words.include?(m[0])
+            token Keyword
+          elsif hash_word.include?(m[0])
+            token Keyword::Constant
+          else
+            fallthrough!
+          end
+        end
+
+        rule %r/#(t|f|next|rest|key|all-keys|include)\b/, Keyword::Constant
+
+        # Numbers
+        rule %r([+-]?\d+/\d+), Literal::Number::Other
+        rule %r/[+-]?\d*[.]\d+(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/[+-]?\d+[.]\d*(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/[+-]\d+(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/#b[01]+/, Literal::Number::Bin
+        rule %r/#o[0-7]+/, Literal::Number::Oct
+        rule %r/[+-]?[0-9]+/, Literal::Number::Integer
+        rule %r/#x[0-9a-f]+/i, Literal::Number::Hex
+
+        # Operators and punctuation
+        rule %r/::|=>|#[(\[#]|[.][.][.]|[(),.;\[\]{}=?]/, Punctuation
+
+        word_re = %r([\w!&*<>|^\$%@][\w!&*<>|^\$%@=/?~+-]*|[+-~])
+
+        rule %r/\\#{word_re}/, Str::Symbol
+
+        rule word_re do |m|
+          word = m[0]
+          if operators.include?(word)
+            token Operator
+          elsif word.start_with?('<') && word.end_with?('>')
+            token Name::Class
+          elsif word.start_with?('*') && word.end_with?('*')
+            token Name::Variable::Instance
+          elsif word.start_with?('$')
+            token Name::Constant
+          else
+            token Name
+          end
+        end
+
+        rule %r/:/, Operator # For 'constrained names'
+        # Strings, characters and whitespace
+        rule %r/"/, Str::Double, :dq
+        rule %r/'([^\\']|(\\[\\'abefnrt0])|(\\[0-9a-f]+))'/, Str::Char
+      end
+
+      state :dq do
+        rule %r/\\[\\'"abefnrt0]/, Str::Escape
+        rule %r/\\<\h+>/, Str::Escape
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# -*- codding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ECL < RegexLexer
+      tag 'ecl'
+      filenames '*.ecl'
+      mimetypes 'application/x-ecl'
+
+      title "ECL"
+      desc "Enterprise Control Language (hpccsystems.com)"
+
+      id = /(#?)\b([a-z_][\w]*?)(\d*)\b/i
+
+      def self.class_first
+        @class_first ||= Set.new %w(
+          file date str math metaphone metaphone3 uni audit blas system
+        )
+      end
+
+      def self.class_second
+        @class_second ||= Set.new %w(
+          debug email job log thorlib util workunit
+        )
+      end
+
+      def self.functions
+        @functions ||= Set.new %w(
+          abs acos aggregate allnodes apply ascii asin asstring atan _token ave
+          case catch choose choosen choosesets clustersize combine correlation
+          cos cosh count covariance cron dataset dedup define denormalize
+          dictionary distribute distributed distribution ebcdic enth error
+          evaluate event eventextra eventname exists exp failcode failmessage
+          fetch fromunicode fromxml getenv getisvalid global graph group hash
+          hashcrc having httpcall httpheader if iff index intformat isvalid
+          iterate join keyunicode length library limit ln local log loop map
+          matched matchlength matchposition matchtext matchunicode max merge
+          mergejoin min nofold nolocal nonempty normalize parse pipe power
+          preload process project pull random range rank ranked realformat
+          recordof regexfind regexreplace regroup rejected rollup round roundup
+          row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt
+          stepped stored sum table tan tanh thisnode topn tounicode toxml
+          transfer transform trim truncate typeof ungroup unicodeorder variance
+          which workunit xmldecode xmlencode xmltext xmlunicode assert
+          build buildindex fail keydiff keypatch loadxml nothor notify
+          output parallel sequential wait
+        )
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          and or in not all any as from atmost before best between case const
+          counter csv descend encrypt end endmacro enum except exclusive expire
+          export extend fail few first flat full function functionmacro group
+          heading hole ifblock import joined keep keyed last left limit load
+          local locale lookup many maxcount maxlength _token module interface
+          named nocase noroot noscan nosort of only opt outer overwrite packed
+          partition penalty physicallength pipe quote record repeat return
+          right rows scan self separator service shared skew skip sql store
+          terminator thor threshold token transform trim type unicodeorder
+          unsorted validate virtual whole wild within xml xpath after cluster
+          compressed compression default encoding escape fileposition forward
+          grouped inner internal linkcounted literal lzw mofn multiple
+          namespace wnotrim noxpath onfail prefetch retry rowset scope smart
+          soapaction stable timelimit timeout unordered unstable update use
+          width
+        )
+      end
+
+      def self.template
+        @template ||= Set.new %w(
+          append apply break constant debug declare demangle else elseif end
+          endregion error expand export exportxml for forall getdatatype if
+          ifdefined inmodule isdefined isvalid line link loop mangle onwarning
+          option region set stored text trace uniquename warning webservice
+          workunit loadxml
+        )
+      end
+
+      def self.type
+        @type ||= Set.new %w(
+          ascii big_endian boolean data decimal ebcdic grouped integer
+          linkcounted pattern qstring real record rule set of streamed string
+          token udecimal unicode utf8 unsigned varstring varunicode
+        )
+      end
+
+      def self.typed
+        @typed ||= Set.new %w(
+          data string qstring varstring varunicode unicode utf8
+        )
+      end
+
+      state :single_quote do
+        rule %r([xDQUV]?'([^'\\]*(?:\\.[^'\\]*)*)'), Str::Single
+        rule %r/\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)/, Text
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text
+        rule %r(//.*), Comment::Single
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :single_quote
+
+        rule %r(\b(?i:(and|not|or|in))\b), Operator::Word
+        rule %r(:=|>|<|<>|/|\\|\+|-|=), Operator
+        rule %r([\[\]{}();,\&\.\%]), Punctuation
+
+        rule %r(\b(?i:(beginc\+\+.*?endc\+\+)))m, Str::Single
+        rule %r(\b(?i:(embed.*?endembed)))m, Str::Single
+
+        rule %r(\b(\w+)\.(\w+)\.(\w+)) do |m|
+          if m[1] == "std" &&
+             self.class.class_first.include?(m[2]) &&
+             self.class.class_second.include?(m[3])
+            token Name::Class
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r(\b(?i:(u)?decimal)(\d+(_\d+)?)\b), Keyword::Type
+
+        rule %r/\d+\.\d+(e[\+\-]?\d+)?/i, Num::Float
+        rule %r/x[0-9a-f]+/i, Num::Hex
+
+        rule %r/0x[0-9a-f]+/i, Num::Hex
+        rule %r/0[0-9a-f]+x/i, Num::Hex
+        rule %r(0[bB][01]+), Num::Bin
+        rule %r([01]+[bB]), Num::Bin
+        rule %r(\d+), Num::Integer
+
+        rule id do |m|
+          name_only = m[2].downcase
+          name      = name_only + m[3]
+          number    = (m[3] == "") ? nil : m[3].to_i
+          if m[1] == "#"
+            if self.class.template.include? name
+              token Keyword::Type
+            else
+              token Error
+            end
+          elsif self.class.typed.include?(name_only) && number != nil
+            token Keyword::Type
+          elsif self.class.type.include? name
+            token Keyword::Type
+          elsif self.class.keywords.include? name
+            token Keyword
+          elsif self.class.functions.include? name
+            token Name::Function
+          elsif ["integer", "unsigned"].include?(name_only) && (1..8).cover?(number)
+            token Keyword::Type
+          elsif name_only == "real" && [4, 8].include?(number)
+            token Keyword::Type
+          elsif ["true", "false"].include? name
+            token Keyword::Constant
+          else
+            token Name::Other
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class EEX < TemplateLexer
+      title "EEX"
+      desc "Embedded Elixir"
+
+      tag 'eex'
+      aliases 'leex', 'heex'
+
+      filenames '*.eex', '*.leex', '*.heex'
+
+      def initialize(opts={})
+        @elixir_lexer = Elixir.new(opts)
+
+        super(opts)
+      end
+
+      start do
+        parent.reset!
+        @elixir_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|<%/
+      close = /%%>|%>/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :elixir
+
+        rule %r/.+?(?=#{open})|.+/mo do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/mo, Comment
+      end
+
+      state :elixir do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/mo do
+          delegate @elixir_lexer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Eiffel < RegexLexer
+      title "Eiffel"
+      desc "Eiffel programming language"
+
+      tag 'eiffel'
+      filenames '*.e'
+      mimetypes 'text/x-eiffel'
+
+      LanguageKeywords = %w(
+        across agent alias all and attached as assign attribute check
+        class convert create debug deferred detachable do else elseif end
+        ensure expanded export external feature from frozen if implies  inherit
+        inspect invariant like local loop not note obsolete old once or
+        Precursor redefine rename require rescue retry select separate
+        some then undefine until variant Void when xor
+      )
+
+      BooleanConstants = %w(True False)
+
+      LanguageVariables = %w(Current Result)
+
+      SimpleString = /(?:[^"%\b\f\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)+?/
+
+      state :root do
+        rule %r/"\[/, Str::Other, :aligned_verbatim_string
+        rule %r/"\{/, Str::Other, :non_aligned_verbatim_string
+        rule %r/"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
+        rule %r/--.*/, Comment::Single
+        rule %r/'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
+
+        rule %r/(?:#{LanguageKeywords.join('|')})\b/, Keyword
+        rule %r/(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
+        rule %r/(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
+
+        rule %r/\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
+        rule %r/\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
+        rule %r/\b0[bB][01](?:_*[01])*\b/, Num::Bin
+        rule %r/\d(?:_*\d)*/, Num::Integer
+        rule %r/(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
+
+        rule %r/:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
+        rule %r/\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~≤≥−∀∃¦⟳⟲]/, Operator
+
+        rule %r/[A-Z][\dA-Z_]*/, Name::Class
+        rule %r/[A-Za-z][\dA-Za-z_]*/, Name
+        rule %r/\s+/, Text
+      end
+
+      state :aligned_verbatim_string do
+        rule %r/]"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+
+      state :non_aligned_verbatim_string do
+        rule %r/}"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # Direct port of pygments Lexer.
+    # See: https://bitbucket.org/birkenfeld/pygments-main/src/7304e4759ae65343d89a51359ca538912519cc31/pygments/lexers/functional.py?at=default#cl-2362
+    class Elixir < RegexLexer
+      title "Elixir"
+      desc "Elixir language (elixir-lang.org)"
+
+      tag 'elixir'
+      aliases 'elixir', 'exs'
+
+      filenames '*.ex', '*.exs'
+
+      def self.detect?(text)
+        return true if text.shebang?('elixir')
+      end
+
+      mimetypes 'text/x-elixir', 'application/x-elixir'
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/#.*$/, Comment::Single
+        rule %r{\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|
+             defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|
+             defexception|defguardp?|defstruct|exit|raise|throw|after|rescue|catch|else)\b(?![?!])|
+             (?<!\.)\b(do|\-\>)\b}x, Keyword
+        rule %r/\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, Keyword::Namespace
+        rule %r/(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
+        rule %r{%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|
+             <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s])\?|
+             (?<=[\s])!+|&(&&?|(?!\d))|\|\||\^|\*|\+|\-|/|
+             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.|~~~}x, Operator
+        rule %r{(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|
+             <=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|
+             \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, Str::Symbol
+        rule %r/:"/, Str::Symbol, :interpoling_symbol
+        rule %r/\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
+        rule %r/\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
+        rule %r/[a-zA-Z_!]\w*[!\?]?/, Name
+        rule %r{::|[%(){};,/\|:\\\[\]]}, Punctuation
+        rule %r/@[a-zA-Z_]\w*|&\d/, Name::Variable
+        rule %r{\b\d(_?\d)*(\.(?![^\d\s])(_?\d)+)([eE][-+]?\d(_?\d)*)?\b}, Num::Float
+        rule %r{\b0x[0-9A-Fa-f](_?[0-9A-Fa-f])*\b}, Num::Hex
+        rule %r{\b0o[0-7](_?[0-7])*\b}, Num::Oct
+        rule %r{\b0b[01](_?[01])*\b}, Num::Bin
+        rule %r{\b\d(_?\d)*\b}, Num::Integer
+
+        mixin :strings
+        mixin :sigil_strings
+      end
+
+      state :strings do
+        rule %r/(%[A-Ba-z])?"""(?:.|\n)*?"""/, Str::Doc
+        rule %r/'''(?:.|\n)*?'''/, Str::Doc
+        rule %r/"/, Str::Double, :dqs
+        rule %r/'/, Str::Single, :sqs
+        rule %r{(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b[^x0MC])|(\\[MC]-)+\w|[^\s\\])}, Str::Other
+      end
+
+      state :dqs do
+        mixin :escapes
+        mixin :interpoling
+        rule %r/[^#"\\]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[#\\]/, Str::Double
+      end
+
+      state :sqs do
+        mixin :escapes
+        mixin :interpoling
+        rule %r/[^#'\\]+/, Str::Single
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[#\\]/, Str::Single
+      end
+
+      state :interpoling do
+        rule %r/#\{/, Str::Interpol, :interpoling_string
+      end
+
+      state :interpoling_string do
+        rule %r/\}/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      state :escapes do
+        rule %r/\\x\h{2}/, Str::Escape
+        rule %r/\\u\{?\d+\}?/, Str::Escape
+        rule %r/\\[\\abdefnrstv0"']/, Str::Escape
+      end
+
+      state :interpoling_symbol do
+        rule %r/"/, Str::Symbol, :pop!
+        mixin :interpoling
+        rule %r/[^#"]+/, Str::Symbol
+      end
+
+      state :sigil_strings do
+        # ~-sigiled strings
+        # ~r(abc), ~r[abc], ~r<abc>, ~r|abc|, ~r/abc/, etc
+        # Cribbed and adjusted from Ruby lexer
+        delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
+        sigil_opens = Regexp.union(delimiter_map.keys + [%r/"{3}/] + %w(| / ' "))
+        rule %r/~([a-z]|[A-Z][A-Z0-9]*)(#{sigil_opens})/ do |m|
+          open = Regexp.escape(m[2])
+          close = Regexp.escape(delimiter_map[m[2]] || m[2])
+          interp = /^[srcw]$/ === m[1]
+          toktype = Str::Other
+
+          puts "    open: #{open.inspect}" if @debug
+          puts "    close: #{close.inspect}" if @debug
+
+          # regexes
+          if m[1] == 'r' || m[1] == 'R'
+            toktype = Str::Regex
+            push :regex_flags
+          end
+
+          if m[1] == 'w' || m[1] == 'W'
+            push :list_flags
+          end
+
+          if open == '"""'
+            toktype = Str::Doc
+          end
+
+          token toktype
+
+          push do
+            rule %r/#{close}/, toktype, :pop!
+
+            if toktype == Str::Doc
+              rule %r/(?:.|\n)*?"""/, toktype, :pop!
+            elsif interp
+              mixin :interpoling
+              rule %r/#/, toktype
+            else
+              rule %r/[\\#]/, toktype
+            end
+
+            uniq_chars = [open, close].uniq.join.squeeze
+            rule %r/[^##{uniq_chars}\\]+/m, toktype
+          end
+        end
+      end
+
+      state :regex_flags do
+        rule %r/[fgimrsux]*/, Str::Regex, :pop!
+      end
+
+      state :list_flags do
+        rule %r/[csa]?/, Str::Other, :pop!
+      end
+    end
+  end
+end