rouge-alda 3.3.0

data/lib/rouge/lexers/sed.rb

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Sed < RegexLexer
+      title "sed"
+      desc 'sed, the ultimate stream editor'
+
+      tag 'sed'
+      filenames '*.sed'
+      mimetypes 'text/x-sed'
+
+      def self.detect?(text)
+        return true if text.shebang? 'sed'
+      end
+
+      class Regex < RegexLexer
+        state :root do
+          rule /\\./, Str::Escape
+          rule /\[/, Punctuation, :brackets
+          rule /[$^.*]/, Operator
+          rule /[()]/, Punctuation
+          rule /./, Str::Regex
+        end
+
+        state :brackets do
+          rule /\^/ do
+            token Punctuation
+            goto :brackets_int
+          end
+
+          rule(//) { goto :brackets_int }
+        end
+
+        state :brackets_int do
+          # ranges
+          rule /.-./, Name::Variable
+          rule /\]/, Punctuation, :pop!
+          rule /./, Str::Regex
+        end
+      end
+
+      class Replacement < RegexLexer
+        state :root do
+          rule /\\./m, Str::Escape
+          rule /&/, Operator
+          rule /[^\\&]+/m, Text
+        end
+      end
+
+      def regex
+        @regex ||= Regex.new(options)
+      end
+
+      def replacement
+        @replacement ||= Replacement.new(options)
+      end
+
+      start { regex.reset!; replacement.reset! }
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule(/#.*?\n/) { token Comment; reset_stack }
+        rule(/\n/) { token Text; reset_stack }
+        rule(/;/) { token Punctuation; reset_stack }
+      end
+
+      state :root do
+        mixin :addr_range
+      end
+
+      edot = /\\.|./m
+
+      state :command do
+        mixin :whitespace
+
+        # subst and transliteration
+        rule /(s)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
+          token Keyword, m[1]
+          token Punctuation, m[2]
+          delegate regex, m[3]
+          token Punctuation, m[4]
+          delegate replacement, m[5]
+          token Punctuation, m[6]
+
+
+          goto :flags
+        end
+
+        rule /(y)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
+          token Keyword, m[1]
+          token Punctuation, m[2]
+          delegate replacement, m[3]
+          token Punctuation, m[4]
+          delegate replacement, m[5]
+          token Punctuation, m[6]
+
+          pop!
+        end
+
+        # commands that take a text segment as an argument
+        rule /([aic])(\s*)/ do
+          groups Keyword, Text; goto :text
+        end
+
+        rule /[pd]/, Keyword
+
+        # commands that take a number argument
+        rule /([qQl])(\s+)(\d+)/i do
+          groups Keyword, Text, Num
+          pop!
+        end
+
+        # no-argument commands
+        rule /[={}dDgGhHlnpPqx]/, Keyword, :pop!
+
+        # commands that take a filename argument
+        rule /([rRwW])(\s+)(\S+)/ do
+          groups Keyword, Text, Name
+          pop!
+        end
+
+        # commands that take a label argument
+        rule /([:btT])(\s+)(\S+)/ do
+          groups Keyword, Text, Name::Label
+          pop!
+        end
+      end
+
+      state :addr_range do
+        mixin :whitespace
+
+        ### address ranges ###
+        addr_tok = Keyword::Namespace
+        rule /\d+/, addr_tok
+        rule /[$,~+!]/, addr_tok
+
+        rule %r((/)((?:\\.|.)*?)(/)) do |m|
+          token addr_tok, m[1]; delegate regex, m[2]; token addr_tok, m[3]
+        end
+
+        # alternate regex rage delimiters
+        rule %r((\\)(.)(\\.|.)*?(\2)) do |m|
+          token addr_tok, m[1] + m[2]
+          delegate regex, m[3]
+          token addr_tok, m[4]
+        end
+
+        rule(//) { push :command }
+      end
+
+      state :text do
+        rule /[^\\\n]+/, Str
+        rule /\\\n/, Str::Escape
+        rule /\\/, Str
+        rule /\n/, Text, :pop!
+      end
+
+      state :flags do
+        rule /[gp]+/, Keyword, :pop!
+
+        # writing to a file with the subst command.
+        # who'da thunk...?
+        rule /([wW])(\s+)(\S+)/ do
+          token Keyword; token Text; token Name
+        end
+
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/shell.rb

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Shell < RegexLexer
+      title "shell"
+      desc "Various shell languages, including sh and bash"
+
+      tag 'shell'
+      aliases 'bash', 'zsh', 'ksh', 'sh'
+      filenames '*.sh', '*.bash', '*.zsh', '*.ksh',
+                '.bashrc', '.zshrc', '.kshrc', '.profile', 'PKGBUILD'
+
+      mimetypes 'application/x-sh', 'application/x-shellscript'
+
+      def self.detect?(text)
+        return true if text.shebang?(/(ba|z|k)?sh/)
+      end
+
+      KEYWORDS = %w(
+        if fi else while do done for then return function
+        select continue until esac elif in
+      ).join('|')
+
+      BUILTINS = %w(
+        alias bg bind break builtin caller cd command compgen
+        complete declare dirs disown enable eval exec exit
+        export false fc fg getopts hash help history jobs let
+        local logout mapfile popd pushd pwd read readonly set
+        shift shopt source suspend test time times trap true type
+        typeset ulimit umask unalias unset wait
+
+        cat tac nl od base32 base64 fmt pr fold head tail split csplit
+        wc sum cksum b2sum md5sum sha1sum sha224sum sha256sum sha384sum
+        sha512sum sort shuf uniq comm ptx tsort cut paste join tr expand
+        unexpand ls dir vdir dircolors cp dd install mv rm shred link ln
+        mkdir mkfifo mknod readlink rmdir unlink chown chgrp chmod touch
+        df du stat sync truncate echo printf yes expr tee basename dirname
+        pathchk mktemp realpath pwd stty printenv tty id logname whoami
+        groups users who date arch nproc uname hostname hostid uptime chcon
+        runcon chroot env nice nohup stdbuf timeout kill sleep factor numfmt
+        seq tar grep sudo awk sed gzip gunzip
+      ).join('|')
+
+      state :basic do
+        rule /#.*$/, Comment
+
+        rule /\b(#{KEYWORDS})\s*\b/, Keyword
+        rule /\bcase\b/, Keyword, :case
+
+        rule /\b(#{BUILTINS})\s*\b(?!(\.|-))/, Name::Builtin
+        rule /[.](?=\s)/, Name::Builtin
+
+        rule /(\b\w+)(=)/ do |m|
+          groups Name::Variable, Operator
+        end
+
+        rule /[\[\]{}()!=>]/, Operator
+        rule /&&|\|\|/, Operator
+
+        # here-string
+        rule /<<</, Operator
+
+        rule /(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
+          groups Operator, Text, Str::Heredoc, Str::Heredoc, Name::Constant, Str::Heredoc
+          @heredocstr = Regexp.escape(m[5])
+          push :heredoc
+        end
+      end
+
+      state :heredoc do
+        rule /\n/, Str::Heredoc, :heredoc_nl
+        rule /[^$\n]+/, Str::Heredoc
+        mixin :interp
+        rule /[$]/, Str::Heredoc
+      end
+
+      state :heredoc_nl do
+        rule /\s*(\w+)\s*\n/ do |m|
+          if m[1] == @heredocstr
+            token Name::Constant
+            pop! 2
+          else
+            token Str::Heredoc
+          end
+        end
+
+        rule(//) { pop! }
+      end
+
+
+      state :double_quotes do
+        # NB: "abc$" is literally the string abc$.
+        # Here we prevent :interp from interpreting $" as a variable.
+        rule /(?:\$#?)?"/, Str::Double, :pop!
+        mixin :interp
+        rule /[^"`\\$]+/, Str::Double
+      end
+
+      state :ansi_string do
+        rule /\\./, Str::Escape
+        rule /[^\\']+/, Str::Single
+        mixin :single_quotes
+      end
+
+      state :single_quotes do
+        rule /'/, Str::Single, :pop!
+        rule /[^']+/, Str::Single
+      end
+
+      state :data do
+        rule /\s+/, Text
+        rule /\\./, Str::Escape
+        rule /\$?"/, Str::Double, :double_quotes
+        rule /\$'/, Str::Single, :ansi_string
+
+        # single quotes are much easier than double quotes - we can
+        # literally just scan until the next single quote.
+        # POSIX: Enclosing characters in single-quotes ( '' )
+        # shall preserve the literal value of each character within the
+        # single-quotes. A single-quote cannot occur within single-quotes.
+        rule /'/, Str::Single, :single_quotes
+
+        rule /\*/, Keyword
+
+        rule /;/, Punctuation
+
+        rule /--?[\w-]+/, Name::Tag
+        rule /[^=\*\s{}()$"'`;\\<]+/, Text
+        rule /\d+(?= |\Z)/, Num
+        rule /</, Text
+        mixin :interp
+      end
+
+      state :curly do
+        rule /}/, Keyword, :pop!
+        rule /:-/, Keyword
+        rule /[a-zA-Z0-9_]+/, Name::Variable
+        rule /[^}:"`'$]+/, Punctuation
+        mixin :root
+      end
+
+      state :paren do
+        rule /\)/, Keyword, :pop!
+        mixin :root
+      end
+
+      state :math do
+        rule /\)\)/, Keyword, :pop!
+        rule %r([-+*/%^|&!]|\*\*|\|\|), Operator
+        rule /\d+(#\w+)?/, Num
+        mixin :root
+      end
+
+      state :case do
+        rule /\besac\b/, Keyword, :pop!
+        rule /\|/, Punctuation
+        rule /\)/, Punctuation, :case_stanza
+        mixin :root
+      end
+
+      state :case_stanza do
+        rule /;;/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :backticks do
+        rule /`/, Str::Backtick, :pop!
+        mixin :root
+      end
+
+      state :interp do
+        rule /\\$/, Str::Escape # line continuation
+        rule /\\./, Str::Escape
+        rule /\$\(\(/, Keyword, :math
+        rule /\$\(/, Keyword, :paren
+        rule /\${#?/, Keyword, :curly
+        rule /`/, Str::Backtick, :backticks
+        rule /\$#?(\w+|.)/, Name::Variable
+        rule /\$[*@]/, Name::Variable
+      end
+
+      state :root do
+        mixin :basic
+        mixin :data
+      end
+    end
+  end
+end

data/lib/rouge/lexers/sieve.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Sieve < RegexLexer
+      title "Sieve"
+      desc "mail filtering language"
+
+      tag 'sieve'
+      filenames '*.sieve'
+
+      id = /:?[a-zA-Z_][a-zA-Z0-9_]*/
+
+      # control commands (rfc5228 § 3)
+      def self.controls
+        @controls ||= %w(if elsif else require stop)
+      end
+
+      def self.actions
+        @actions ||= Set.new(
+          # action commands (rfc5228 § 2.9)
+          %w(keep fileinto redirect discard) +
+          # Editheader Extension (rfc5293)
+          %w(addheader deleteheader) +
+          # Reject and Extended Reject Extensions (rfc5429)
+          %w(reject ereject) +
+          # Extension for Notifications (rfc5435)
+          %w(notify) +
+          # Imap4flags Extension (rfc5232)
+          %w(setflag addflag removeflag) +
+          # Vacation Extension (rfc5230)
+          %w(vacation) +
+          # MIME Part Tests, Iteration, Extraction, Replacement, and Enclosure (rfc5703)
+          %w(replace enclose extracttext)
+        )
+      end
+
+      def self.tests
+        @tests ||= Set.new(
+          # test commands (rfc5228 § 5)
+          %w(address allof anyof exists false header not size true) +
+          # Body Extension (rfc5173)
+          %w(body) +
+          # Imap4flags Extension (rfc5232)
+          %w(hasflag) +
+          # Spamtest and Virustest Extensions (rfc5235)
+          %w(spamtest virustest) +
+          # Date and Index Extensions (rfc5260)
+          %w(date currentdate) +
+          # Extension for Notifications (rfc5435)
+          %w(valid_notify_method notify_method_capability) +
+          # Extensions for Checking Mailbox Status and Accessing Mailbox
+          # Metadata (rfc5490)
+          %w(mailboxexists metadata metadataexists servermetadata servermetadataexists)
+        )
+      end
+
+      state :comments_and_whitespace do
+        rule /\s+/, Text
+        rule %r(#.*?\n), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+      end
+
+      state :string do
+        rule /\\./, Str::Escape
+        rule /"/, Str::Double, :pop!
+        # Variables Extension (rfc5229)
+        rule /\${(?:[0-9][.0-9]*|[a-zA-Z_][.a-zA-Z0-9_]*)}/, Str::Interpol
+        rule /./, Str::Double
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+
+        rule /[\[\](),;{}]/, Punctuation
+
+        rule id do |m|
+          if self.class.controls.include? m[0]
+            token Keyword
+          elsif self.class.tests.include? m[0]
+            token Name::Variable
+          elsif self.class.actions.include? m[0]
+            token Name::Function
+          elsif m[0] =~ /^:/ # tags like :contains, :matches etc.
+            token Operator
+          else
+            token Name::Other
+          end
+        end
+
+        rule /"/, Str::Double, :string
+        rule /[0-9]+[KMG]/, Num::Integer
+      end
+    end
+  end
+end

data/lib/rouge/lexers/slim.rb

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # A lexer for the Slim tempalte language
+    # @see http://slim-lang.org
+    class Slim < RegexLexer
+      include Indentation
+
+      title "Slim"
+      desc 'The Slim template language'
+
+      tag 'slim'
+
+      filenames '*.slim'
+
+      # Ruby identifier characters
+      ruby_chars = /[\w\!\?\@\$]/
+
+      # Since you are allowed to wrap lines with a backslash, include \\\n in characters
+      dot = /(\\\n|.)/
+
+      def ruby
+        @ruby ||= Ruby.new(options)
+      end
+
+      def html
+        @html ||= HTML.new(options)
+      end
+
+      def filters
+        @filters ||= {
+          'ruby' => ruby,
+          'erb' => ERB.new(options),
+          'javascript' => Javascript.new(options),
+          'css' => CSS.new(options),
+          'coffee' => Coffeescript.new(options),
+          'markdown' => Markdown.new(options),
+          'scss' => Scss.new(options),
+          'sass' => Sass.new(options)
+        }
+      end
+
+      start { ruby.reset!; html.reset! }
+
+      state :root do
+        rule /\s*\n/, Text
+        rule(/\s*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        mixin :css
+
+        rule /\/#{dot}*/, Comment, :indented_block
+
+        rule /(doctype)(\s+)(.*)/ do
+          groups Name::Namespace, Text::Whitespace, Text
+          pop!
+        end
+
+        # filters, shamelessly ripped from HAML
+        rule /(\w*):\s*\n/ do |m|
+          token Name::Decorator
+          pop!
+          starts_block :filter_block
+
+          filter_name = m[1].strip
+
+          @filter_lexer = self.filters[filter_name]
+          @filter_lexer.reset! unless @filter_lexer.nil?
+
+          puts "    slim: filter #{filter_name.inspect} #{@filter_lexer.inspect}" if @debug
+        end
+
+        # Text
+        rule %r([\|'](?=\s)) do
+          token Punctuation
+          pop!
+          starts_block :plain_block
+          goto :plain_block
+        end
+
+        rule /-|==|=/, Punctuation, :ruby_line
+
+        # Dynamic tags
+        rule /(\*)(#{ruby_chars}+\(.*?\))/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        #rule /<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
+        rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
+          delegate html, m[1]
+          pop!
+        end
+
+        # Ordinary slim tags
+        rule /\w+/, Name::Tag, :tag
+
+      end
+
+      state :tag do
+        mixin :css
+        mixin :indented_block
+        mixin :interpolation
+
+        # Whitespace control
+        rule /[<>]/, Punctuation
+
+        # Trim whitespace
+        rule /\s+?/, Text::Whitespace
+
+        # Splats, these two might be mergable?
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        rule /(\*)(\{#{dot}+?\})/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        # Attributes
+        rule /([\w\-]+)(\s*)(\=)/ do |m|
+          token Name::Attribute, m[1]
+          token Text::Whitespace, m[2]
+          token Punctuation, m[3]
+          push :html_attr
+        end
+
+        # Ruby value
+        rule /(\=)(#{dot}+)/ do |m|
+          token Punctuation, m[1]
+          #token Keyword::Constant, m[2]
+          delegate ruby, m[2]
+        end
+
+        # HTML Entities
+        rule(/&\S*?;/, Name::Entity)
+
+        rule /#{dot}+?/, Text
+
+        rule /\s*\n/, Text::Whitespace, :pop!
+      end
+
+      state :css do
+        rule(/\.[\w-]*/) { token Name::Class; goto :tag }
+        rule(/#[a-zA-Z][\w:-]*/) { token Name::Function; goto :tag }
+      end
+
+      state :html_attr do
+        # Strings, double/single quoted
+        rule(/\s*(['"])#{dot}*?\1/, Literal::String, :pop!)
+
+        # Ruby stuff
+        rule(/(#{ruby_chars}+\(.*?\))/) { |m| delegate ruby, m[1]; pop! }
+        rule(/(#{ruby_chars}+)/) { |m| delegate ruby, m[1]; pop! }
+
+        rule /\s+/, Text::Whitespace
+      end
+
+      state :ruby_line do
+        # Need at top
+        mixin :indented_block
+
+        rule(/,\s*\n/) { delegate ruby }
+        rule /[ ]\|[ \t]*\n/, Str::Escape
+        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+      end
+
+      state :filter_block do
+        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+          if @filter_lexer
+            delegate @filter_lexer
+          else
+            token Name::Decorator
+          end
+        end
+
+        mixin :interpolation
+        mixin :indented_block
+      end
+
+      state :plain_block do
+        mixin :interpolation
+
+        rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
+          delegate html, m[1]
+        end
+
+        # HTML Entities
+        rule(/&\S*?;/, Name::Entity)
+
+        #rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule /#{dot}+?/, Text
+
+        mixin :indented_block
+      end
+
+      state :interpolation do
+        rule /#[{]/, Str::Interpol, :ruby_interp
+      end
+
+      state :ruby_interp do
+        rule /[}]/, Str::Interpol, :pop!
+        mixin :ruby_interp_inner
+      end
+
+      state :ruby_interp_inner do
+        rule(/[{]/) { delegate ruby; push :ruby_interp_inner }
+        rule(/[}]/) { delegate ruby; pop! }
+        rule(/[^{}]+/) { delegate ruby }
+      end
+
+      state :indented_block do
+        rule(/(?<!\\)\n/) { token Text; reset_stack }
+      end
+    end
+  end
+end