rouge 1.11.0 → 1.11.1

data/lib/rouge/lexers/d.rb

@@ -9,7 +9,7 @@ module Rouge
       mimetypes 'application/x-dsrc', 'text/x-dsrc'
 
       title "D"
-      desc 'The D programming language(dlag.org)'
+      desc 'The D programming language(dlang.org)'
 
       keywords = %w(
         abstract alias align asm assert auto body

data/lib/rouge/lexers/groovy.rb

@@ -57,10 +57,14 @@ module Rouge
         rule /package\b/, Keyword::Namespace, :import
         rule /import\b/, Keyword::Namespace, :import
 
-        rule /"(\\\\|\\"|[^"])*"/, Str::Double
-        rule /'(\\\\|\\'|[^'])*'/, Str::Single
-        rule %r(\$/((?!/\$).)*/\$), Str
-        rule %r(/(\\\\|\\"|[^/])*/), Str
+        # TODO: highlight backslash escapes
+        rule /""".*?"""/m, Str::Double
+        rule /'''.*?'''/m, Str::Single
+
+        rule /"(\\.|\\\n|.)*?"/, Str::Double
+        rule /'(\\.|\\\n|.)*?'/, Str::Single
+        rule %r(\$/(\$.|.)*?/\$)m, Str
+        rule %r(/(\\.|\\\n|.)*?/), Str
         rule /'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, Str::Char
         rule /(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
           groups Operator, Name::Attribute

data/lib/rouge/lexers/http.rb

@@ -7,8 +7,8 @@ module Rouge
       title "HTTP"
       desc 'http requests and responses'
 
-      def self.methods
-        @methods ||= %w(GET POST PUT DELETE HEAD OPTIONS TRACE PATCH)
+      def self.http_methods
+        @http_methods ||= %w(GET POST PUT DELETE HEAD OPTIONS TRACE PATCH)
       end
 
       def content_lexer
@@ -24,7 +24,7 @@ module Rouge
       state :root do
         # request
         rule %r(
-          (#{HTTP.methods.join('|')})([ ]+) # method
+          (#{HTTP.http_methods.join('|')})([ ]+) # method
           ([^ ]+)([ ]+)                     # path
           (HTTPS?)(/)(1[.][01])(\r?\n|$)  # http version
         )ox do

data/lib/rouge/lexers/javascript.rb

@@ -2,6 +2,12 @@
 
 module Rouge
   module Lexers
+    # IMPORTANT NOTICE:
+    #
+    # Please do not copy this lexer and open a pull request
+    # for a new language. It will not get merged, you will
+    # be unhappy, and kittens will cry.
+    #
     class Javascript < RegexLexer
       title "JavaScript"
       desc "JavaScript, the browser scripting language"
@@ -33,7 +39,10 @@ module Rouge
           goto :regex
         end
 
-        rule /[{]/, Punctuation, :object
+        rule /[{]/ do
+          token Punctuation
+          goto :object
+        end
 
         rule //, Text, :pop!
       end
@@ -177,6 +186,12 @@ module Rouge
       # object literals
       state :object do
         mixin :comments_and_whitespace
+
+        rule /[{]/ do
+          token Punctuation
+          push
+        end
+
         rule /[}]/ do
           token Punctuation
           goto :statement

data/lib/rouge/lexers/kotlin.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Kotlin < RegexLexer
+      title "Kotlin"
+      desc "Kotlin <http://kotlinlang.org>"
+
+      tag 'kotlin'
+      filenames '*.kt'
+      mimetypes 'text/x-kotlin'
+
+      keywords = %w(
+        abstract annotation as break by catch class companion const
+        constructor continue crossinline do dynamic else enum
+        external false final finally for fun get if import in infix
+        inline inner interface internal is lateinit noinline null
+        object open operator out override package private protected
+        public reified return sealed set super tailrec this throw
+        true try typealias typeof val var vararg when where while
+        yield
+      )
+
+      name = %r'@?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}][\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
+
+      id = %r'(#{name}|`#{name}`)'
+
+      state :root do
+        rule %r'^\s*\[.*?\]', Name::Attribute
+        rule %r'[^\S\n]+', Text
+        rule %r'\\\n', Text # line continuation
+        rule %r'//.*?\n', Comment::Single
+        rule %r'/[*].*?[*]/'m, Comment::Multiline
+        rule %r'\n', Text
+        rule %r'::|!!|\?[:.]', Operator
+        rule %r"(\.\.)", Operator
+        rule %r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation
+        rule %r'[{}]', Punctuation
+        rule %r'@"(""|[^"])*"'m, Str
+        rule %r'""".*?"""'m, Str
+        rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
+        rule %r"'\\.'|'[^\\]'", Str::Char
+        rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
+        rule %r'(class)(\s+)(object)' do
+          groups Keyword, Text, Keyword
+        end
+        rule %r'(class|data\s+class|interface|object)(\s+)' do
+          groups Keyword::Declaration, Text
+          push :class
+        end
+        rule %r'(package|import)(\s+)' do
+          groups Keyword, Text
+          push :package
+        end
+        rule %r'(val|var)(\s+)' do
+          groups Keyword::Declaration, Text
+          push :property
+        end
+        rule %r'(fun)(\s+)' do
+          groups Keyword, Text
+          push :function
+        end
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule id, Name
+      end
+
+      state :package do
+        rule /\S+/, Name::Namespace, :pop!
+      end
+
+      state :class do
+        rule id, Name::Class, :pop!
+      end
+
+      state :property do
+        rule id, Name::Property, :pop!
+      end
+
+      state :function do
+        rule id, Name::Function, :pop!
+      end
+    end
+  end
+end

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/praat.rb

@@ -16,7 +16,7 @@ module Rouge
 
       keywords = %w(
         if then else elsif elif endif fi for from to endfor endproc while
-        endwhile repeat until select plus minus demo assert stopwatch 
+        endwhile repeat until select plus minus demo assert stopwatch
         nocheck nowarn noprogress editor endeditor clearinfo
       )
 
@@ -39,7 +39,7 @@ module Rouge
         endSendPraat endsWith erb erbToHertz erf erfc exitScript exp
         extractNumber fileReadable fisherP fisherQ floor gaussP gaussQ
         hertzToBark hertzToErb hertzToMel hertzToSemitones imax imin
-        incompleteBeta incompleteGammaP index index_regex invBinomialP
+        incompleteBeta incompleteGammaP index index_regex integer invBinomialP
         invBinomialQ invChiSquareQ invFisherQ invGaussQ invSigmoid invStudentQ
         length ln lnBeta lnGamma log10 log2 max melToHertz min minusObject
         natural number numberOfColumns numberOfRows numberOfSelected
@@ -47,10 +47,10 @@ module Rouge
         phonToDifferenceLimens plusObject positive randomBinomial randomGauss
         randomInteger randomPoisson randomUniform real readFile removeObject
         rindex rindex_regex round runScript runSystem runSystem_nocheck
-        selectObject selected semitonesToHertz sentencetext sigmoid sin sinc
-        sincpi sinh soundPressureToPhon sqrt startsWith studentP studentQ tan
-        tanh variableExists word writeFile writeFileLine writeInfo
-        writeInfoLine
+        selectObject selected semitonesToHertz sentence sentencetext sigmoid
+        sin sinc sincpi sinh soundPressureToPhon sqrt startsWith studentP
+        studentQ tan tanh text variableExists word writeFile writeFileLine
+        writeInfo writeInfoLine
       )
 
       functions_array = %w(
@@ -62,29 +62,31 @@ module Rouge
         BarkFilter BarkSpectrogram CCA Categories Cepstrogram Cepstrum
         Cepstrumc ChebyshevSeries ClassificationTable Cochleagram Collection
         ComplexSpectrogram Configuration Confusion ContingencyTable Corpus
-        Correlation Covariance CrossCorrelationTable CrossCorrelationTables DTW
-        DataModeler Diagonalizer Discriminant Dissimilarity Distance
-        Distributions DurationTier EEG ERP ERPTier EditCostsTable
-        EditDistanceTable Eigen Excitation Excitations ExperimentMFC FFNet
-        FeatureWeights FileInMemory FilesInMemory Formant FormantFilter
-        FormantGrid FormantModeler FormantPoint FormantTier GaussianMixture HMM
-        HMM_Observation HMM_ObservationSequence HMM_State HMM_StateSequence
-        Harmonicity ISpline Index Intensity IntensityTier IntervalTier KNN
-        KlattGrid KlattTable LFCC LPC Label LegendreSeries LinearRegression
-        LogisticRegression LongSound Ltas MFCC MSpline ManPages Manipulation
-        Matrix MelFilter MelSpectrogram MixingMatrix Movie Network OTGrammar
-        OTHistory OTMulti PCA PairDistribution ParamCurve Pattern Permutation
-        Photo Pitch PitchModeler PitchTier PointProcess Polygon Polynomial
-        PowerCepstrogram PowerCepstrum Procrustes RealPoint RealTier ResultsMFC
-        Roots SPINET SSCP SVD Salience ScalarProduct Similarity SimpleString
-        SortedSetOfString Sound Speaker Spectrogram Spectrum SpectrumTier
-        SpeechSynthesizer SpellingChecker Strings StringsIndex Table
-        TableOfReal TextGrid TextInterval TextPoint TextTier Tier Transition
-        VocalTract VocalTractTier Weight WordList
+        Correlation Covariance CrossCorrelationTable CrossCorrelationTableList
+        CrossCorrelationTables DTW DataModeler Diagonalizer Discriminant
+        Dissimilarity Distance Distributions DurationTier EEG ERP ERPTier
+        EditCostsTable EditDistanceTable Eigen Excitation Excitations
+        ExperimentMFC FFNet FeatureWeights FileInMemory FilesInMemory Formant
+        FormantFilter FormantGrid FormantModeler FormantPoint FormantTier
+        GaussianMixture HMM HMM_Observation HMM_ObservationSequence HMM_State
+        HMM_StateSequence HMMObservation HMMObservationSequence HMMState
+        HMMStateSequence Harmonicity ISpline Index Intensity IntensityTier
+        IntervalTier KNN KlattGrid KlattTable LFCC LPC Label LegendreSeries
+        LinearRegression LogisticRegression LongSound Ltas MFCC MSpline ManPages
+        Manipulation Matrix MelFilter MelSpectrogram MixingMatrix Movie Network
+        OTGrammar OTHistory OTMulti PCA PairDistribution ParamCurve Pattern
+        Permutation Photo Pitch PitchModeler PitchTier PointProcess Polygon
+        Polynomial PowerCepstrogram PowerCepstrum Procrustes RealPoint RealTier
+        ResultsMFC Roots SPINET SSCP SVD Salience ScalarProduct Similarity
+        SimpleString SortedSetOfString Sound Speaker Spectrogram Spectrum
+        SpectrumTier SpeechSynthesizer SpellingChecker Strings StringsIndex
+        Table TableOfReal TextGrid TextInterval TextPoint TextTier Tier
+        Transition VocalTract VocalTractTier Weight WordList
       )
 
       variables_numeric = %w(
-        macintosh windows unix praatVersion pi e undefined
+        all average e left macintosh mono pi praatVersion right stereo
+        undefined unix windows
       )
 
       variables_string = %w(
@@ -93,6 +95,10 @@ module Rouge
         defaultDirectory
       )
 
+      object_attributes = %w(
+        ncol nrow xmin ymin xmax ymax nx ny dx dy
+      )
+
       state :root do
         rule /(\s+)(#.*?$)/ do
           groups Text, Comment::Single
@@ -107,6 +113,7 @@ module Rouge
 
         mixin :function_call
 
+        rule /\b(?:select all)\b/, Keyword
         rule /\b(?:#{keywords.join('|')})\b/, Keyword
 
         rule /(\bform\b)(\s+)([^\n]+)/ do
@@ -132,51 +139,25 @@ module Rouge
 
         rule /\b(?=[A-Z])/, Text, :command
         rule /(\.{3}|[)(,\$])/, Punctuation
-        rule /./, Generic::Error
       end
 
       state :command do
         rule /( ?[\w()-]+ ?)/, Keyword
-        rule /'(?=.*')/,  Literal::String::Interpol, :string_interpolated
-        rule /\.{3}/,     Keyword, :old_arguments
-        rule /:/,         Keyword, :comma_list
-        rule /[\s\n]/,    Text, :pop!
-      end
+        mixin :string_interpolated
 
-      state :function_call do
-        rule /\b(#{functions_string.join('|')})\$(?=\s*[:(])/, Name::Function, :function
-        rule /\b(#{functions_array.join('|')})#(?=\s*[:(])/,   Name::Function, :function
-        rule /\b(#{functions_numeric.join('|')})(?=\s*[:(])/,  Name::Function, :function
-      end
-
-      state :old_arguments do
-        rule /\n/ do
-          token Text
+        rule /\.{3}/ do
+          token Keyword
           pop!
-          pop! unless state? :root
+          push :old_arguments
         end
 
-        mixin :function_call
-        mixin :operator
-        mixin :number
-
-        rule /"/, Literal::String, :string
-        rule /[^\n]/, Text
-      end
-
-      state :function do
-        rule /\s+/, Text
-
         rule /:/ do
-          token Punctuation
-          push :comma_list
-        end
-
-        rule /\s*\(/ do
-          token Punctuation
+          token Keyword
           pop!
           push :comma_list
         end
+
+        rule /[\s\n]/,    Text, :pop!
       end
 
       state :procedure_call do
@@ -184,10 +165,14 @@ module Rouge
 
         rule /([\w.]+)(:|\s*\()/ do
           groups Name::Function, Punctuation
-          push :comma_list
+          pop!
         end
 
-        rule /([\w.]+)/, Name::Function, :old_arguments
+        rule /([\w.]+)/ do
+          token Name::Function
+          pop!
+          push :old_arguments
+        end
       end
 
       state :procedure_definition do
@@ -204,16 +189,28 @@ module Rouge
         end
       end
 
+      state :function_call do
+        rule /\b(#{functions_string.join('|')})\$(?=\s*[:(])/, Name::Function, :function
+        rule /\b(#{functions_array.join('|')})#(?=\s*[:(])/,   Name::Function, :function
+        rule /\b(#{functions_numeric.join('|')})(?=\s*[:(])/,  Name::Function, :function
+      end
+
+      state :function do
+        rule /\s+/, Text
+
+        rule /(?::|\s*\()/ do
+          token Text
+          pop!
+          push :comma_list
+        end
+      end
+
       state :comma_list do
         rule /(\s*\n\s*)(\.{3})/ do
           groups Text, Punctuation
         end
 
-        rule /\s*(\)|\]|\n)/ do
-          token Punctuation
-          pop!
-          pop! unless state? :root
-        end
+        rule /\s*[\])\n]/, Text, :pop!
 
         rule /\s+/, Text
         rule /"/,   Literal::String, :string
@@ -224,9 +221,21 @@ module Rouge
         mixin :operator
         mixin :number
 
+        rule /[()]/, Text
         rule /,/, Punctuation
       end
 
+      state :old_arguments do
+        rule /\n/, Text, :pop!
+
+        mixin :variable_name
+        mixin :operator
+        mixin :number
+
+        rule /"/, Literal::String, :string
+        rule /[^\n]/, Text
+      end
+
       state :number do
         rule /\n/, Text, :pop!
         rule /\b\d+(\.\d*)?([eE][-+]?\d+)?%?/, Literal::Number
@@ -237,43 +246,45 @@ module Rouge
         mixin :number
 
         rule /\b(?:#{variables_string.join('|')})\$/,  Name::Builtin
-        rule /\b(?:#{variables_numeric.join('|')})\b/, Name::Builtin
+        rule /\b(?:#{variables_numeric.join('|')})(?!\$)\b/, Name::Builtin
 
-        rule /\b(Object|#{objects.join('|')})_\w+/, Name::Builtin, :object_attributes
-
-        rule /\b((?:Object|#{objects.join('|')})_)(')/ do
-          groups Name::Builtin, Literal::String::Interpol
-          push :object_attributes
-          push :string_interpolated
+        rule /\b(Object|#{objects.join('|')})_/ do
+          token Name::Builtin
+          push :object_reference
         end
 
         rule /\.?[a-z][a-zA-Z0-9_.]*(\$|#)?/, Text
-        rule /[\[\]]/, Punctuation
-        rule /'(?=.*')/, Literal::String::Interpol, :string_interpolated
+        rule /[\[\]]/, Text, :comma_list
+        mixin :string_interpolated
       end
 
-      state :object_attributes do
-        rule /\.?(n(col|row)|[xy]min|[xy]max|[nd][xy])\b/, Name::Builtin, :pop!
-        rule /(\.?(?:col|row)\$)(\[)/ do
-          groups Name::Builtin, Punctuation
-          push :variable_name
-        end
-        rule /(\$?)(\[)/ do
-          groups Name::Builtin, Punctuation
-          push :comma_list
-        end
+      state :object_reference do
+        mixin :string_interpolated
+        rule /([a-z][a-zA-Z0-9_]*|\d+)/, Name::Builtin
+
+        rule /\.(#{object_attributes.join('|')})\b/, Name::Builtin, :pop!
+
+        rule /\$/, Name::Builtin
+        rule /\[/, Text, :pop!
+      end
+
+      state :operator do
+        # This rule incorrectly matches === or +++++, which are not operators
+        rule /([+\/*<>=!-]=?|[&*|][&*|]?|\^|<>)/,       Operator
+        rule /(?<![\w.])(and|or|not|div|mod)(?![\w.])/, Operator::Word
       end
 
       state :string_interpolated do
-        rule /\.?[_a-z][a-zA-Z0-9_.]*(?:[\$#]?(?:\[[a-zA-Z0-9,]+\])?|:[0-9]+)?/, Literal::String::Interpol
-        rule /'/, Literal::String::Interpol, :pop!
+        rule /'[\._a-z][^\[\]'":]*(\[([\d,]+|"[\w\d,]+")\])?(:[0-9]+)?'/, Literal::String::Interpol
       end
 
       state :string_unquoted do
         rule /\n\s*\.{3}/, Punctuation
         rule /\n/,         Text, :pop!
         rule /\s/,         Text
-        rule /'(?=.*')/,   Literal::String::Interpol, :string_interpolated
+
+        mixin :string_interpolated
+
         rule /'/,          Literal::String
         rule /[^'\n]+/,    Literal::String
       end
@@ -281,12 +292,18 @@ module Rouge
       state :string do
         rule /\n\s*\.{3}/, Punctuation
         rule /"/,          Literal::String,           :pop!
-        rule /'(?=.*')/,   Literal::String::Interpol, :string_interpolated
+
+        mixin :string_interpolated
+
         rule /'/,          Literal::String
         rule /[^'"\n]+/,   Literal::String
       end
 
       state :old_form do
+        rule /(\s+)(#.*?$)/ do
+          groups Text, Comment::Single
+        end
+
         rule /\s+/, Text
 
         rule /(optionmenu|choice)([ \t]+\S+:[ \t]+)/ do
@@ -294,11 +311,6 @@ module Rouge
           push :number
         end
 
-        rule /(option|button)([ \t]+)/ do
-          groups Keyword, Text
-          push :number
-        end
-
         rule /(option|button)([ \t]+)/ do
           groups Keyword, Text
           push :string_unquoted
@@ -310,7 +322,7 @@ module Rouge
         end
 
         rule /(word)([ \t]+\S+[ \t]*)(\S+)?([ \t]+.*)?/ do
-          groups Keyword, Text, Literal::String, Generic::Error
+          groups Keyword, Text, Literal::String, Text
         end
 
         rule /(boolean)(\s+\S+\s*)(0|1|"?(?:yes|no)"?)/ do
@@ -330,11 +342,6 @@ module Rouge
         rule /\bendform\b/, Keyword, :pop!
       end
 
-      state :operator do
-        # This rule incorrectly matches === or +++++, which are not operators
-        rule /([+\/*<>=!-]=?|[&*|][&*|]?|\^|<>)/, Operator
-        rule /\b(and|or|not|div|mod)\b/,          Operator::Word
-      end
     end
   end
 end