rugments 1.0.0.beta1

data/lib/rugments/lexers/tcl.rb

@@ -0,0 +1,189 @@
+module Rugments
+  module Lexers
+    class TCL < RegexLexer
+      title 'Tcl'
+      desc 'The Tool Command Language (tcl.tk)'
+      tag 'tcl'
+      filenames '*.tcl'
+      mimetypes 'text/x-tcl', 'text/x-script.tcl', 'application/x-tcl'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'tclsh'
+        return 1 if text.shebang? 'wish'
+        return 1 if text.shebang? 'jimsh'
+      end
+
+      KEYWORDS = %w(
+        after apply array break catch continue elseif else error
+        eval expr for foreach global if namespace proc rename return
+        set switch then trace unset update uplevel upvar variable
+        vwait while
+      )
+
+      BUILTINS = %w(
+        append bgerror binary cd chan clock close concat dde dict
+        encoding eof exec exit fblocked fconfigure fcopy file
+        fileevent flush format gets glob history http incr info interp
+        join lappend lassign lindex linsert list llength load loadTk
+        lrange lrepeat lreplace lreverse lsearch lset lsort mathfunc
+        mathop memory msgcat open package pid pkg::create pkg_mkIndex
+        platform platform::shell puts pwd re_syntax read refchan
+        regexp registry regsub scan seek socket source split string
+        subst tell time tm unknown unload
+      )
+
+      OPEN =  %w| \( \[ \{ " |
+      CLOSE = %w| \) \] \} |
+      ALL = OPEN + CLOSE
+      END_LINE = CLOSE + %w(; \n)
+      END_WORD = END_LINE + %w(\s)
+
+      CHARS =     lambda { |list| Regexp.new %([#{list.join}])  }
+      NOT_CHARS = lambda { |list| Regexp.new %([^#{list.join}]) }
+
+      state :word do
+        rule /\{\*\}/, Keyword
+
+        mixin :brace_abort
+        mixin :interp
+        rule /\{/, Punctuation, :brace
+        rule /\(/, Punctuation,   :paren
+        rule /"/,  Str::Double, :string
+        rule /#{NOT_CHARS[END_WORD]}+?(?=#{CHARS[OPEN + ['\\\\']]})/, Text
+      end
+
+      def self.gen_command_state(name = '')
+        state(:"command#{name}") do
+          mixin :word
+
+          rule /##{NOT_CHARS[END_LINE]}+/, Comment::Single
+
+          rule /(?=#{CHARS[END_WORD]})/ do
+            push :"params#{name}"
+          end
+
+          rule /#{NOT_CHARS[END_WORD]}+/ do |m|
+            if KEYWORDS.include? m[0]
+              token Keyword
+            elsif BUILTINS.include? m[0]
+              token Name::Builtin
+            else
+              token Text
+            end
+          end
+
+          mixin :whitespace
+        end
+      end
+
+      def self.gen_delimiter_states(name, close, opts = {})
+        gen_command_state("_in_#{name}")
+
+        state :"params_in_#{name}" do
+          rule close do
+            token Punctuation
+            pop! 2
+          end
+
+          # mismatched delimiters.  Braced strings with mismatched
+          # closing delimiters should be okay, since this is standard
+          # practice, like {]]]]}
+          if opts[:strict]
+            rule CHARS[CLOSE - [close]], Error
+          else
+            rule CHARS[CLOSE - [close]], Text
+          end
+
+          mixin :params
+        end
+
+        state name do
+          rule close, Punctuation, :pop!
+          mixin :"command_in_#{name}"
+        end
+      end
+
+      # tcl is freaking impossible.  If we're in braces and we encounter
+      # a close brace, we have to drop everything and close the brace.
+      # This is so silly things like {abc"def} and {abc]def} don't b0rk
+      # everything after them.
+
+      # TODO: TCL seems to have this aborting behavior quite a lot.
+      # such things as [ abc" ] are a runtime error, but will still
+      # parse.  Currently something like this will muck up the lex.
+      state :brace_abort do
+        rule /}/ do
+          if in_state? :brace
+            pop! until state? :brace
+            pop!
+            token Punctuation
+          else
+            token Error
+          end
+        end
+      end
+
+      state :params do
+        rule /;/, Punctuation, :pop!
+        rule /\n/, Text, :pop!
+        rule /else|elseif|then/, Keyword
+        mixin :word
+        mixin :whitespace
+        rule /#{NOT_CHARS[END_WORD]}+/, Text
+      end
+
+      gen_delimiter_states :brace,   /\}/, strict: false
+      gen_delimiter_states :paren,   /\)/, strict: true
+      gen_delimiter_states :bracket, /\]/, strict: true
+      gen_command_state
+
+      state :root do
+        mixin :command
+      end
+
+      state :whitespace do
+        # not a multiline regex because we want to capture \n sometimes
+        rule /\s+/, Text
+      end
+
+      state :interp do
+        rule /\[/, Punctuation, :bracket
+        rule /\$[a-z0-9.:-]+/, Name::Variable
+        rule /\$\{.*?\}/m, Name::Variable
+        rule /\$/, Text
+
+        # escape sequences
+        rule /\\[0-7]{3}/, Str::Escape
+        rule /\\x[0-9a-f]{2}/i, Str::Escape
+        rule /\\u[0-9a-f]{4}/i, Str::Escape
+        rule /\\./m, Str::Escape
+      end
+
+      state :string do
+        rule /"/, Str::Double, :pop!
+        mixin :interp
+        rule /[^\\\[\$"{}]+/m, Str::Double
+
+        # strings have to keep count of their internal braces, to support
+        # for example { "{ }" }.
+        rule /{/ do
+          @brace_count ||= 0
+          @brace_count += 1
+
+          token Str::Double
+        end
+
+        rule /}/ do
+          if in_state?(:brace) && @brace_count.to_i == 0
+            pop! until state? :brace
+            pop!
+            token Punctuation
+          else
+            @brace_count -= 1
+            token Str::Double
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rugments/lexers/tex.rb

@@ -0,0 +1,70 @@
+module Rugments
+  module Lexers
+    class TeX < RegexLexer
+      title 'TeX'
+      desc 'The TeX typesetting system'
+      tag 'tex'
+      aliases 'TeX', 'LaTeX', 'latex'
+
+      filenames '*.tex', '*.aux', '*.toc'
+      mimetypes 'text/x-tex', 'text/x-latex'
+
+      def self.analyze_text(text)
+        return 1 if text =~ /\A\s*\\documentclass/
+        return 1 if text =~ /\A\s*\\input/
+        return 1 if text =~ /\A\s*\\documentstyle/
+        return 1 if text =~ /\A\s*\\relax/
+      end
+
+      command = /\\([a-z]+|\s+|.)/i
+
+      state :general do
+        rule /%.*$/, Comment
+        rule /[{}&_^]/, Punctuation
+      end
+
+      state :root do
+        rule /\\\[/, Punctuation, :displaymath
+        rule /\\\(/, Punctuation, :inlinemath
+        rule /\$\$/, Punctuation, :displaymath
+        rule /\$/, Punctuation, :inlinemath
+        rule /\\(begin|end)\{.*?\}/, Name::Tag
+
+        rule /(\\verb)\b(\S)(.*?)(\2)/ do |_m|
+          groups Name::Builtin, Keyword::Pseudo, Str::Other, Keyword::Pseudo
+        end
+
+        rule command, Keyword, :command
+        mixin :general
+        rule /[^\\$%&_^{}]+/, Text
+      end
+
+      state :math do
+        rule command, Name::Variable
+        mixin :general
+        rule /[0-9]+/, Num
+        rule /[-=!+*\/()\[\]]/, Operator
+        rule /[^=!+*\/()\[\]\\$%&_^{}0-9-]+/, Name::Builtin
+      end
+
+      state :inlinemath do
+        rule /\\\)/, Punctuation, :pop!
+        rule /\$/, Punctuation, :pop!
+        mixin :math
+      end
+
+      state :displaymath do
+        rule /\\\]/, Punctuation, :pop!
+        rule /\$\$/, Punctuation, :pop!
+        rule /\$/, Name::Builtin
+        mixin :math
+      end
+
+      state :command do
+        rule /\[.*?\]/, Name::Attribute
+        rule /\*/, Keyword
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rugments/lexers/toml.rb

@@ -0,0 +1,68 @@
+module Rugments
+  module Lexers
+    class TOML < RegexLexer
+      title 'TOML'
+      desc 'the TOML configuration format (https://github.com/mojombo/toml)'
+      tag 'toml'
+
+      filenames '*.toml'
+      mimetypes 'text/x-toml'
+
+      def self.analyze_text(text)
+        return 0.1 if text =~ /\A\[[\w.]+\]\s*\w+\s*=\s*("\w+")+/
+      end
+
+      identifier = /[\w.\S]+/
+
+      state :basic do
+        rule /\s+/, Text
+        rule /#.*?$/, Comment
+        rule /(true|false)/, Keyword::Constant
+        rule /(?<!=)\s*\[[\w\d\S]+\]/, Name::Namespace
+
+        rule /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
+
+        rule /(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, Num::Float
+        rule /\d+[eE][+-]?[0-9]+j?/, Num::Float
+        rule /\-?\d+/, Num::Integer
+      end
+
+      state :root do
+        mixin :basic
+
+        rule /(#{identifier})(\s*)(=)/ do
+          groups Name::Property, Text, Punctuation
+          push :value
+        end
+      end
+
+      state :value do
+        rule /\n/, Text, :pop!
+        mixin :content
+      end
+
+      state :content do
+        mixin :basic
+        rule /"/, Str, :dq
+        mixin :esc_str
+        rule /\,/, Punctuation
+        rule /\[/, Punctuation, :array
+      end
+
+      state :dq do
+        rule /"/, Str, :pop!
+        mixin :esc_str
+        rule /[^\\"]+/, Str
+      end
+
+      state :esc_str do
+        rule /\\[0t\tn\n "\\ r]/, Str::Escape
+      end
+
+      state :array do
+        mixin :content
+        rule /\]/, Punctuation, :pop!
+      end
+    end
+  end
+end

data/lib/rugments/lexers/vb.rb

@@ -0,0 +1,162 @@
+module Rugments
+  module Lexers
+    class VisualBasic < RegexLexer
+      title 'Visual Basic'
+      desc 'Visual Basic'
+      tag 'vb'
+      aliases 'visualbasic'
+      filenames '*.vbs'
+      mimetypes 'text/x-visualbasic', 'application/x-visualbasic'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          AddHandler Alias ByRef ByVal CBool CByte CChar CDate CDbl CDec
+          CInt CLng CObj CSByte CShort CSng CStr CType CUInt CULng CUShort
+          Call Case Catch Class Const Continue Declare Default Delegate
+          Dim DirectCast Do Each Else ElseIf End EndIf Enum Erase Error
+          Event Exit False Finally For Friend Function Get Global GoSub
+          GoTo Handles If Implements Imports Inherits Interface Let
+          Lib Loop Me Module MustInherit MustOverride MyBase MyClass
+          Namespace Narrowing New Next Not NotInheritable NotOverridable
+          Nothing Of On Operator Option Optional Overloads Overridable
+          Overrides ParamArray Partial Private Property Protected Public
+          RaiseEvent ReDim ReadOnly RemoveHandler Resume Return Select Set
+          Shadows Shared Single Static Step Stop Structure Sub SyncLock
+          Then Throw To True Try TryCast Using Wend When While Widening
+          With WithEvents WriteOnly
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          Boolean Byte Char Date Decimal Double Integer Long Object
+          SByte Short Single String Variant UInteger ULong UShort
+        )
+      end
+
+      def self.operator_words
+        @operator_words ||= Set.new %w(
+          AddressOf And AndAlso As GetType In Is IsNot Like Mod Or OrElse
+          TypeOf Xor
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          Console ConsoleColor
+        )
+      end
+
+      id = /[a-z_]\w*/i
+      upper_id = /[A-Z]\w*/
+
+      state :whitespace do
+        rule /\s+/, Text
+        rule /\n/, Text, :bol
+        rule /rem\b.*?$/i, Comment::Single
+        rule %r(%\{.*?%\})m, Comment::Multiline
+        rule /'.*$/, Comment::Single
+      end
+
+      state :bol do
+        rule /\s+/, Text
+        rule /<.*?>/, Name::Attribute
+        rule(//) { :pop! }
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r{
+            [#]If\b .*? \bThen
+          | [#]ElseIf\b .*? \bThen
+          | [#]End \s+ If
+          | [#]Const
+          | [#]ExternalSource .*? \n
+          | [#]End \s+ ExternalSource
+          | [#]Region .*? \n
+          | [#]End \s+ Region
+          | [#]ExternalChecksum
+                }x, Comment::Preproc
+        rule /[.]/, Punctuation, :dotted
+        rule /[(){}!#,:]/, Punctuation
+        rule /Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text)/,
+             Keyword::Declaration
+        rule /End\b/, Keyword, :end
+        rule /(Dim|Const)\b/, Keyword, :dim
+        rule /(Function|Sub|Property)\b/, Keyword, :funcname
+        rule /(Class|Structure|Enum)\b/, Keyword, :classname
+        rule /(Module|Namespace|Imports)\b/, Keyword, :namespace
+
+        rule upper_id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.keywords_type.include? match
+            token Keyword::Type
+          elsif self.class.operator_words.include? match
+            token Operator::Word
+          elsif self.class.builtins.include? match
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        rule(
+          %r{&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>.]},
+          Operator
+        )
+
+        rule /"/, Str, :string
+        rule /#{id}[%&@!#\$]?/, Name
+        rule /#.*?#/, Literal::Date
+
+        rule /(\d+\.\d*|\d*\.\d+)(f[+-]?\d+)?/i, Num::Float
+        rule /\d+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule /&H[0-9a-f]+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule /&O[0-7]+([SILDFR]|US|UI|UL)?/, Num::Integer
+
+        rule /_\n/, Keyword
+      end
+
+      state :dotted do
+        mixin :whitespace
+        rule id, Name, :pop!
+      end
+
+      state :string do
+        rule /""/, Str::Escape
+        rule /"C?/, Str, :pop!
+        rule /[^"]+/, Str
+      end
+
+      state :dim do
+        mixin :whitespace
+        rule id, Name::Variable, :pop!
+        rule(//) { pop! }
+      end
+
+      state :funcname do
+        mixin :whitespace
+        rule id, Name::Function, :pop!
+      end
+
+      state :classname do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule /#{id}([.]#{id})*/, Name::Namespace, :pop!
+      end
+
+      state :end do
+        mixin :whitespace
+        rule /(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b/,
+             Keyword, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rugments/lexers/viml/keywords.rb

@@ -0,0 +1,11 @@
+# DO NOT EDIT: automatically generated by `rake builtins:vim`.
+# see tasks/vim.rake for more info.
+module Rugments
+  module Lexers
+    class VimL
+      def self.keywords
+        @keywords ||= { command: [%w(a a), %w(ab ab), %w(abc abclear), %w(abo aboveleft), %w(al all), %w(ar ar), %w(ar args), %w(arga argadd), %w(argd argdelete), %w(argdo argdo), %w(arge argedit), %w(argg argglobal), %w(argl arglocal), %w(argu argument), %w(as ascii), %w(au au), %w(b buffer), %w(bN bNext), %w(ba ball), %w(bad badd), %w(bd bdelete), %w(bel belowright), %w(bf bfirst), %w(bl blast), %w(bm bmodified), %w(bn bnext), %w(bo botright), %w(bp bprevious), %w(br br), %w(br brewind), %w(brea break), %w(breaka breakadd), %w(breakd breakdel), %w(breakl breaklist), %w(bro browse), %w(bu bu), %w(buf buf), %w(bufdo bufdo), %w(buffers buffers), %w(bun bunload), %w(bw bwipeout), %w(c c), %w(c change), %w(cN cN), %w(cN cNext), %w(cNf cNf), %w(cNf cNfile), %w(cabc cabclear), %w(cad cad), %w(cad caddexpr), %w(caddb caddbuffer), %w(caddf caddfile), %w(cal call), %w(cat catch), %w(cb cbuffer), %w(cc cc), %w(ccl cclose), %w(cd cd), %w(ce center), %w(cex cexpr), %w(cf cfile), %w(cfir cfirst), %w(cg cgetfile), %w(cgetb cgetbuffer), %w(cgete cgetexpr), %w(changes changes), %w(chd chdir), %w(che checkpath), %w(checkt checktime), %w(cl cl), %w(cl clist), %w(cla clast), %w(clo close), %w(cmapc cmapclear), %w(cn cn), %w(cn cnext), %w(cnew cnewer), %w(cnf cnf), %w(cnf cnfile), %w(co copy), %w(col colder), %w(colo colorscheme), %w(com com), %w(comc comclear), %w(comp compiler), %w(con con), %w(con continue), %w(conf confirm), %w(cope copen), %w(cp cprevious), %w(cpf cpfile), %w(cq cquit), %w(cr crewind), %w(cs cs), %w(cscope cscope), %w(cstag cstag), %w(cuna cunabbrev), %w(cw cwindow), %w(d d), %w(d delete), %w(de de), %w(debug debug), %w(debugg debuggreedy), %w(del del), %w(delc delcommand), %w(delel delel), %w(delep delep), %w(deletel deletel), %w(deletep deletep), %w(deletl deletl), %w(deletp deletp), %w(delf delf), %w(delf delfunction), %w(dell dell), %w(delm delmarks), %w(delp delp), %w(dep dep), %w(di di), %w(di display), %w(diffg diffget), %w(diffo diffoff), %w(diffp diffpatch), %w(diffpu diffput), %w(diffs diffsplit), %w(difft diffthis), %w(diffu diffupdate), %w(dig dig), %w(dig digraphs), %w(dir dir), %w(dj djump), %w(dl dl), %w(dli dlist), %w(do do), %w(doau doau), %w(dp dp), %w(dr drop), %w(ds dsearch), %w(dsp dsplit), %w(e e), %w(e edit), %w(ea ea), %w(earlier earlier), %w(ec ec), %w(echoe echoerr), %w(echom echomsg), %w(echon echon), %w(el else), %w(elsei elseif), %w(em emenu), %w(en en), %w(en endif), %w(endf endf), %w(endf endfunction), %w(endfo endfor), %w(endfun endfun), %w(endt endtry), %w(endw endwhile), %w(ene enew), %w(ex ex), %w(exi exit), %w(exu exusage), %w(f f), %w(f file), %w(files files), %w(filet filet), %w(filetype filetype), %w(fin fin), %w(fin find), %w(fina finally), %w(fini finish), %w(fir first), %w(fix fixdel), %w(fo fold), %w(foldc foldclose), %w(foldd folddoopen), %w(folddoc folddoclosed), %w(foldo foldopen), %w(for for), %w(fu fu), %w(fu function), %w(fun fun), %w(g g), %w(go goto), %w(gr grep), %w(grepa grepadd), %w(gui gui), %w(gvim gvim), %w(h h), %w(h help), %w(ha hardcopy), %w(helpf helpfind), %w(helpg helpgrep), %w(helpt helptags), %w(hi hi), %w(hid hide), %w(his history), %w(i i), %w(ia ia), %w(iabc iabclear), %w(if if), %w(ij ijump), %w(il ilist), %w(imapc imapclear), %w(in in), %w(intro intro), %w(is isearch), %w(isp isplit), %w(iuna iunabbrev), %w(j join), %w(ju jumps), %w(k k), %w(kee keepmarks), %w(keepa keepa), %w(keepalt keepalt), %w(keepj keepjumps), %w(keepp keeppatterns), %w(l l), %w(l list), %w(lN lN), %w(lN lNext), %w(lNf lNf), %w(lNf lNfile), %w(la la), %w(la last), %w(lad lad), %w(lad laddexpr), %w(laddb laddbuffer), %w(laddf laddfile), %w(lan lan), %w(lan language), %w(lat lat), %w(later later), %w(lb lbuffer), %w(lc lcd), %w(lch lchdir), %w(lcl lclose), %w(lcs lcs), %w(lcscope lcscope), %w(le left), %w(lefta leftabove), %w(lex lexpr), %w(lf lfile), %w(lfir lfirst), %w(lg lgetfile), %w(lgetb lgetbuffer), %w(lgete lgetexpr), %w(lgr lgrep), %w(lgrepa lgrepadd), %w(lh lhelpgrep), %w(ll ll), %w(lla llast), %w(lli llist), %w(lmak lmake), %w(lmapc lmapclear), %w(lne lne), %w(lne lnext), %w(lnew lnewer), %w(lnf lnf), %w(lnf lnfile), %w(lo lo), %w(lo loadview), %w(loadk loadk), %w(loadkeymap loadkeymap), %w(loc lockmarks), %w(lockv lockvar), %w(lol lolder), %w(lop lopen), %w(lp lprevious), %w(lpf lpfile), %w(lr lrewind), %w(ls ls), %w(lt ltag), %w(lua lua), %w(luado luado), %w(luafile luafile), %w(lv lvimgrep), %w(lvimgrepa lvimgrepadd), %w(lw lwindow), %w(m move), %w(ma ma), %w(ma mark), %w(mak make), %w(marks marks), %w(mat match), %w(menut menut), %w(menut menutranslate), %w(mes mes), %w(messages messages), %w(mk mk), %w(mk mkexrc), %w(mks mksession), %w(mksp mkspell), %w(mkv mkv), %w(mkv mkvimrc), %w(mkvie mkview), %w(mo mo), %w(mod mode), %w(mz mz), %w(mz mzscheme), %w(mzf mzfile), %w(n n), %w(n next), %w(nb nbkey), %w(nbc nbclose), %w(nbs nbstart), %w(ne ne), %w(new new), %w(nmapc nmapclear), %w(noa noa), %w(noautocmd noautocmd), %w(noh nohlsearch), %w(nu number), %w(o o), %w(o open), %w(ol oldfiles), %w(omapc omapclear), %w(on only), %w(opt options), %w(ownsyntax ownsyntax), %w(p p), %w(p print), %w(pc pclose), %w(pe pe), %w(pe perl), %w(ped pedit), %w(perld perldo), %w(po pop), %w(popu popu), %w(popu popup), %w(pp ppop), %w(pr pr), %w(pre preserve), %w(prev previous), %w(pro pro), %w(prof profile), %w(profd profdel), %w(promptf promptfind), %w(promptr promptrepl), %w(ps psearch), %w(ptN ptN), %w(ptN ptNext), %w(pta ptag), %w(ptf ptfirst), %w(ptj ptjump), %w(ptl ptlast), %w(ptn ptn), %w(ptn ptnext), %w(ptp ptprevious), %w(ptr ptrewind), %w(pts ptselect), %w(pu put), %w(pw pwd), %w(py py), %w(py python), %w(py3 py3), %w(py3 py3), %w(py3do py3do), %w(pydo pydo), %w(pyf pyfile), %w(python3 python3), %w(q q), %w(q quit), %w(qa qall), %w(quita quitall), %w(r r), %w(r read), %w(re re), %w(rec recover), %w(red red), %w(red redo), %w(redi redir), %w(redr redraw), %w(redraws redrawstatus), %w(reg registers), %w(res resize), %w(ret retab), %w(retu return), %w(rew rewind), %w(ri right), %w(rightb rightbelow), %w(ru ru), %w(ru runtime), %w(rub ruby), %w(rubyd rubydo), %w(rubyf rubyfile), %w(rundo rundo), %w(rv rviminfo), %w(sN sNext), %w(sa sargument), %w(sal sall), %w(san sandbox), %w(sav saveas), %w(sb sbuffer), %w(sbN sbNext), %w(sba sball), %w(sbf sbfirst), %w(sbl sblast), %w(sbm sbmodified), %w(sbn sbnext), %w(sbp sbprevious), %w(sbr sbrewind), %w(scrip scrip), %w(scrip scriptnames), %w(scripte scriptencoding), %w(scs scs), %w(scscope scscope), %w(se set), %w(setf setfiletype), %w(setg setglobal), %w(setl setlocal), %w(sf sfind), %w(sfir sfirst), %w(sh shell), %w(si si), %w(sig sig), %w(sign sign), %w(sil silent), %w(sim simalt), %w(sl sl), %w(sl sleep), %w(sla slast), %w(sm smagic), %w(sm smap), %w(sme sme), %w(smenu smenu), %w(sn snext), %w(sni sniff), %w(sno snomagic), %w(snoreme snoreme), %w(snoremenu snoremenu), %w(so so), %w(so source), %w(sor sort), %w(sp split), %w(spe spe), %w(spe spellgood), %w(spelld spelldump), %w(spelli spellinfo), %w(spellr spellrepall), %w(spellu spellundo), %w(spellw spellwrong), %w(spr sprevious), %w(sre srewind), %w(st st), %w(st stop), %w(sta stag), %w(star star), %w(star startinsert), %w(start start), %w(startg startgreplace), %w(startr startreplace), %w(stj stjump), %w(stopi stopinsert), %w(sts stselect), %w(sun sunhide), %w(sunme sunme), %w(sunmenu sunmenu), %w(sus suspend), %w(sv sview), %w(sw swapname), %w(sy sy), %w(syn syn), %w(sync sync), %w(syncbind syncbind), %w(syntime syntime), %w(t t), %w(tN tN), %w(tN tNext), %w(ta ta), %w(ta tag), %w(tab tab), %w(tabN tabN), %w(tabN tabNext), %w(tabc tabclose), %w(tabd tabdo), %w(tabe tabedit), %w(tabf tabfind), %w(tabfir tabfirst), %w(tabl tablast), %w(tabm tabmove), %w(tabn tabnext), %w(tabnew tabnew), %w(tabo tabonly), %w(tabp tabprevious), %w(tabr tabrewind), %w(tabs tabs), %w(tags tags), %w(tc tcl), %w(tcld tcldo), %w(tclf tclfile), %w(te tearoff), %w(tf tfirst), %w(th throw), %w(tj tjump), %w(tl tlast), %w(tm tm), %w(tm tmenu), %w(tn tn), %w(tn tnext), %w(to topleft), %w(tp tprevious), %w(tr tr), %w(tr trewind), %w(try try), %w(ts tselect), %w(tu tu), %w(tu tunmenu), %w(u u), %w(u undo), %w(un un), %w(una unabbreviate), %w(undoj undojoin), %w(undol undolist), %w(unh unhide), %w(unl unl), %w(unlo unlockvar), %w(uns unsilent), %w(up update), %w(v v), %w(ve ve), %w(ve version), %w(verb verbose), %w(vert vertical), %w(vi vi), %w(vi visual), %w(vie view), %w(vim vimgrep), %w(vimgrepa vimgrepadd), %w(viu viusage), %w(vmapc vmapclear), %w(vne vnew), %w(vs vsplit), %w(w w), %w(w write), %w(wN wNext), %w(wa wall), %w(wh while), %w(win win), %w(win winsize), %w(winc wincmd), %w(windo windo), %w(winp winpos), %w(wn wnext), %w(wp wprevious), %w(wq wq), %w(wqa wqall), %w(ws wsverb), %w(wundo wundo), %w(wv wviminfo), %w(x x), %w(x xit), %w(xa xall), %w(xmapc xmapclear), %w(xme xme), %w(xmenu xmenu), %w(xnoreme xnoreme), %w(xnoremenu xnoremenu), %w(xunme xunme), %w(xunmenu xunmenu), %w(xwininfo xwininfo), %w(y yank)], option: [], auto: [%w(BufAdd BufAdd), %w(BufCreate BufCreate), %w(BufDelete BufDelete), %w(BufEnter BufEnter), %w(BufFilePost BufFilePost), %w(BufFilePre BufFilePre), %w(BufHidden BufHidden), %w(BufLeave BufLeave), %w(BufNew BufNew), %w(BufNewFile BufNewFile), %w(BufRead BufRead), %w(BufReadCmd BufReadCmd), %w(BufReadPost BufReadPost), %w(BufReadPre BufReadPre), %w(BufUnload BufUnload), %w(BufWinEnter BufWinEnter), %w(BufWinLeave BufWinLeave), %w(BufWipeout BufWipeout), %w(BufWrite BufWrite), %w(BufWriteCmd BufWriteCmd), %w(BufWritePost BufWritePost), %w(BufWritePre BufWritePre), %w(Cmd Cmd), %w(CmdwinEnter CmdwinEnter), %w(CmdwinLeave CmdwinLeave), %w(ColorScheme ColorScheme), %w(CompleteDone CompleteDone), %w(CursorHold CursorHold), %w(CursorHoldI CursorHoldI), %w(CursorMoved CursorMoved), %w(CursorMovedI CursorMovedI), %w(EncodingChanged EncodingChanged), %w(FileAppendCmd FileAppendCmd), %w(FileAppendPost FileAppendPost), %w(FileAppendPre FileAppendPre), %w(FileChangedRO FileChangedRO), %w(FileChangedShell FileChangedShell), %w(FileChangedShellPost FileChangedShellPost), %w(FileEncoding FileEncoding), %w(FileReadCmd FileReadCmd), %w(FileReadPost FileReadPost), %w(FileReadPre FileReadPre), %w(FileType FileType), %w(FileWriteCmd FileWriteCmd), %w(FileWritePost FileWritePost), %w(FileWritePre FileWritePre), %w(FilterReadPost FilterReadPost), %w(FilterReadPre FilterReadPre), %w(FilterWritePost FilterWritePost), %w(FilterWritePre FilterWritePre), %w(FocusGained FocusGained), %w(FocusLost FocusLost), %w(FuncUndefined FuncUndefined), %w(GUIEnter GUIEnter), %w(GUIFailed GUIFailed), %w(InsertChange InsertChange), %w(InsertCharPre InsertCharPre), %w(InsertEnter InsertEnter), %w(InsertLeave InsertLeave), %w(MenuPopup MenuPopup), %w(QuickFixCmdPost QuickFixCmdPost), %w(QuickFixCmdPre QuickFixCmdPre), %w(QuitPre QuitPre), %w(RemoteReply RemoteReply), %w(SessionLoadPost SessionLoadPost), %w(ShellCmdPost ShellCmdPost), %w(ShellFilterPost ShellFilterPost), %w(SourceCmd SourceCmd), %w(SourcePre SourcePre), %w(SpellFileMissing SpellFileMissing), %w(StdinReadPost StdinReadPost), %w(StdinReadPre StdinReadPre), %w(SwapExists SwapExists), %w(Syntax Syntax), %w(TabEnter TabEnter), %w(TabLeave TabLeave), %w(TermChanged TermChanged), %w(TermResponse TermResponse), %w(TextChanged TextChanged), %w(TextChangedI TextChangedI), %w(User User), %w(UserGettingBored UserGettingBored), %w(VimEnter VimEnter), %w(VimLeave VimLeave), %w(VimLeavePre VimLeavePre), %w(VimResized VimResized), %w(WinEnter WinEnter), %w(WinLeave WinLeave), %w(event event)] }
+      end
+    end
+  end
+end

data/lib/rugments/lexers/viml.rb

@@ -0,0 +1,99 @@
+module Rugments
+  module Lexers
+    class VimL < RegexLexer
+      title 'VimL'
+      desc 'VimL, the scripting language for the Vim editor (vim.org)'
+      tag 'viml'
+      aliases 'vim', 'vimscript', 'ex'
+      filenames '*.vim', '*.vba', '.vimrc', '.exrc', '.gvimrc',
+                '_vimrc', '_exrc', '_gvimrc' # _ names for windows
+
+      mimetypes 'text/x-vim'
+
+      def self.keywords
+        load Pathname.new(__FILE__).dirname.join('viml/keywords.rb')
+        keywords
+      end
+
+      state :root do
+        rule /^(\s*)(".*?)$/ do
+          groups Text, Comment
+        end
+
+        rule /^\s*\\/, Str::Escape
+
+        rule /[ \t]+/, Text
+
+        # TODO: regexes can have other delimiters
+        rule %r{/(\\\\|\\/|[^\n/])*/}, Str::Regex
+        rule %r{"(\\\\|\\"|[^\n"])*"}, Str::Double
+        rule %r{'(\\\\|\\'|[^\n'])*'}, Str::Single
+
+        # if it's not a string, it's a comment.
+        rule /(?<=\s)"[^-:.%#=*].*?$/, Comment
+
+        rule /-?\d+/, Num
+        rule /#[0-9a-f]{6}/i, Num::Hex
+        rule /^:/, Punctuation
+        rule /[():<>+=!\[\]{}\|,~.-]/, Punctuation
+        rule /\b(let|if|else|endif|elseif|fun|function|endfunction)\b/,
+             Keyword
+
+        rule /\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
+
+        rule /[absg]:\w+\b/, Name::Variable
+        rule /\b\w+\b/ do |m|
+          name = m[0]
+          keywords = self.class.keywords
+
+          if mapping_contains?(keywords[:command], name)
+            token Keyword
+          elsif mapping_contains?(keywords[:option], name)
+            token Name::Builtin
+          elsif mapping_contains?(keywords[:auto], name)
+            token Name::Builtin
+          else
+            token Text
+          end
+        end
+
+        # no errors in VimL!
+        rule /./m, Text
+      end
+
+      def mapping_contains?(mapping, word)
+        shortest, longest = find_likely_mapping(mapping, word)
+
+        shortest and word.start_with?(shortest) and
+          longest and longest.start_with?(word)
+      end
+
+      # binary search through the mappings to find the one that's likely
+      # to actually work.
+      def find_likely_mapping(mapping, word)
+        min = 0
+        max = mapping.size
+
+        until max == min
+          mid = (max + min) / 2
+
+          cmp, _ = mapping[mid]
+
+          case word <=> cmp
+          when 1
+            # too low
+            min = mid + 1
+          when -1
+            # too high
+            max = mid
+          when 0
+            # just right, abort!
+            return mapping[mid]
+          end
+        end
+
+        mapping[max - 1]
+      end
+    end
+  end
+end

data/lib/rugments/lexers/xml.rb

@@ -0,0 +1,57 @@
+module Rugments
+  module Lexers
+    class XML < RegexLexer
+      title 'XML'
+      desc '<desc for="this-lexer">XML</desc>'
+      tag 'xml'
+      filenames *%w(*.xml *.xsl *.rss *.xslt *.xsd *.wsdl)
+      mimetypes *%w(
+        text/xml
+        application/xml
+        image/svg+xml
+        application/rss+xml
+        application/atom+xml
+      )
+
+      def self.analyze_text(text)
+        return 0.9 if text.doctype?
+        return 0.8 if text =~ /\A<\?xml\b/
+        start = text[0..1000]
+        return 0.6 if start =~ %r{<xml\b}
+        return 0.3 if start =~ %r{<.+?>.*?</.+?>}m
+      end
+
+      state :root do
+        rule /[^<&]+/, Text
+        rule /&\S*?;/, Name::Entity
+        rule /<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
+        rule /<!--/, Comment, :comment
+        rule /<\?.*?\?>/, Comment::Preproc
+        rule /<![^>]*>/, Comment::Preproc
+
+        # open tags
+        rule %r{<\s*[\w:.-]+}m, Name::Tag, :tag
+
+        # self-closing tags
+        rule %r{<\s*/\s*[\w:.-]+\s*>}m, Name::Tag
+      end
+
+      state :comment do
+        rule /[^-]+/m, Comment
+        rule /-->/, Comment, :pop!
+        rule /-/, Comment
+      end
+
+      state :tag do
+        rule /\s+/m, Text
+        rule /[\w.:-]+\s*=/m, Name::Attribute, :attr
+        rule %r{/?\s*>}, Name::Tag, :pop!
+      end
+
+      state :attr do
+        rule /\s+/m, Text
+        rule /".*?"|'.*?'|[^\s>]+/, Str, :pop!
+      end
+    end
+  end
+end