rougegal 2.1.2

data/lib/rouge/lexers/pascal.rb

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Pascal < RegexLexer
+      tag 'pascal'
+      title "Pascal"
+      desc 'a procedural programming language commonly used as a teaching language.'
+      filenames '*.pas'
+
+      mimetypes 'text/x-pascal'
+
+      id = /@?[_a-z]\w*/i
+
+      keywords = %w(
+        absolute abstract all and and_then array as asm assembler attribute
+        begin bindable case class const constructor delay destructor div do
+        downto else end except exit export exports external far file finalization
+        finally for forward function goto if implementation import in inc index
+        inherited initialization inline interface interrupt is label library
+        message mod module near nil not object of on only operator or or_else
+        otherwise out overload override packed pascal pow private procedure program
+        property protected public published qualified raise read record register
+        repeat resident resourcestring restricted safecall segment set shl shr
+        stdcall stored string then threadvar to try type unit until uses value var
+        view virtual while with write writeln xor
+      )
+
+      keywords_type = %w(
+        ansichar ansistring bool boolean byte bytebool cardinal char comp currency
+        double dword extended int64 integer iunknown longbool longint longword pansichar
+        pansistring pbool pboolean pbyte pbytearray pcardinal pchar pcomp pcurrency
+        pdate pdatetime pdouble pdword pextended phandle pint64 pinteger plongint plongword
+        pointer ppointer pshortint pshortstring psingle psmallint pstring pvariant pwidechar
+        pwidestring pword pwordarray pwordbool real real48 shortint shortstring single
+        smallint string tclass tdate tdatetime textfile thandle tobject ttime variant
+        widechar widestring word wordbool
+      )
+
+      state :whitespace do
+        # Spaces
+        rule /\s+/m, Text
+        # // Comments
+        rule %r((//).*$\n?), Comment::Single
+        # -- Comments
+        rule %r((--).*$\n?), Comment::Single
+        # (* Comments *)
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        # { Comments }
+        rule %r(\{.*?\})m, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r{((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?}, Num
+        rule %r{[~!@#\$%\^&\*\(\)\+`\-={}\[\]:;<>\?,\.\/\|\\]}, Punctuation
+        rule %r{'([^']|'')*'}, Str
+        rule /(true|false|nil)\b/i, Name::Builtin
+        rule /\b(#{keywords.join('|')})\b/i, Keyword
+        rule /\b(#{keywords_type.join('|')})\b/i, Keyword::Type
+        rule id, Name
+      end
+    end
+  end
+end

data/lib/rouge/lexers/perl.rb

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Perl < RegexLexer
+      title "Perl"
+      desc "The Perl scripting language (perl.org)"
+
+      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.4 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 = Str::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/m, Comment::Multiline
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+
+        rule /(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
+          groups Keyword, Text, Name, Text, Punctuation, 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, Str
+
+        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]+)*/, Num::Oct
+        rule /0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
+        rule /0b[01]+(_[01]+)*/, Num::Bin
+        rule /(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
+          Num::Float
+        rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
+        rule /\d+(_\d+)*/, Num::Integer
+
+        rule /'(\\\\|\\'|[^'])*'/, Str
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /`(\\\\|\\`|[^`])*`/, Str::Backtick
+        rule /<([^\s>]+)>/, re_tok
+        rule /(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
+        rule /(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
+        rule /(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
+        rule /(q|qq|qw|qr|qx)</, Str::Other, :lt_string
+        rule /(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::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/, Str::Interpol, :pop!
+        rule /.*?\n/, Str::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
+          groups Punctuation, Text
+        end
+
+        rule /.*?{/, Punctuation, :pop!
+        rule /;/, Punctuation, :pop!
+      end
+
+      [[:cb, '\{', '\}'],
+       [:rb, '\(', '\)'],
+       [:sb, '\[', '\]'],
+       [:lt, '<',  '>']].each do |name, open, close|
+        tok = Str::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,193 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class PHP < TemplateLexer
+      title "PHP"
+      desc "The PHP scripting language (php.net)"
+      tag 'php'
+      aliases 'php', 'php3', 'php4', 'php5'
+      filenames '*.php', '*.php[345t]','*.phtml',
+                # Support Drupal file extensions, see:
+                # https://github.com/gitlabhq/gitlabhq/issues/8900
+                '*.module', '*.inc', '*.profile', '*.install', '*.test'
+      mimetypes 'text/x-php'
+
+      option :start_inline, 'Whether to start with inline php or require <?php ... ?>. (default: best guess)'
+      option :funcnamehighlighting, 'Whether to highlight builtin functions (default: true)'
+      option :disabledmodules, 'Disable certain modules from being highlighted as builtins (default: empty)'
+
+      def initialize(*)
+        super
+
+        # if truthy, the lexer starts highlighting with php code
+        # (no <?php required)
+        @start_inline = bool_option(:start_inline) { :guess }
+        @funcnamehighlighting = bool_option(:funcnamehighlighting) { true }
+        @disabledmodules = list_option(:disabledmodules)
+      end
+
+      def self.builtins
+        load Pathname.new(__FILE__).dirname.join('php/builtins.rb')
+        self.builtins
+      end
+
+      def builtins
+        return [] unless @funcnamehighlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          self.class.builtins.each do |mod, fns|
+            next if @disabledmodules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      # source: http://php.net/manual/en/language.variables.basics.php
+      # the given regex is invalid utf8, so... we're using the unicode
+      # "Letter" property instead.
+      id = /[\p{L}_][\p{L}\p{N}_]*/
+      nsid = /#{id}(?:\\#{id})*/
+
+      start do
+        case @start_inline
+        when true
+          push :template
+          push :php
+        when false
+          push :template
+        when :guess
+          # pass
+        end
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %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 yield
+        )
+      end
+
+      def self.analyze_text(text)
+        return 1 if text.shebang?('php')
+        return 0.3 if /<\?(?!xml)/ =~ text
+        0
+      end
+
+      state :root do
+        # some extremely rough heuristics to decide whether to start inline or not
+        rule(/\s*(?=<)/m) { delegate parent; push :template }
+        rule(/[^$]+(?=<\?(php|=))/) { delegate parent; push :template }
+
+        rule(//) { push :template; push :php }
+      end
+
+      state :template do
+        rule /<\?(php|=)?/, Comment::Preproc, :php
+        rule(/.*?(?=<\?)|.*/m) { delegate parent }
+      end
+
+      state :php do
+        rule /\?>/, Comment::Preproc, :pop!
+        # heredocs
+        rule /<<<('?)(#{id})\1\n.*?\n\2;?\n/im, Str::Heredoc
+        rule /\s+/, Text
+        rule /#.*?\n/, Comment::Single
+        rule %r(//.*?\n), Comment::Single
+        # empty comment, otherwise seen as the start of a docstring
+        rule %r(/\*\*/), Comment::Multiline
+        rule %r(/\*\*.*?\*/)m, Str::Doc
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule /(->|::)(\s*)(#{id})/ do
+          groups Operator, Text, Name::Attribute
+        end
+
+        rule /[~!%^&*+=\|:.<>\/?@-]+/, Operator
+        rule /[\[\]{}();,]/, Punctuation
+        rule /class\b/, Keyword, :classname
+        # anonymous functions
+        rule /(function)(\s*)(?=\()/ do
+          groups Keyword, Text
+        end
+
+        # named functions
+        rule /(function)(\s+)(&?)(\s*)/ do
+          groups Keyword, Text, Operator, Text
+          push :funcname
+        end
+
+        rule /(const)(\s+)(#{id})/i do
+          groups Keyword, Text, Name::Constant
+        end
+
+        rule /(true|false|null)\b/, Keyword::Constant
+        rule /\$\{\$+#{id}\}/i, Name::Variable
+        rule /\$+#{id}/i, Name::Variable
+
+        # may be intercepted for builtin highlighting
+        rule /\\?#{nsid}/i do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.builtins.include? name
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+
+        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, Num::Float
+        rule /\d+e[+-]?\d+/i, Num::Float
+        rule /0[0-7]+/, Num::Oct
+        rule /0x[a-f0-9]+/i, Num::Hex
+        rule /\d+/, Num::Integer
+        rule /'([^'\\]*(?:\\.[^'\\]*)*)'/, Str::Single
+        rule /`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
+        rule /"/, Str::Double, :string
+      end
+
+      state :classname do
+        rule /\s+/, Text
+        rule /#{nsid}/, Name::Class, :pop!
+      end
+
+      state :funcname do
+        rule /#{id}/, Name::Function, :pop!
+      end
+
+      state :string do
+        rule /"/, Str::Double, :pop!
+        rule /[^\\{$"]+/, Str::Double
+        rule /\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})/,
+          Str::Escape
+        rule /\$#{id}(\[\S+\]|->#{id})?/, Name::Variable
+
+        rule /\{\$\{/, Str::Interpol, :interp_double
+        rule /\{(?=\$)/, Str::Interpol, :interp_single
+        rule /(\{)(\S+)(\})/ do
+          groups Str::Interpol, Name::Variable, Str::Interpol
+        end
+
+        rule /[${\\]+/, Str::Double
+      end
+
+      state :interp_double do
+        rule /\}\}/, Str::Interpol, :pop!
+        mixin :php
+      end
+
+      state :interp_single do
+        rule /\}/, Str::Interpol, :pop!
+        mixin :php
+      end
+    end
+  end
+end