rouge 0.0.13 → 0.0.14

data/lib/rouge/lexers/haskell.rb

@@ -38,6 +38,13 @@ module Rouge
         rule /[-{}]/, 'Comment.Multiline'
       end
 
+      state :comment_preproc do
+        rule /-}/, 'Comment.Preproc', :pop!
+        rule /{-/, 'Comment.Preproc', :comment
+        rule /[^-{}]+/, 'Comment.Preproc'
+        rule /[-{}]/, 'Comment.Preproc'
+      end
+
       state :root do
         mixin :basic
 

data/lib/rouge/lexers/html.rb

@@ -48,11 +48,29 @@ module Rouge
 
       state :attr do
         # TODO: are backslash escapes valid here?
-        rule /".*?"/,   'Literal.String', :pop!
-        rule /'.*?'/,   'Literal.String', :pop!
+        rule /"/ do
+          token 'Literal.String'
+          pop!; push :dq
+        end
+
+        rule /'/ do
+          token 'Literal.String'
+          pop!; push :sq
+        end
+
         rule /[^\s>]+/, 'Literal.String', :pop!
       end
 
+      state :dq do
+        rule /"/, 'Literal.String', :pop!
+        rule /[^"]+/, 'Literal.String'
+      end
+
+      state :sq do
+        rule /'/, 'Literal.String', :pop!
+        rule /[^']+/, 'Literal.String'
+      end
+
       state :script_content do
         rule %r(<\s*/\s*script\s*>)m, 'Name.Tag', :pop!
         rule %r(.*?(?=<\s*/\s*script\s*>))m do

data/lib/rouge/lexers/make.rb

@@ -0,0 +1,105 @@
+module Rouge
+  module Lexers
+    class Make < RegexLexer
+      tag 'make'
+      aliases 'makefile', 'mf', 'gnumake', 'bsdmake'
+      filenames '*.make', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'
+      mimetypes 'text/x-makefile'
+
+      def self.analyze_text(text)
+        return 0.2 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
+
+      attr_reader :shell
+      def initialize(opts={})
+        super
+        @shell = Shell.new(opts)
+      end
+
+      state :root do
+        rule /^(?:[\t ]+.*\n|\n)+/ do
+          delegate lexer.shell
+        end
+
+        # rule /\$\((?:.*\\\n|.*\n)+/ do
+        #   delegate Shell
+        # end
+
+        rule /\s+/, 'Text'
+
+        rule /#.*?\n/, 'Comment'
+
+        rule /(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
+          group 'Keyword'; group '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 /"(\\\\|\\.|[^"\\])*"/, 'Literal.String.Double'
+        rule /'(\\\\|\\.|[^'\\])*'/, 'Literal.String.Single'
+        rule /([^\n:]+)(:+)([ \t]*)/ do
+          group 'Name.Label'; group 'Operator'; group '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'
+          pop!; push :block_body
+        end
+      end
+
+      state :block_body do
+        rule /(\t[\t ]*)([@-]?)/ do |m|
+          group 'Text'; group 'Punctuation'
+          push :shell_line
+        end
+
+        rule(//) { lexer.shell.reset!; pop! }
+      end
+
+      state :shell do
+        # macro interpolation
+        rule /\$\(\s*[a-z_]\w*\s*\)/i, 'Name.Variable'
+        rule(/.+?(?=\$\(|\)|\n)/m) { delegate lexer.shell }
+        rule(/\$\(|\)|\n/) { delegate lexer.shell }
+      end
+
+      state :shell_line do
+        rule /\n/, 'Text', :pop!
+        mixin :shell
+      end
+    end
+  end
+end

data/lib/rouge/lexers/perl.rb

@@ -0,0 +1,196 @@
+module Rouge
+  module Lexers
+    class Perl < RegexLexer
+      tag 'perl'
+      aliases 'pl'
+
+      filenames '*.pl', '*.pm'
+      mimetypes 'text/x-perl', 'application/x-perl'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'perl'
+        return 0.9 if text.include? 'my $'
+      end
+
+      keywords = %w(
+        case continue do else elsif for foreach if last my next our
+        redo reset then unless until while use print new BEGIN CHECK
+        INIT END return
+      )
+
+      builtins = %w(
+        abs accept alarm atan2 bind binmode bless caller chdir chmod
+        chomp chop chown chr chroot close closedir connect continue cos
+        crypt dbmclose dbmopen defined delete die dump each endgrent
+        endhostent endnetent endprotoent endpwent endservent eof eval
+        exec exists exit exp fcntl fileno flock fork format formline getc
+        getgrent getgrgid getgrnam gethostbyaddr gethostbyname gethostent
+        getlogin getnetbyaddr getnetbyname getnetent getpeername
+        getpgrp getppid getpriority getprotobyname getprotobynumber
+        getprotoent getpwent getpwnam getpwuid getservbyname getservbyport
+        getservent getsockname getsockopt glob gmtime goto grep hex
+        import index int ioctl join keys kill last lc lcfirst length
+        link listen local localtime log lstat map mkdir msgctl msgget
+        msgrcv msgsnd my next no oct open opendir ord our pack package
+        pipe pop pos printf prototype push quotemeta rand read readdir
+        readline readlink readpipe recv redo ref rename require reverse
+        rewinddir rindex rmdir scalar seek seekdir select semctl semget
+        semop send setgrent sethostent setnetent setpgrp setpriority
+        setprotoent setpwent setservent setsockopt shift shmctl shmget
+        shmread shmwrite shutdown sin sleep socket socketpair sort splice
+        split sprintf sqrt srand stat study substr symlink syscall sysopen
+        sysread sysseek system syswrite tell telldir tie tied time times
+        tr truncate uc ucfirst umask undef unlink unpack unshift untie
+        utime values vec wait waitpid wantarray warn write
+      )
+
+      re_tok = 'Literal.String.Regex'
+
+      state :balanced_regex do
+        rule %r(/(\\\\|\\/|[^/])*/[egimosx]*)m, re_tok, :pop!
+        rule %r(!(\\\\|\\!|[^!])*![egimosx]*)m, re_tok, :pop!
+        rule %r(\\(\\\\|[^\\])*\\[egimosx]*)m, re_tok, :pop!
+        rule %r({(\\\\|\\}|[^}])*}[egimosx]*), re_tok, :pop!
+        rule %r(<(\\\\|\\>|[^>])*>[egimosx]*), re_tok, :pop!
+        rule %r(\[(\\\\|\\\]|[^\]])*\][egimosx]*), re_tok, :pop!
+        rule %r(\((\\\\|\\\)|[^\)])*\)[egimosx]*), re_tok, :pop!
+        rule %r(@(\\\\|\\\@|[^\@])*@[egimosx]*), re_tok, :pop!
+        rule %r(%(\\\\|\\\%|[^\%])*%[egimosx]*), re_tok, :pop!
+        rule %r(\$(\\\\|\\\$|[^\$])*\$[egimosx]*), re_tok, :pop!
+      end
+
+      state :root do
+        rule /#.*?$/, 'Comment.Single'
+        rule /^=[a-zA-Z0-9]+\s+.*?\n=cut/, 'Comment.Multiline'
+        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
+
+        rule /(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
+          group 'Keyword'; group 'Text'
+          group 'Name'; group 'Text'
+          group 'Punctuation'; group 'Text'
+
+          push :format
+        end
+
+        rule /(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, 'Operator.Word'
+
+        # common delimiters
+        rule %r(s/(\\\\|\\/|[^/])*/(\\\\|\\/|[^/])*/[egimosx]*), re_tok
+        rule %r(s!(\\\\|\\!|[^!])*!(\\\\|\\!|[^!])*![egimosx]*), re_tok
+        rule %r(s\\(\\\\|[^\\])*\\(\\\\|[^\\])*\\[egimosx]*), re_tok
+        rule %r(s@(\\\\|\\@|[^@])*@(\\\\|\\@|[^@])*@[egimosx]*), re_tok
+        rule %r(s%(\\\\|\\%|[^%])*%(\\\\|\\%|[^%])*%[egimosx]*), re_tok
+
+        # balanced delimiters
+        rule %r(s{(\\\\|\\}|[^}])*}\s*), re_tok, :balanced_regex
+        rule %r(s<(\\\\|\\>|[^>])*>\s*), re_tok, :balanced_regex
+        rule %r(s\[(\\\\|\\\]|[^\]])*\]\s*), re_tok, :balanced_regex
+        rule %r(s\((\\\\|\\\)|[^\)])*\)\s*), re_tok, :balanced_regex
+
+        rule %r(m?/(\\\\|\\/|[^/\n])*/[gcimosx]*), re_tok
+        rule %r(m(?=[/!\\{<\[\(@%\$])), re_tok, :balanced_regex
+        rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[gcimosx]*),
+          re_tok, :balanced_regex
+
+        rule /\s+/, 'Text'
+        rule /(?:#{builtins.join('|')})\b/, 'Name.Builtin'
+        rule /((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b/,
+          'Name.Builtin.Pseudo'
+
+        rule /<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m,
+          'Literal.String'
+
+        rule /__END__\b/, 'Comment.Preproc', :end_part
+        rule /\$\^[ADEFHILMOPSTWX]/, 'Name.Variable.Global'
+        rule /\$[\\"\[\]'&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, 'Name.Variable.Global'
+        rule /[$@%#]+/, 'Name.Variable', :varname
+
+        rule /0_?[0-7]+(_[0-7]+)*/, 'Literal.Number.Oct'
+        rule /0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, 'Literal.Number.Hex'
+        rule /0b[01]+(_[01]+)*/, 'Literal.Number.Bin'
+        rule /(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
+          'Literal.Number.Float'
+        rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, 'Literal.Number.Float'
+        rule /\d+(_\d+)*/, 'Literal.Number.Integer'
+
+        rule /'(\\\\|\\'|[^'])*'/, 'Literal.String'
+        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String'
+        rule /`(\\\\|\\`|[^`])*`/, 'Literal.String.Backtick'
+        rule /<([^\s>]+)>/, re_tok
+        rule /(q|qq|qw|qr|qx)\{/, 'Literal.String.Other', :cb_string
+        rule /(q|qq|qw|qr|qx)\(/, 'Literal.String.Other', :rb_string
+        rule /(q|qq|qw|qr|qx)\[/, 'Literal.String.Other', :sb_string
+        rule /(q|qq|qw|qr|qx)</, 'Literal.String.Other', :lt_string
+        rule /(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, 'Literal.String.Other'
+
+        rule /package\s+/, 'Keyword', :modulename
+        rule /sub\s+/, 'Keyword', :funcname
+        rule /\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
+          'Operator'
+        rule /[-+\/*%=<>&^\|!\\~]=?/, 'Operator'
+        rule /[()\[\]:;,<>\/?{}]/, 'Punctuation'
+        rule(/(?=\w)/) { push :name }
+      end
+
+      state :format do
+        rule /\.\n/, 'Literal.String.Interpol', :pop!
+        rule /.*?\n/, 'Literal.String.Interpol'
+      end
+
+      state :name_common do
+        rule /\w+::/, 'Name.Namespace'
+        rule /[\w:]+/, 'Name.Variable', :pop!
+      end
+
+      state :varname do
+        rule /\s+/, 'Text'
+        rule /\{/, 'Punctuation', :pop! # hash syntax
+        rule /\)|,/, 'Punctuation', :pop! # arg specifier
+        mixin :name_common
+      end
+
+      state :name do
+        mixin :name_common
+        rule /[A-Z_]+(?=[^a-zA-Z0-9_])/, 'Name.Constant', :pop!
+        rule(/(?=\W)/) { pop! }
+      end
+
+      state :modulename do
+        rule /[a-z_]\w*/i, 'Name.Namespace', :pop!
+      end
+
+      state :funcname do
+        rule /[a-zA-Z_]\w*[!?]?/, 'Name.Function'
+        rule /\s+/, 'Text'
+
+        # argument declaration
+        rule /(\([$@%]*\))(\s*)/ do
+          group 'Punctuation'
+          group 'Text'
+        end
+
+        rule /.*?{/, 'Punctuation', :pop!
+        rule /;/, 'Punctuation', :pop!
+      end
+
+      [[:cb, '\{', '\}'],
+       [:rb, '\(', '\)'],
+       [:sb, '\[', '\]'],
+       [:lt, '<',  '>']].each do |name, open, close|
+        tok = 'Literal.String.Other'
+        state :"#{name}_string" do
+          rule /\\[#{open}#{close}\\]/, tok
+          rule /\\/, tok
+          rule(/#{open}/) { token tok; push }
+          rule /#{close}/, tok, :pop!
+          rule /[^#{open}#{close}\\]+/, tok
+        end
+      end
+
+      state :end_part do
+        # eat the rest of the stream
+        rule /.+/m, 'Comment.Preproc', :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/php.rb

@@ -0,0 +1,145 @@
+module Rouge
+  module Lexers
+    class PHP < RegexLexer
+      tag 'php'
+      aliases 'php', 'php3', 'php4', 'php5'
+      filenames '*.php', '*.php[345]'
+      mimetypes 'text/x-php'
+
+      def initialize(opts={})
+        # if truthy, the lexer starts highlighting with php code
+        # (no <?php required)
+        @start_inline = opts.delete(:start_inline)
+        @funcnamehighlighting = opts.delete(:funcnamehighlighting) { true }
+        @disabledmodules = opts.delete(:disabledmodules) { [] }
+      end
+
+      def builtins
+        return [] unless @funcnamehighlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          require Pathname.new(__FILE__).dirname.join('php/builtins.rb')
+
+          self.class.builtins.each do |mod, fns|
+            next if @disabledmodules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      def start_inline?
+        !!@start_inline
+      end
+
+      start do
+        push :php if lexer.start_inline?
+      end
+
+      keywords = %w(
+        and E_PARSE old_function E_ERROR or as E_WARNING parent eval
+        PHP_OS break exit case extends PHP_VERSION cfunction FALSE
+        print for require continue foreach require_once declare return
+        default static do switch die stdClass echo else TRUE elseif
+        var empty if xor enddeclare include virtual endfor include_once
+        while endforeach global __FILE__ endif list __LINE__ endswitch
+        new __sleep endwhile not array __wakeup E_ALL NULL final
+        php_user_filter interface implements public private protected
+        abstract clone try catch throw this use namespace
+      )
+
+      state :root do
+        rule /<\?(php)?/, 'Comment.Preproc', :php
+        rule /.*?(?=<\?)/, 'Other'
+        rule /</, 'Other'
+      end
+
+      state :php do
+        rule /\?>/, 'Comment.Preproc', :pop!
+        # heredocs
+        rule /<<<('?)([a-z_]\w*)\1\n.*?\n\2;?\n/im, 'String'
+        rule /\s+/, 'Text'
+        rule /#.*?\n/, 'Comment.Single'
+        rule %r(//.*?\n), 'Comment.Single'
+        # empty comment, otherwise seen as the start of a docstring
+        rule %r(/\*\*/)
+        rule %r(/\*\*.*?\*/)m, 'Literal.String.Doc'
+        rule %r(/\*.*?\*/)m, 'Comment.Multiline'
+        rule /(->|::)(\s*)([a-zA-Z_][a-zA-Z0-9_]*)/ do
+          group 'Operator'; group 'Text'; group 'Name.Attribute'
+        end
+
+        rule /[~!%^&*+=\|:.<>\/?@-]+/, 'Operator'
+        rule /[\[\]{}();,]+/, 'Punctuation'
+        rule /class\b/, 'Keyword', :classname
+        # anonymous functions
+        rule /(function)(\s*)(?=\()/ do
+          group 'Keyword'; group 'Text'
+        end
+
+        # named functions
+        rule /(function)(\s+)(&?)(\s*)/ do
+          group 'Keyword'; group 'Text'; group 'Operator'; group 'Text'
+          push :funcname
+        end
+
+        rule /(const)(\s+)([a-zA-Z_]\w*)/i do
+          group 'Keyword'; group 'Text'; group 'Name.Constant'
+        end
+
+        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
+        rule /(true|false|null)\b/, 'Keyword.Constant'
+        rule /\$\{\$+[a-z_]\w*\}/i, 'Name.Variable'
+        rule /\$+[a-z_]\w*/i, 'Name.Variable'
+
+        # may be intercepted for builtin highlighting
+        rule /[\\a-z_][\\\w]*/i, 'Name.Other'
+
+        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, 'Literal.Number.Float'
+        rule /\d+e[+-]?\d+/i, 'Literal.Number.Float'
+        rule /0[0-7]+/, 'Literal.Number.Oct'
+        rule /0x[a-f0-9]+/i, 'Literal.Number.Hex'
+        rule /\d+/, 'Literal.Number.Integer'
+        rule /'([^'\\]*(?:\\.[^'\\]*)*)'/, 'Literal.String.Single'
+        rule /`([^`\\]*(?:\\.[^`\\]*)*)`/, 'Literal.String.Backtick'
+        rule /"/, 'Literal.String.Double', :string
+      end
+
+      state :classname do
+        rule /\s+/, 'Text'
+        rule /[a-z_][\\\w]*/i, 'Name.Class', :pop!
+      end
+
+      state :funcname do
+        rule /[a-z_]\w*/i, 'Name.Function', :pop!
+      end
+
+      state :string do
+        rule /"/, 'Literal.String.Double', :pop!
+        rule /[^\\{$"]+/, 'Literal.String.Double'
+        rule /\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})/,
+          'Literal.String.Escape'
+        rule /\$[a-zA-Z_][a-zA-Z0-9_]*(\[\S+\]|->[a-zA-Z_][a-zA-Z0-9_]*)?/
+
+        lsi = 'Literal.String.Interpol'
+        rule /\{\$\{/, lsi, :interp_double
+        rule /\{(?=\$)/, lsi, :interp_single
+        rule /(\{)(\S+)(\})/ do
+          group lsi; group 'Name.Variable'; group lsi
+        end
+
+        rule /[${\\]+/, 'Literal.String.Double'
+      end
+
+      def stream_tokens(source, &b)
+        super(source) do |tok, val|
+          if tok.name == 'Name.Other' and builtins.include? val
+            yield [Token['Name.Builtin'], val]
+          else
+            yield [tok, val]
+          end
+        end
+      end
+    end
+  end
+end
+