gitlab-rouge 1.9.2

data/lib/rouge/lexers/plain_text.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class PlainText < Lexer
+      title "Plain Text"
+      desc "A boring lexer that doesn't highlight anything"
+
+      tag 'plaintext'
+      aliases 'text'
+      filenames '*.txt'
+      mimetypes 'text/plain'
+
+      default_options :token => 'Text'
+
+      def token
+        @token ||= Token[option :token]
+      end
+
+      def stream_tokens(string, &b)
+        yield self.token, string
+      end
+    end
+  end
+end

data/lib/rouge/lexers/powershell.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_const :Shell, 'shell.rb'
+
+    class Powershell < Shell
+      title 'powershell'
+      desc 'powershell'
+      tag 'powershell'
+      aliases 'posh'
+      filenames '*.ps1', '*.psm1', '*.psd1'
+      mimetypes 'text/plain'
+
+      ATTRIBUTES = %w(
+        CmdletBinding ConfirmImpact DefaultParameterSetName HelpURI SupportsPaging
+        SupportsShouldProcess PositionalBinding
+      ).join('|')
+
+      KEYWORDS = %w(
+        Begin Exit Process Break Filter Return Catch Finally Sequence Class For
+        Switch Continue ForEach Throw Data From Trap Define Function Try Do If
+        Until DynamicParam In Using Else InlineScript Var ElseIf Parallel While
+        End Param Workflow
+      ).join('|')
+
+      KEYWORDS_TYPE = %w(
+        bool byte char decimal double float int long object sbyte
+        short string uint ulong ushort
+      ).join('|')
+
+      OPERATORS = %w(
+        -split -isplit -csplit -join -is -isnot -as -eq -ieq -ceq -ne -ine
+        -cne -gt -igt -cgt -ge -ige -cge -lt -ilt -clt -le -ile -cle -like
+        -ilike -clike -notlike -inotlike -cnotlike -match -imatch -cmatch
+        -notmatch -inotmatch -cnotmatch -contains -icontains -ccontains
+        -notcontains -inotcontains -cnotcontains -replace -ireplace
+        -creplace -band -bor -bxor -and -or -xor \. & = \+= -= \*= \/= %=
+      ).join('|')
+
+      BUILTINS = %w(
+        Add-Content Add-History Add-Member Add-PSSnapin Clear-Content
+        Clear-Item Clear-Item Property Clear-Variable Compare-Object
+        ConvertFrom-SecureString Convert-Path ConvertTo-Html
+        ConvertTo-SecureString Copy-Item Copy-ItemProperty Export-Alias
+        Export-Clixml Export-Console Export-Csv ForEach-Object
+        Format-Custom Format-List Format-Table Format-Wide
+        Get-Acl Get-Alias Get-AuthenticodeSignature Get-ChildItem
+        Get-Command Get-Content Get-Credential Get-Culture Get-Date
+        Get-EventLog Get-ExecutionPolicy Get-Help Get-History
+        Get-Host Get-Item Get-ItemProperty Get-Location Get-Member
+        Get-PfxCertificate Get-Process Get-PSDrive Get-PSProvider
+        Get-PSSnapin Get-Service Get-TraceSource Get-UICulture
+        Get-Unique Get-Variable Get-WmiObject Group-Object
+        Import-Alias Import-Clixml Import-Csv Invoke-Expression
+        Invoke-History Invoke-Item Join-Path Measure-Command
+        Measure-Object Move-Item Move-ItemProperty New-Alias
+        New-Item New-ItemProperty New-Object New-PSDrive New-Service
+        New-TimeSpan New-Variable Out-Default Out-File Out-Host Out-Null
+        Out-Printer Out-String Pop-Location Push-Location Read-Host
+        Remove-Item Remove-ItemProperty Remove-PSDrive Remove-PSSnapin
+        Remove-Variable Rename-Item Rename-ItemProperty Resolve-Path
+        Restart-Service Resume-Service Select-Object Select-String
+        Set-Acl Set-Alias Set-AuthenticodeSignature Set-Content Set-Date
+        Set-ExecutionPolicy Set-Item Set-ItemProperty Set-Location
+        Set-PSDebug Set-Service Set-TraceSource Set-Variable Sort-Object
+        Split-Path Start-Service Start-Sleep Start-Transcript Stop-Process
+        Stop-Service Stop-Transcript Suspend-Service Tee-Object Test-Path
+        Trace-Command Update-FormatData Update-TypeData Where-Object
+        Write-Debug Write-Error Write-Host Write-Output Write-Progress
+        Write-Verbose Write-Warning ac asnp cat cd chdir clc clear clhy
+        cli clp cls clv cnsn compare copy cp cpi cpp curl cvpa dbp del
+        diff dir dnsn ebp echo epal epcsv epsn erase etsn exsn fc fl
+        foreach ft fw gal gbp gc gci gcm gcs gdr ghy gi gjb gl gm gmo
+        gp gps group gsn gsnp gsv gu gv gwmi h history icm iex ihy ii
+        ipal ipcsv ipmo ipsn irm ise iwmi iwr kill lp ls man md measure
+        mi mount move mp mv nal ndr ni nmo npssc nsn nv ogv oh popd ps
+        pushd pwd r rbp rcjb rcsn rd rdr ren ri rjb rm rmdir rmo rni rnp
+        rp rsn rsnp rujb rv rvpa rwmi sajb sal saps sasv sbp sc select
+        set shcm si sl sleep sls sort sp spjb spps spsv start sujb sv
+        swmi tee trcm type wget where wjb write \% \?
+      ).join('|')
+
+      prepend :basic do
+        rule %r(<#[\s,\S]*?#>)m, Comment::Multiline
+        rule /#.*$/, Comment::Single
+        rule /\b(#{OPERATORS})\s*\b/i, Operator
+        rule /\b(#{ATTRIBUTES})\s*\b/i, Name::Attribute
+        rule /\b(#{KEYWORDS})\s*\b/i, Keyword
+        rule /\b(#{KEYWORDS_TYPE})\s*\b/i, Keyword::Type
+        rule /\bcase\b/, Keyword, :case
+        rule /\b(#{BUILTINS})\s*\b(?!\.)/i, Name::Builtin
+      end
+    end
+  end
+end

data/lib/rouge/lexers/prolog.rb

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Prolog < RegexLexer
+      title "Prolog"
+      desc "The Prolog programming language (http://en.wikipedia.org/wiki/Prolog)"
+      tag 'prolog'
+      aliases 'prolog'
+      filenames '*.pro', '*.P', '*.prolog', '*.pl'
+      mimetypes 'text/x-prolog'
+
+      def self.analyze_text(text)
+        return 0.1 if text =~ /\A\w+(\(\w+\,\s*\w+\))*\./
+        return 0.1 if text.include? ':-'
+      end
+
+      state :basic do
+        rule /\s+/, Text
+        rule /^#.*/, Comment::Single
+        rule /\/\*/, Comment::Multiline, :nested_comment
+
+        rule /[\[\](){}|.,;!]/, Punctuation
+        rule /:-|-->/, Punctuation
+
+        rule /"[^"]*"/, Str::Double
+
+        rule /\d+\.\d+/, Num::Float
+        rule /\d+/, Num
+      end
+
+      state :atoms do
+        rule /[[:lower:]]([_[:word:][:digit:]])*/, Str::Symbol
+        rule /'[^']*'/, Str::Symbol
+      end
+
+      state :operators do
+        rule /(<|>|=<|>=|==|=:=|=|\/|\/\/|\*|\+|-)(?=\s|[a-zA-Z0-9\[])/,
+          Operator
+        rule /is/, Operator
+        rule /(mod|div|not)/, Operator
+        rule /[#&*+-.\/:<=>?@^~]+/, Operator
+      end
+
+      state :variables do
+        rule /[A-Z]+\w*/, Name::Variable
+        rule /_[[:word:]]*/, Name::Variable
+      end
+
+      state :root do
+        mixin :basic
+        mixin :atoms
+        mixin :variables
+        mixin :operators
+      end
+
+      state :nested_comment do
+        rule /\/\*/, Comment::Multiline, :push
+        rule /\s*\*[^*\/]+/, Comment::Multiline
+        rule /\*\//, Comment::Multiline, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/properties.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Properties < RegexLexer
+      title ".properties"
+      desc '.properties config files for Java'
+      tag 'properties'
+
+      filenames '*.properties'
+      mimetypes 'text/x-java-properties'
+
+      def self.analyze_text(text)
+        return 0.1 if text =~ /\A\[[\w.]+\]\s*\w+=\w+/
+      end
+
+      identifier = /[\w.]+/
+
+      state :basic do
+        rule /[!#].*?\n/, Comment
+        rule /\s+/, Text
+        rule /\\\n/, Str::Escape
+      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 :basic
+        rule /"/, Str, :dq
+        rule /'.*?'/, Str
+        mixin :esc_str
+        rule /[^\\\n]+/, Str
+      end
+
+      state :dq do
+        rule /"/, Str, :pop!
+        mixin :esc_str
+        rule /[^\\"]+/m, Str
+      end
+
+      state :esc_str do
+        rule /\\u[0-9]{4}/, Str::Escape
+        rule /\\./m, Str::Escape
+      end
+    end
+  end
+end

data/lib/rouge/lexers/puppet.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Puppet < RegexLexer
+      title "Puppet"
+      desc 'The Puppet configuration management language (puppetlabs.org)'
+      tag 'puppet'
+      aliases 'pp'
+      filenames '*.pp'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'puppet-apply'
+        return 1 if text.shebang? 'puppet'
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          and case class default define else elsif if in import inherits
+          node unless
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          false true undef
+        )
+      end
+
+      def self.metaparameters
+        @metaparameters ||= Set.new %w(
+          before require notify subscribe
+        )
+      end
+
+      id = /[a-z]\w*/
+      cap_id = /[A-Z]\w*/
+      qualname = /(::)?(#{id}::)*\w+/
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule /#.*?\n/, Comment
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule /[$]#{qualname}/, Name::Variable
+        rule /(#{id})(?=\s*[=+]>)/m do |m|
+          if self.class.metaparameters.include? m[0]
+            token Keyword::Pseudo
+          else
+            token Name::Property
+          end
+        end
+
+        rule /(#{qualname})(?=\s*[(])/m, Name::Function
+        rule cap_id, Name::Class
+
+        rule /[+=|~-]>|<[|~-]/, Punctuation
+        rule /[:}();\[\]]/, Punctuation
+
+        # HACK for case statements and selectors
+        rule /{/, Punctuation, :regex_allowed
+        rule /,/, Punctuation, :regex_allowed
+
+        rule /(in|and|or)\b/, Operator::Word
+        rule /[=!<>]=/, Operator
+        rule /[=!]~/, Operator, :regex_allowed
+        rule %r([<>!+*/-]), Operator
+
+        rule /(class|include)(\s*)(#{qualname})/ do
+          groups Keyword, Text, Name::Class
+        end
+
+        rule /node\b/, Keyword, :regex_allowed
+
+        rule /'(\\[\\']|[^'])*'/m, Str::Single
+        rule /"/, Str::Double, :dquotes
+
+        rule /\d+([.]\d+)?(e[+-]\d+)?/, Num
+
+        # a valid regex.  TODO: regexes are only allowed
+        # in certain places in puppet.
+        rule qualname do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          else
+            token Name
+          end
+        end
+      end
+
+      state :regex_allowed do
+        mixin :whitespace
+        rule %r(/), Str::Regex, :regex
+
+        rule(//) { pop! }
+      end
+
+      state :regex do
+        rule %r(/), Str::Regex, :pop!
+        rule /\\./, Str::Escape
+        rule /[(){}]/, Str::Interpol
+        rule /\[/, Str::Interpol, :regex_class
+        rule /./, Str::Regex
+      end
+
+      state :regex_class do
+        rule /\]/, Str::Interpol, :pop!
+        rule /(?<!\[)-(?=\])/, Str::Regex
+        rule /-/, Str::Interpol
+        rule /\\./, Str::Escape
+        rule /[^\\\]-]+/, Str::Regex
+      end
+
+      state :dquotes do
+        rule /"/, Str::Double, :pop!
+        rule /[^$\\"]+/m, Str::Double
+        rule /\\./m, Str::Escape
+        rule /[$]#{qualname}/, Name::Variable
+        rule /[$][{]#{qualname}[}]/, Name::Variable
+      end
+    end
+  end
+end

data/lib/rouge/lexers/python.rb

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Python < RegexLexer
+      title "Python"
+      desc "The Python programming language (python.org)"
+      tag 'python'
+      aliases 'py'
+      filenames '*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac'
+      mimetypes 'text/x-python', 'application/x-python'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang?(/pythonw?(3|2(\.\d)?)?/)
+      end
+
+      def self.keywords
+        @keywords ||= %w(
+          assert break continue del elif else except exec
+          finally for global if lambda pass print raise
+          return try while yield as with
+        )
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          __import__ abs all any apply basestring bin bool buffer
+          bytearray bytes callable chr classmethod cmp coerce compile
+          complex delattr dict dir divmod enumerate eval execfile exit
+          file filter float frozenset getattr globals hasattr hash hex id
+          input int intern isinstance issubclass iter len list locals
+          long map max min next object oct open ord pow property range
+          raw_input reduce reload repr reversed round set setattr slice
+          sorted staticmethod str sum super tuple type unichr unicode
+          vars xrange zip
+        )
+      end
+
+      def self.builtins_pseudo
+        @builtins_pseudo ||= %w(self None Ellipsis NotImplemented False True)
+      end
+
+      def self.exceptions
+        @exceptions ||= %w(
+          ArithmeticError AssertionError AttributeError
+          BaseException DeprecationWarning EOFError EnvironmentError
+          Exception FloatingPointError FutureWarning GeneratorExit IOError
+          ImportError ImportWarning IndentationError IndexError KeyError
+          KeyboardInterrupt LookupError MemoryError NameError
+          NotImplemented NotImplementedError OSError OverflowError
+          OverflowWarning PendingDeprecationWarning ReferenceError
+          RuntimeError RuntimeWarning StandardError StopIteration
+          SyntaxError SyntaxWarning SystemError SystemExit TabError
+          TypeError UnboundLocalError UnicodeDecodeError
+          UnicodeEncodeError UnicodeError UnicodeTranslateError
+          UnicodeWarning UserWarning ValueError VMSError Warning
+          WindowsError ZeroDivisionError
+        )
+      end
+
+      identifier =        /[a-z_][a-z0-9_]*/i
+      dotted_identifier = /[a-z_.][a-z0-9_.]*/i
+      state :root do
+        rule /\n+/m, Text
+        rule /^(:)(\s*)([ru]{,2}""".*?""")/mi do
+          groups Punctuation, Text, Str::Doc
+        end
+
+        rule /[^\S\n]+/, Text
+        rule /#.*$/, Comment
+        rule /[\[\]{}:(),;]/, Punctuation
+        rule /\\\n/, Text
+        rule /\\/, Text
+
+        rule /(in|is|and|or|not)\b/, Operator::Word
+        rule /!=|==|<<|>>|[-~+\/*%=<>&^|.]/, Operator
+
+        rule /(def)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :funcname
+        end
+
+        rule /(class)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :classname
+        end
+
+        rule /(from)((?:\s|\\\s)+)/ do
+          groups Keyword::Namespace, Text
+          push :fromimport
+        end
+
+        rule /(import)((?:\s|\\\s)+)/ do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+
+        # TODO: not in python 3
+        rule /`.*?`/, Str::Backtick
+        rule /(?:r|ur|ru)"""/i, Str, :tdqs
+        rule /(?:r|ur|ru)'''/i, Str, :tsqs
+        rule /(?:r|ur|ru)"/i,   Str, :dqs
+        rule /(?:r|ur|ru)'/i,   Str, :sqs
+        rule /u?"""/i,          Str, :escape_tdqs
+        rule /u?'''/i,          Str, :escape_tsqs
+        rule /u?"/i,            Str, :escape_dqs
+        rule /u?'/i,            Str, :escape_sqs
+
+        rule /@#{dotted_identifier}/i, Name::Decorator
+
+        # using negative lookbehind so we don't match property names
+        rule /(?<!\.)#{identifier}/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.exceptions.include? m[0]
+            token Name::Builtin
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif self.class.builtins_pseudo.include? m[0]
+            token Name::Builtin::Pseudo
+          else
+            token Name
+          end
+        end
+
+        rule identifier, Name
+
+        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
+        rule /\d+e[+-]?[0-9]+/i, Num::Float
+        rule /0[0-7]+/, Num::Oct
+        rule /0x[a-f0-9]+/i, Num::Hex
+        rule /\d+L/, Num::Integer::Long
+        rule /\d+/, Num::Integer
+      end
+
+      state :funcname do
+        rule identifier, Name::Function, :pop!
+      end
+
+      state :classname do
+        rule identifier, Name::Class, :pop!
+      end
+
+      state :import do
+        # non-line-terminating whitespace
+        rule /(?:[ \t]|\\\n)+/, Text
+
+        rule /as\b/, Keyword::Namespace
+        rule /,/, Operator
+        rule dotted_identifier, Name::Namespace
+        rule(//) { pop! } # anything else -> go back
+      end
+
+      state :fromimport do
+        # non-line-terminating whitespace
+        rule /(?:[ \t]|\\\n)+/, Text
+
+        rule /import\b/, Keyword::Namespace, :pop!
+        rule dotted_identifier, Name::Namespace
+      end
+
+      state :strings do
+        rule /%(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, Str::Interpol
+      end
+
+      state :strings_double do
+        rule /[^\\"%\n]+/, Str
+        mixin :strings
+      end
+
+      state :strings_single do
+        rule /[^\\'%\n]+/, Str
+        mixin :strings
+      end
+
+      state :nl do
+        rule /\n/, Str
+      end
+
+      state :escape do
+        rule %r(\\
+          ( [\\abfnrtv"']
+          | \n
+          | N{.*?}
+          | u[a-fA-F0-9]{4}
+          | U[a-fA-F0-9]{8}
+          | x[a-fA-F0-9]{2}
+          | [0-7]{1,3}
+          )
+        )x, Str::Escape
+      end
+
+      state :dqs do
+        rule /"/, Str, :pop!
+        rule /\\\\|\\"|\\\n/, Str::Escape
+        mixin :strings_double
+      end
+
+      state :sqs do
+        rule /'/, Str, :pop!
+        rule /\\\\|\\'|\\\n/, Str::Escape
+        mixin :strings_single
+      end
+
+      state :tdqs do
+        rule /"""/, Str, :pop!
+        rule /"/, Str
+        mixin :strings_double
+        mixin :nl
+      end
+
+      state :tsqs do
+        rule /'''/, Str, :pop!
+        rule /'/, Str
+        mixin :strings_single
+        mixin :nl
+      end
+
+      %w(tdqs tsqs dqs sqs).each do |qtype|
+        state :"escape_#{qtype}" do
+          mixin :escape
+          mixin :"#{qtype}"
+        end
+      end
+
+    end
+  end
+end