gitlab-rouge 1.9.2

data/lib/rouge/lexers/sass.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_const :SassCommon, 'sass/common.rb'
+
+    class Sass < SassCommon
+      include Indentation
+
+      title "Sass"
+      desc 'The Sass stylesheet language language (sass-lang.com)'
+
+      tag 'sass'
+      filenames '*.sass'
+      mimetypes 'text/x-sass'
+
+      id = /[\w-]+/
+
+      state :root do
+        rule /[ \t]*\n/, Text
+        rule(/[ \t]*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        # block comments
+        rule %r(//.*?\n) do
+          token Comment::Single
+          pop!; starts_block :single_comment
+        end
+
+        rule %r(/[*].*?\n) do
+          token Comment::Multiline
+          pop!; starts_block :multi_comment
+        end
+
+        rule /@import\b/, Keyword, :import
+
+        mixin :content_common
+
+        rule %r(=#{id}), Name::Function, :value
+        rule %r([+]#{id}), Name::Decorator, :value
+
+        rule /:/, Name::Attribute, :old_style_attr
+
+        rule(/(?=.+?:([^a-z]|$))/) { push :attribute }
+
+        rule(//) { push :selector }
+      end
+
+      state :single_comment do
+        rule /.*?\n/, Comment::Single, :pop!
+      end
+
+      state :multi_comment do
+        rule /.*?\n/, Comment::Multiline, :pop!
+      end
+
+      state :import do
+        rule /[ \t]+/, Text
+        rule /\S+/, Str
+        rule /\n/, Text, :pop!
+      end
+
+      state :old_style_attr do
+        mixin :attr_common
+        rule(//) { pop!; push :value }
+      end
+
+      state :end_section do
+        rule(/\n/) { token Text; reset_stack }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/sass/common.rb

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    # shared states with SCSS
+    class SassCommon < RegexLexer
+      id = /[\w-]+/
+
+      state :content_common do
+        rule /@for\b/, Keyword, :for
+        rule /@(debug|warn|if|each|while|else|return|media)/, Keyword, :value
+
+        rule /(@mixin)(\s+)(#{id})/ do
+          groups Keyword, Text, Name::Function
+          push :value
+        end
+
+        rule /(@function)(\s+)(#{id})/ do
+          groups Keyword, Text, Name::Function
+          push :value
+        end
+
+        rule /@extend\b/, Keyword, :selector
+
+        rule /(@include)(\s+)(#{id})/ do
+          groups Keyword, Text, Name::Decorator
+          push :value
+        end
+
+        rule /@#{id}/, Keyword, :selector
+
+        # $variable: assignment
+        rule /([$]#{id})([ \t]*)(:)/ do
+          groups Name::Variable, Text, Punctuation
+          push :value
+        end
+      end
+
+      state :value do
+        mixin :end_section
+        rule /[ \t]+/, Text
+        rule /[$]#{id}/, Name::Variable
+        rule /url[(]/, Str::Other, :string_url
+        rule /#{id}(?=\s*[(])/, Name::Function
+        rule /%#{id}/, Name::Decorator
+
+        # named literals
+        rule /(true|false)\b/, Name::Builtin::Pseudo
+        rule /(and|or|not)\b/, Operator::Word
+
+        # colors and numbers
+        rule /#[a-z0-9]{1,6}/i, Num::Hex
+        rule /-?\d+(%|[a-z]+)?/, Num
+        rule /-?\d*\.\d+(%|[a-z]+)?/, Num::Integer
+
+        mixin :has_strings
+        mixin :has_interp
+
+        rule /[~^*!&%<>\|+=@:,.\/?-]+/, Operator
+        rule /[\[\]()]+/, Punctuation
+        rule %r(/[*]), Comment::Multiline, :inline_comment
+        rule %r(//[^\n]*), Comment::Single
+
+        # identifiers
+        rule(id) do |m|
+          if CSS.builtins.include? m[0]
+            token Name::Builtin
+          elsif CSS.constants.include? m[0]
+            token Name::Constant
+          else
+            token Name
+          end
+        end
+      end
+
+      state :has_interp do
+        rule /[#][{]/, Str::Interpol, :interpolation
+      end
+
+      state :has_strings do
+        rule /"/, Str::Double, :dq
+        rule /'/, Str::Single, :sq
+      end
+
+      state :interpolation do
+        rule /}/, Str::Interpol, :pop!
+        mixin :value
+      end
+
+      state :selector do
+        mixin :end_section
+
+        mixin :has_strings
+        mixin :has_interp
+        rule /[ \t]+/, Text
+        rule /:/, Name::Decorator, :pseudo_class
+        rule /[.]/, Name::Class, :class
+        rule /#/, Name::Namespace, :id
+        rule /%/, Name::Variable, :placeholder
+        rule id, Name::Tag
+        rule /&/, Keyword
+        rule /[~^*!&\[\]()<>\|+=@:;,.\/?-]/, Operator
+      end
+
+      state :dq do
+        rule /"/, Str::Double, :pop!
+        mixin :has_interp
+        rule /(\\.|#(?![{])|[^\n"#])+/, Str::Double
+      end
+
+      state :sq do
+        rule /'/, Str::Single, :pop!
+        mixin :has_interp
+        rule /(\\.|#(?![{])|[^\n'#])+/, Str::Single
+      end
+
+      state :string_url do
+        rule /[)]/, Str::Other, :pop!
+        rule /(\\.|#(?![{])|[^\n)#])+/, Str::Other
+        mixin :has_interp
+      end
+
+      state :selector_piece do
+        mixin :has_interp
+        rule(//) { pop! }
+      end
+
+      state :pseudo_class do
+        rule id, Name::Decorator
+        mixin :selector_piece
+      end
+
+      state :class do
+        rule id, Name::Class
+        mixin :selector_piece
+      end
+
+      state :id do
+        rule id, Name::Namespace
+        mixin :selector_piece
+      end
+
+      state :placeholder do
+        rule id, Name::Variable
+        mixin :selector_piece
+      end
+
+      state :for do
+        rule /(from|to|through)/, Operator::Word
+        mixin :value
+      end
+
+      state :attr_common do
+        mixin :has_interp
+        rule id do |m|
+          if CSS.attributes.include? m[0]
+            token Name::Label
+          else
+            token Name::Attribute
+          end
+        end
+      end
+
+      state :attribute do
+        mixin :attr_common
+
+        rule /([ \t]*)(:)/ do
+          groups Text, Punctuation
+          push :value
+        end
+      end
+
+      state :inline_comment do
+        rule /(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, Comment::Multiline
+        mixin :has_interp
+        rule %r([*]/), Comment::Multiline, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/scala.rb

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 #
+
+module Rouge
+  module Lexers
+    class Scala < RegexLexer
+      title "Scala"
+      desc "The Scala programming language (scala-lang.org)"
+      tag 'scala'
+      aliases 'scala'
+      filenames '*.scala', '*.sbt'
+
+      mimetypes 'text/x-scala', 'application/x-scala'
+
+      # As documented in the ENBF section of the scala specification
+      # http://www.scala-lang.org/docu/files/ScalaReference.pdf
+      whitespace = /\p{Space}/
+      letter = /[\p{L}$_]/
+      upper = /[\p{Lu}$_]/
+      digits = /[0-9]/
+      parens = /[(){}\[\]]/
+      delims = %r([‘’".;,])
+
+      # negative lookahead to filter out other classes
+      op = %r(
+        (?!#{whitespace}|#{letter}|#{digits}|#{parens}|#{delims})
+        [\u0020-\u007F\p{Sm}\p{So}]
+      )x
+
+      idrest = %r(#{letter}(?:#{letter}|#{digits})*(?:(?<=_)#{op}+)?)x
+
+      keywords = %w(
+        abstract case catch def do else extends final finally for forSome
+        if implicit lazy match new override private protected requires return
+        sealed super this throw try val var while with yield
+      )
+
+      state :root do
+        rule /(class|trait|object)(\s+)/ do
+          groups Keyword, Text
+          push :class
+        end
+        rule /'#{idrest}[^']/, Str::Symbol
+        rule /[^\S\n]+/, Text
+
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/\*), Comment::Multiline, :comment
+
+        rule /@#{idrest}/, Name::Decorator
+        rule %r(
+          (#{keywords.join("|")})\b|
+          (<[%:-]|=>|>:|[#=@_\u21D2\u2190])(\b|(?=\s)|$)
+        )x, Keyword
+        rule /:(?!#{op})/, Keyword, :type
+        rule /#{upper}#{idrest}\b/, Name::Class
+        rule /(true|false|null)\b/, Keyword::Constant
+        rule /(import|package)(\s+)/ do
+          groups Keyword, Text
+          push :import
+        end
+
+        rule /(type)(\s+)/ do
+          groups Keyword, Text
+          push :type
+        end
+
+        rule /""".*?"""(?!")/m, Str
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'/, Str::Char
+
+        rule idrest, Name
+        rule /`[^`]+`/, Name
+
+        rule /\[/, Operator, :typeparam
+        rule /[\(\)\{\};,.#]/, Operator
+        rule /#{op}+/, Operator
+
+        rule /([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?/, Num::Float
+        rule /([0-9][0-9]*[fFdD])/, Num::Float
+        rule /0x[0-9a-fA-F]+/, Num::Hex
+        rule /[0-9]+L?/, Num::Integer
+        rule /\n/, Text
+      end
+
+      state :class do
+        rule /(#{idrest}|#{op}+|`[^`]+`)(\s*)(\[)/ do
+          groups Name::Class, Text, Operator
+          push :typeparam
+        end
+
+        rule /\s+/, Text
+        rule /{/, Operator, :pop!
+        rule /\(/, Operator, :pop!
+        rule %r(//.*?\n), Comment::Single, :pop!
+        rule %r(#{idrest}|#{op}+|`[^`]+`), Name::Class, :pop!
+      end
+
+      state :type do
+        rule /\s+/, Text
+        rule /<[%:]|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule /([,\);}]|=>|=)(\s*)/ do
+          groups Operator, Text
+          pop!
+        end
+        rule /[\(\{]/, Operator, :type
+
+        typechunk = /(?:#{idrest}|#{op}+\`[^`]+`)/
+        rule /(#{typechunk}(?:\.#{typechunk})*)(\s*)(\[)/ do
+          groups Keyword::Type, Text, Operator
+          pop!
+          push :typeparam
+        end
+
+        rule /(#{typechunk}(?:\.#{typechunk})*)(\s*)$/ do
+          groups Keyword::Type, Text
+          pop!
+        end
+
+        rule %r(//.*?\n), Comment::Single, :pop!
+        rule /\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
+      end
+
+      state :typeparam do
+        rule /[\s,]+/, Text
+        rule /<[%:]|=>|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule /([\]\)\}])/, Operator, :pop!
+        rule /[\(\[\{]/, Operator, :typeparam
+        rule /\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
+      end
+
+      state :comment do
+        rule %r([^/\*]+), Comment::Multiline
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r([*/]), Comment::Multiline
+      end
+
+      state :import do
+        rule %r((#{idrest}|\.)+), Name::Namespace, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/scheme.rb

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Scheme < RegexLexer
+      title "Scheme"
+      desc "The Scheme variant of Lisp"
+
+      tag 'scheme'
+      filenames '*.scm', '*.ss'
+      mimetypes 'text/x-scheme', 'application/x-scheme'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          lambda define if else cond and or case let let* letrec begin
+          do delay set! => quote quasiquote unquote unquote-splicing
+          define-syntax let-syntax letrec-syntax syntax-rules
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          * + - / < <= = > >= abs acos angle append apply asin
+          assoc assq assv atan boolean? caaaar caaadr caaar caadar
+          caaddr caadr caar cadaar cadadr cadar caddar cadddr caddr
+          cadr call-with-current-continuation call-with-input-file
+          call-with-output-file call-with-values call/cc car cdaaar cdaadr
+          cdaar cdadar cdaddr cdadr cdar cddaar cddadr cddar cdddar cddddr
+          cdddr cddr cdr ceiling char->integer char-alphabetic? char-ci<=?
+          char-ci<? char-ci=? char-ci>=? char-ci>? char-downcase
+          char-lower-case? char-numeric? char-ready? char-upcase
+          char-upper-case? char-whitespace? char<=? char<? char=? char>=?
+          char>? char? close-input-port close-output-port complex? cons
+          cos current-input-port current-output-port denominator
+          display dynamic-wind eof-object? eq?  equal? eqv? eval
+          even? exact->inexact exact? exp expt floor for-each force gcd
+          imag-part inexact->exact inexact? input-port? integer->char
+          integer? interaction-environment lcm length list list->string
+          list->vector list-ref list-tail list?  load log magnitude
+          make-polar make-rectangular make-string make-vector map
+          max member memq memv min modulo negative? newline not
+          null-environment null? number->string number? numerator odd?
+          open-input-file open-output-file output-port? pair?  peek-char
+          port? positive? procedure? quotient rational? rationalize
+          read read-char real-part real?  remainder reverse round
+          scheme-report-environment set-car! set-cdr! sin sqrt string
+          string->list string->number string->symbol string-append
+          string-ci<=?  string-ci<? string-ci=? string-ci>=? string-ci>?
+          string-copy string-fill! string-length string-ref
+          string-set! string<=? string<? string=? string>=?
+          string>? string? substring symbol->string symbol?
+          tan transcript-off transcript-on truncate values vector
+          vector->list vector-fill! vector-length vector-ref
+          vector-set! vector? with-input-from-file with-output-to-file
+          write write-char zero?
+        )
+      end
+
+      id = /[a-z0-9!$\%&*+,\/:<=>?@^_~|-]+/i
+
+      state :root do
+        # comments
+        rule /;.*$/, Comment::Single
+        rule /\s+/m, Text
+        rule /-?\d+\.\d+/, Num::Float
+        rule /-?\d+/, Num::Integer
+
+        # Racket infinitites
+        rule /[+-]inf[.][f0]/, Num
+
+        rule /#b[01]+/, Num::Bin
+        rule /#o[0-7]+/, Num::Oct
+        rule /#d[0-9]+/, Num::Integer
+        rule /#x[0-9a-f]+/i, Num::Hex
+        rule /#[ei][\d.]+/, Num::Other
+
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /'#{id}/i, Str::Symbol
+        rule /#\\([()\/'"._!\$%& ?=+-]{1}|[a-z0-9]+)/i,
+          Str::Char
+        rule /#t|#f/, Name::Constant
+        rule /(?:'|#|`|,@|,|\.)/, Operator
+
+        rule /(['#])(\s*)(\()/m do
+          groups Str::Symbol, Text, Punctuation
+        end
+
+        rule /\(/, Punctuation, :command
+        rule /\)/, Punctuation
+
+        rule id, Name::Variable
+      end
+
+      state :command do
+        rule id, Name::Function do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Function
+          end
+
+          pop!
+        end
+
+        rule(//) { pop! }
+      end
+
+    end
+  end
+end