rugments 1.0.0.beta1

data/lib/rugments/lexers/javascript.rb

@@ -0,0 +1,258 @@
+module Rugments
+  module Lexers
+    class Javascript < RegexLexer
+      title 'JavaScript'
+      desc 'JavaScript, the browser scripting language'
+
+      tag 'javascript'
+      aliases 'js'
+      filenames '*.js'
+      mimetypes 'application/javascript', 'application/x-javascript',
+                'text/javascript', 'text/x-javascript'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang?('node')
+        return 1 if text.shebang?('jsc')
+        # TODO: rhino, spidermonkey, etc
+      end
+
+      state :comments_and_whitespace do
+        rule /\s+/, Text
+        rule /<!--/, Comment # really...?
+        rule %r{//.*?$}, Comment::Single
+        rule %r{/\*.*?\*/}m, Comment::Multiline
+      end
+
+      state :expr_start do
+        mixin :comments_and_whitespace
+
+        rule %r{/} do
+          token Str::Regex
+          goto :regex
+        end
+
+        rule /[{]/, Punctuation, :object
+
+        rule //, Text, :pop!
+      end
+
+      state :regex do
+        rule %r{/} do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r{[^/]\n}, Error, :pop!
+
+        rule /\n/, Error, :pop!
+        rule /\[\^/, Str::Escape, :regex_group
+        rule /\[/, Str::Escape, :regex_group
+        rule /\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule /[{][\d,]+[}]/, Str::Escape
+        rule /[()?]/, Str::Escape
+        rule /./, Str::Regex
+      end
+
+      state :regex_end do
+        rule /[gim]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        # specially highlight / in a group to indicate that it doesn't
+        # close the regex
+        rule /\//, Str::Escape
+
+        rule %r{[^/]\n} do
+          token Error
+          pop! 2
+        end
+
+        rule /\]/, Str::Escape, :pop!
+        rule /\\./, Str::Escape
+        rule /./, Str::Regex
+      end
+
+      state :bad_regex do
+        rule /[^\n]+/, Error, :pop!
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          for in while do break return continue switch case default
+          if else throw try catch finally new delete typeof instanceof
+          void this
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(var let with function)
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          abstract boolean byte char class const debugger double enum
+          export extends final float goto implements import int interface
+          long native package private protected public short static
+          super synchronized throws transient volatile
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null NaN Infinity undefined)
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          Array Boolean Date Error Function Math netscape
+          Number Object Packages RegExp String sun decodeURI
+          decodeURIComponent encodeURI encodeURIComponent
+          Error eval isFinite isNaN parseFloat parseInt document this
+          window
+        )
+      end
+
+      id = /[$a-zA-Z_][a-zA-Z0-9_]*/
+
+      state :root do
+        rule /\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule /\n/, Text, :statement
+        rule %r{(?<=\n)(?=\s|/|<!--)}, Text, :expr_start
+        mixin :comments_and_whitespace
+        rule %r{\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
+               | !== }x,
+             Operator, :expr_start
+        rule %r{[-<>+*%&|\^/!=]=?}, Operator, :expr_start
+        rule /[(\[,]/, Punctuation, :expr_start
+        rule /;/, Punctuation, :statement
+        rule /[)\].]/, Punctuation
+
+        rule /[?]/ do
+          token Punctuation
+          push :ternary
+          push :expr_start
+        end
+
+        rule /[{}]/, Punctuation, :statement
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+            push :expr_start
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :expr_start
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule /0x[0-9a-fA-F]+/, Num::Hex
+        rule /[0-9]+/, Num::Integer
+        rule /"(\\\\|\\"|[^"])*"/, Str::Double
+        rule /'(\\\\|\\'|[^'])*'/, Str::Single
+      end
+
+      # braced parts that aren't object literals
+      state :statement do
+        rule /(#{id})(\s*)(:)/ do
+          groups Name::Label, Text, Punctuation
+        end
+
+        rule /[{}]/, Punctuation
+
+        mixin :expr_start
+      end
+
+      # object literals
+      state :object do
+        mixin :comments_and_whitespace
+        rule /[}]/ do
+          token Punctuation
+          goto :statement
+        end
+
+        rule /(#{id})(\s*)(:)/ do
+          groups Name::Attribute, Text, Punctuation
+          push :expr_start
+        end
+
+        rule /:/, Punctuation
+        mixin :root
+      end
+
+      # ternary expressions, where <id>: is not a label!
+      state :ternary do
+        rule /:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
+        mixin :root
+      end
+    end
+
+    class JSON < RegexLexer
+      desc 'JavaScript Object Notation (json.org)'
+      tag 'json'
+      filenames '*.json'
+      mimetypes 'application/json'
+
+      # TODO: is this too much of a performance hit?  JSON is quite simple,
+      # so I'd think this wouldn't be too bad, but for large documents this
+      # could mean doing two full lexes.
+      def self.analyze_text(text)
+        return 0.8 if text =~ /\A\s*{/m && text.lexes_cleanly?(self)
+      end
+
+      state :root do
+        mixin :whitespace
+        # special case for empty objects
+        rule /(\{)(\s*)(\})/m do
+          groups Punctuation, Text::Whitespace, Punctuation
+        end
+        rule /(?:true|false|null)\b/, Keyword::Constant
+        rule /{/,  Punctuation, :object_key
+        rule /\[/, Punctuation, :array
+        rule /-?(?:0|[1-9]\d*)\.\d+(?:e[+-]\d+)?/i, Num::Float
+        rule /-?(?:0|[1-9]\d*)(?:e[+-]\d+)?/i, Num::Integer
+        mixin :has_string
+      end
+
+      state :whitespace do
+        rule /\s+/m, Text::Whitespace
+      end
+
+      state :has_string do
+        rule /"(\\.|[^"])*"/, Str::Double
+      end
+
+      state :object_key do
+        mixin :whitespace
+        mixin :has_string
+        rule /:/, Punctuation, :object_val
+        rule /}/, Error, :pop!
+      end
+
+      state :object_val do
+        rule /,/, Punctuation, :pop!
+        rule(/}/) { token Punctuation; pop!(2) }
+        mixin :root
+      end
+
+      state :array do
+        rule /\]/, Punctuation, :pop!
+        rule /,/, Punctuation
+        mixin :root
+      end
+    end
+  end
+end

data/lib/rugments/lexers/literate_coffeescript.rb

@@ -0,0 +1,31 @@
+module Rugments
+  module Lexers
+    class LiterateCoffeescript < RegexLexer
+      tag 'literate_coffeescript'
+      title 'Literate CoffeeScript'
+      desc 'Literate coffeescript'
+      aliases 'litcoffee'
+      filenames '*.litcoffee'
+
+      def markdown
+        @markdown ||= Markdown.new(options)
+      end
+
+      def coffee
+        @coffee ||= Coffeescript.new(options)
+      end
+
+      start { markdown.reset!; coffee.reset! }
+
+      state :root do
+        rule /^(    .*?\n)+/m do
+          delegate coffee
+        end
+
+        rule /^([ ]{0,3}(\S.*?|)\n)*/m do
+          delegate markdown
+        end
+      end
+    end
+  end
+end

data/lib/rugments/lexers/literate_haskell.rb

@@ -0,0 +1,34 @@
+module Rugments
+  module Lexers
+    class LiterateHaskell < RegexLexer
+      title 'Literate Haskell'
+      desc 'Literate haskell'
+      tag 'literate_haskell'
+      aliases 'lithaskell', 'lhaskell', 'lhs'
+      filenames '*.lhs'
+      mimetypes 'text/x-literate-haskell'
+
+      def haskell
+        @haskell ||= Haskell.new(options)
+      end
+
+      start { haskell.reset! }
+
+      # TODO: support TeX versions as well.
+      state :root do
+        rule /\s*?\n(?=>)/, Text, :code
+        rule /.*?\n/, Text
+        rule /.+\z/, Text
+      end
+
+      state :code do
+        rule /(>)( .*?(\n|\z))/ do |m|
+          token Name::Label, m[1]
+          delegate haskell, m[2]
+        end
+
+        rule /\s*\n(?=\s*[^>])/, Text, :pop!
+      end
+    end
+  end
+end

data/lib/rugments/lexers/llvm.rb

@@ -0,0 +1,82 @@
+module Rugments
+  module Lexers
+    class LLVM < RegexLexer
+      title 'LLVM'
+      desc 'The LLVM Compiler Infrastructure (http://llvm.org/)'
+      tag 'llvm'
+
+      filenames '*.ll'
+      mimetypes 'text/x-llvm'
+
+      def self.analyze_text(text)
+        return 0.1 if text =~ /\A%\w+\s=\s/
+      end
+
+      string = /"[^"]*?"/
+      identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
+
+      state :basic do
+        rule /;.*?$/, Comment::Single
+        rule /\s+/, Text
+
+        rule /#{identifier}\s*:/, Name::Label
+
+        rule /@(#{identifier}|\d+)/, Name::Variable::Global
+        rule /(%|!)#{identifier}/, Name::Variable
+        rule /(%|!)\d+/, Name::Variable
+
+        rule /c?#{string}/, Str
+
+        rule /0[xX][a-fA-F0-9]+/, Num
+        rule /-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
+
+        rule /[=<>{}\[\]()*.,!]|x/, Punctuation
+      end
+
+      builtin_types = %w(
+        void float double half x86_fp80 x86mmx fp128 ppc_fp128 label metadata
+      )
+
+      state :types do
+        rule /i[1-9]\d*/, Keyword::Type
+        rule /#{builtin_types.join('|')}/, Keyword::Type
+      end
+
+      builtin_keywords = %w(
+        begin end true false declare define global constant personality private
+        landingpad linker_private internal available_externally linkonce_odr
+        linkonce weak weak_odr appending dllimport dllexport common default
+        hidden protected extern_weak external thread_local zeroinitializer
+        undef null to tail target triple datalayout volatile nuw nsw nnan ninf
+        nsz arcp fast exact inbounds align addrspace section alias module asm
+        sideeffect gc dbg ccc fastcc coldcc x86_stdcallcc x86_fastcallcc
+        arm_apcscc arm_aapcscc arm_aapcs_vfpcc ptx_device ptx_kernel cc
+        c signext zeroext inreg sret nounwind noreturn noalias nocapture byval
+        nest readnone readonly inlinehint noinline alwaysinline optsize ssp
+        sspreq noredzone noimplicitfloat naked type opaque eq ne slt sgt sle
+        sge ult ugt ule uge oeq one olt ogt ole oge ord uno unnamed_addr ueq
+        une uwtable x
+      )
+
+      builtin_instructions = %w(
+        add fadd sub fsub mul fmul udiv sdiv fdiv urem srem frem shl lshr ashr
+        and or xor icmp fcmp phi call catch trunc zext sext fptrunc fpext
+        uitofp sitofp fptoui fptosi inttoptr ptrtoint bitcast select va_arg ret
+        br switch invoke unwind unreachable malloc alloca free load store
+        getelementptr extractelement insertelement shufflevector getresult
+        extractvalue insertvalue cleanup resume
+      )
+
+      state :keywords do
+        rule /#{builtin_instructions.join('|')}/, Keyword
+        rule /#{builtin_keywords.join('|')}/, Keyword
+      end
+
+      state :root do
+        mixin :basic
+        mixin :keywords
+        mixin :types
+      end
+    end
+  end
+end

data/lib/rugments/lexers/lua/builtins.rb

@@ -0,0 +1,21 @@
+# automatically generated by `rake builtins:lua`
+module Rugments
+  module Lexers
+    class Lua
+      def self.builtins
+        @builtins ||= {}.tap do |b|
+          b['basic'] = Set.new %w(_G _VERSION assert collectgarbage dofile error getmetatable ipairs load loadfile next pairs pcall print rawequal rawget rawlen rawset select setmetatable tonumber tostring type xpcall file:close file:flush file:lines file:read file:seek file:setvbuf file:write)
+          b['modules'] = Set.new %w(require package.config package.cpath package.loaded package.loadlib package.path package.preload package.searchers package.searchpath)
+          b['bit32'] = Set.new %w(bit32.arshift bit32.band bit32.bnot bit32.bor bit32.btest bit32.bxor bit32.extract bit32.lrotate bit32.lshift bit32.replace bit32.rrotate bit32.rshift)
+          b['coroutine'] = Set.new %w(coroutine.create coroutine.resume coroutine.running coroutine.status coroutine.wrap coroutine.yield)
+          b['debug'] = Set.new %w(debug.debug debug.getuservalue debug.gethook debug.getinfo debug.getlocal debug.getmetatable debug.getregistry debug.getupvalue debug.setuservalue debug.sethook debug.setlocal debug.setmetatable debug.setupvalue debug.traceback debug.upvalueid debug.upvaluejoin)
+          b['io'] = Set.new %w(io.close io.flush io.input io.lines io.open io.output io.popen io.read io.stderr io.stdin io.stdout io.tmpfile io.type io.write)
+          b['math'] = Set.new %w(math.abs math.acos math.asin math.atan math.atan2 math.ceil math.cos math.cosh math.deg math.exp math.floor math.fmod math.frexp math.huge math.ldexp math.log math.max math.min math.modf math.pi math.pow math.rad math.random math.randomseed math.sin math.sinh math.sqrt math.tan math.tanh)
+          b['os'] = Set.new %w(os.clock os.date os.difftime os.execute os.exit os.getenv os.remove os.rename os.setlocale os.time os.tmpname)
+          b['string'] = Set.new %w(string.byte string.char string.dump string.find string.format string.gmatch string.gsub string.len string.lower string.match string.rep string.reverse string.sub string.upper)
+          b['table'] = Set.new %w(table.concat table.insert table.pack table.remove table.sort table.unpack)
+        end
+      end
+    end
+  end
+end

data/lib/rugments/lexers/lua.rb

@@ -0,0 +1,120 @@
+module Rugments
+  module Lexers
+    class Lua < RegexLexer
+      title 'Lua'
+      desc 'Lua (http://www.lua.org)'
+      tag 'lua'
+      filenames '*.lua', '*.wlua'
+
+      mimetypes 'text/x-lua', 'application/x-lua'
+
+      def initialize(opts = {})
+        @function_highlighting = opts.delete(:function_highlighting) { true }
+        @disabled_modules = opts.delete(:disabled_modules) { [] }
+        super(opts)
+      end
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'lua'
+      end
+
+      def self.builtins
+        load Pathname.new(__FILE__).dirname.join('lua/builtins.rb')
+        builtins
+      end
+
+      def builtins
+        return [] unless @function_highlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          self.class.builtins.each do |mod, fns|
+            next if @disabled_modules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      state :root do
+        # lua allows a file to start with a shebang
+        rule %r{#!(.*?)$}, Comment::Preproc
+        rule //, Text, :base
+      end
+
+      state :base do
+        rule %r{--\[(=*)\[.*?\]\1\]}m, Comment::Multiline
+        rule %r{--.*$}, Comment::Single
+
+        rule %r{(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'}, Num::Float
+        rule %r{(?i)\d+e[+-]?\d+}, Num::Float
+        rule %r{(?i)0x[0-9a-f]*}, Num::Hex
+        rule %r{\d+}, Num::Integer
+
+        rule %r{\n}, Text
+        rule %r{[^\S\n]}, Text
+        # multiline strings
+        rule %r{\[(=*)\[.*?\]\1\]}m, Str
+
+        rule %r{(==|~=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>#])}, Operator
+        rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
+        rule %r{(and|or|not)\b}, Operator::Word
+
+        rule %r{(break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b}, Keyword
+        rule %r{(local)\b}, Keyword::Declaration
+        rule %r{(true|false|nil)\b}, Keyword::Constant
+
+        rule %r{(function)\b}, Keyword, :function_name
+
+        rule %r{[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?} do |m|
+          name = m[0]
+          if self.builtins.include?(name)
+            token Name::Builtin
+          elsif name =~ /\./
+            a, b = name.split('.', 2)
+            token Name, a
+            token Punctuation, '.'
+            token Name, b
+          else
+            token Name
+          end
+        end
+
+        rule %r{'}, Str::Single, :escape_sqs
+        rule %r{"}, Str::Double, :escape_dqs
+      end
+
+      state :function_name do
+        rule /\s+/, Text
+        rule %r{(?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)} do
+          groups Name::Class, Punctuation, Name::Function
+          pop!
+        end
+        # inline function
+        rule %r{\(}, Punctuation, :pop!
+      end
+
+      state :escape_sqs do
+        mixin :string_escape
+        mixin :sqs
+      end
+
+      state :escape_dqs do
+        mixin :string_escape
+        mixin :dqs
+      end
+
+      state :string_escape do
+        rule %r(\\([abfnrtv\\"']|\d{1,3})), Str::Escape
+      end
+
+      state :sqs do
+        rule %r{'}, Str::Single, :pop!
+        rule %r{[^']+}, Str::Single
+      end
+
+      state :dqs do
+        rule %r{"}, Str::Double, :pop!
+        rule %r{[^"]+}, Str::Double
+      end
+    end
+  end
+end

data/lib/rugments/lexers/make.rb

@@ -0,0 +1,114 @@
+module Rugments
+  module Lexers
+    class Make < RegexLexer
+      title 'Make'
+      desc 'Makefile syntax'
+      tag 'make'
+      aliases 'makefile', 'mf', 'gnumake', 'bsdmake'
+      filenames '*.make', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'
+      mimetypes 'text/x-makefile'
+
+      def self.analyze_text(text)
+        return 0.6 if text =~ /^\.PHONY:/
+      end
+
+      bsd_special = %w(
+        include undef error warning if else elif endif for endfor
+      )
+
+      gnu_special = %w(
+        ifeq ifneq ifdef ifndef else endif include -include define endef :
+      )
+
+      line = /(?:\\.|\\\n|[^\\\n])*/m
+
+      def initialize(opts = {})
+        super
+        @shell = Shell.new(opts)
+      end
+
+      start { @shell.reset! }
+
+      state :root do
+        rule /\s+/, Text
+
+        rule /#.*?\n/, Comment
+
+        rule /(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
+          groups Keyword, Text
+          push :export
+        end
+
+        rule /export\s+/, Keyword
+
+        # assignment
+        rule /([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)/m do |m|
+          token Name::Variable, m[1]
+          token Text, m[2]
+          token Operator, m[3]
+          push :shell_line
+        end
+
+        rule /"(\\\\|\\.|[^"\\])*"/, Str::Double
+        rule /'(\\\\|\\.|[^'\\])*'/, Str::Single
+        rule /([^\n:]+)(:+)([ \t]*)/ do
+          groups Name::Label, Operator, Text
+          push :block_header
+        end
+      end
+
+      state :export do
+        rule /[\w\${}-]/, Name::Variable
+        rule /\n/, Text, :pop!
+        rule /\s+/, Text
+      end
+
+      state :block_header do
+        rule /[^,\\\n#]+/, Name::Function
+        rule /,/, Punctuation
+        rule /#.*?/, Comment
+        rule /\\\n/, Text
+        rule /\\./, Text
+        rule /\n/ do
+          token Text
+          goto :block_body
+        end
+      end
+
+      state :block_body do
+        rule /(\t[\t ]*)([@-]?)/ do |_m|
+          groups Text, Punctuation
+          push :shell_line
+        end
+
+        rule(//) { @shell.reset!; pop! }
+      end
+
+      state :shell do
+        # macro interpolation
+        rule /\$\(\s*[a-z_]\w*\s*\)/i, Name::Variable
+        # $(shell ...)
+        rule /(\$\()(\s*)(shell)(\s+)/m do
+          groups Name::Function, Text, Name::Builtin, Text
+          push :shell_expr
+        end
+
+        rule(/\\./m) { delegate @shell }
+        stop = /\$\(|\(|\)|\n|\\/
+        rule(/.+?(?=#{stop})/m) { delegate @shell }
+        rule(stop) { delegate @shell }
+      end
+
+      state :shell_expr do
+        rule(/\(/) { delegate @shell; push }
+        rule /\)/, Name::Variable, :pop!
+        mixin :shell
+      end
+
+      state :shell_line do
+        rule /\n/, Text, :pop!
+        mixin :shell
+      end
+    end
+  end
+end