rouge 3.18.0

data/lib/rouge/lexers/sass.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer '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 %r/[ \t]*\n/, Text
+        rule(/[ \t]*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        # block comments
+        rule %r(//.*?$) do
+          token Comment::Single
+          pop!; starts_block :single_comment
+        end
+
+        rule %r(/[*].*?\n) do
+          token Comment::Multiline
+          pop!; starts_block :multi_comment
+        end
+
+        rule %r/@import\b/, Keyword, :import
+
+        mixin :content_common
+
+        rule %r(=#{id}), Name::Function, :value
+        rule %r([+]#{id}), Name::Decorator, :value
+
+        rule %r/:/, Name::Attribute, :old_style_attr
+
+        rule(/(?=[^\[\n]+?:([^a-z]|$))/) { push :attribute }
+
+        rule(//) { push :selector }
+      end
+
+      state :single_comment do
+        rule %r/.*?$/, Comment::Single, :pop!
+      end
+
+      state :multi_comment do
+        rule %r/.*?\n/, Comment::Multiline, :pop!
+      end
+
+      state :import do
+        rule %r/[ \t]+/, Text
+        rule %r/\S+/, Str
+        rule %r/\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,181 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # shared states with SCSS
+    class SassCommon < RegexLexer
+      id = /[\w-]+/
+
+      state :content_common do
+        rule %r/@for\b/, Keyword, :for
+        rule %r/@(debug|warn|if|each|while|else|return|media)/, Keyword, :value
+
+        rule %r/(@mixin)(\s+)(#{id})/ do
+          groups Keyword, Text, Name::Function
+          push :value
+        end
+
+        rule %r/(@function)(\s+)(#{id})/ do
+          groups Keyword, Text, Name::Function
+          push :value
+        end
+
+        rule %r/@extend\b/, Keyword, :selector
+
+        rule %r/(@include)(\s+)(#{id})/ do
+          groups Keyword, Text, Name::Decorator
+          push :value
+        end
+
+        rule %r/@#{id}/, Keyword, :selector
+
+        # $variable: assignment
+        rule %r/([$]#{id})([ \t]*)(:)/ do
+          groups Name::Variable, Text, Punctuation
+          push :value
+        end
+      end
+
+      state :value do
+        mixin :end_section
+        rule %r/[ \t]+/, Text
+        rule %r/[$]#{id}/, Name::Variable
+        rule %r/url[(]/, Str::Other, :string_url
+        rule %r/#{id}(?=\s*[(])/, Name::Function
+        rule %r/%#{id}/, Name::Decorator
+
+        # named literals
+        rule %r/(true|false)\b/, Name::Builtin::Pseudo
+        rule %r/(and|or|not)\b/, Operator::Word
+
+        # colors and numbers
+        rule %r/#[a-z0-9]{1,6}/i, Num::Hex
+        rule %r/-?\d+(%|[a-z]+)?/, Num
+        rule %r/-?\d*\.\d+(%|[a-z]+)?/, Num::Integer
+
+        mixin :has_strings
+        mixin :has_interp
+
+        rule %r/[~^*!&%<>\|+=@:,.\/?-]+/, Operator
+        rule %r/[\[\]()]+/, 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 %r/[#][{]/, Str::Interpol, :interpolation
+      end
+
+      state :has_strings do
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
+      end
+
+      state :interpolation do
+        rule %r/}/, Str::Interpol, :pop!
+        mixin :value
+      end
+
+      state :selector do
+        mixin :end_section
+
+        mixin :has_strings
+        mixin :has_interp
+        rule %r/[ \t]+/, Text
+        rule %r/:/, Name::Decorator, :pseudo_class
+        rule %r/[.]/, Name::Class, :class
+        rule %r/#/, Name::Namespace, :id
+        rule %r/%/, Name::Variable, :placeholder
+        rule id, Name::Tag
+        rule %r/&/, Keyword
+        rule %r/[~^*!&\[\]()<>\|+=@:;,.\/?-]/, Operator
+      end
+
+      state :dq do
+        rule %r/"/, Str::Double, :pop!
+        mixin :has_interp
+        rule %r/(\\.|#(?![{])|[^\n"#])+/, Str::Double
+      end
+
+      state :sq do
+        rule %r/'/, Str::Single, :pop!
+        mixin :has_interp
+        rule %r/(\\.|#(?![{])|[^\n'#])+/, Str::Single
+      end
+
+      state :string_url do
+        rule %r/[)]/, Str::Other, :pop!
+        rule %r/(\\.|#(?![{])|[^\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 %r/(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 %r/([ \t]*)(:)/ do
+          groups Text, Punctuation
+          push :value
+        end
+      end
+
+      state :inline_comment do
+        rule %r/(\\#|#(?=[^\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,169 @@
+# -*- coding: utf-8 #
+# frozen_string_literal: true
+
+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 %r/(class|trait|object)(\s+)/ do
+          groups Keyword, Text
+          push :class
+        end
+        rule %r/'#{idrest}(?!')/, Str::Symbol
+        rule %r/[^\S\n]+/, Text
+
+        rule %r(//.*), Comment::Single
+        rule %r(/\*), Comment::Multiline, :comment
+
+        rule %r/@#{idrest}/, Name::Decorator
+
+        rule %r/(def)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+          groups Keyword, Text, Name::Function, Text
+        end
+
+        rule %r/(val)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+          groups Keyword, Text, Name::Variable, Text
+        end
+
+        rule %r/(this)(\n*)(\.)(#{idrest})/ do
+          groups Keyword, Text, Operator, Name::Property
+        end
+
+        rule %r/(#{idrest}|_)(\n*)(\.)(#{idrest})/ do
+          groups Name::Variable, Text, Operator, Name::Property
+        end
+
+        rule %r/#{upper}#{idrest}\b/, Name::Class
+
+        rule %r/(#{idrest})(#{whitespace}*)(\()/ do
+          groups Name::Function, Text, Operator
+        end
+
+        rule %r/(\.)(#{idrest})/ do
+          groups Operator, Name::Property
+        end
+
+        rule %r(
+          (#{keywords.join("|")})\b|
+          (<[%:-]|=>|>:|[#=@_\u21D2\u2190])(\b|(?=\s)|$)
+        )x, Keyword
+        rule %r/:(?!#{op})/, Keyword, :type
+        rule %r/(true|false|null)\b/, Keyword::Constant
+        rule %r/(import|package)(\s+)/ do
+          groups Keyword, Text
+          push :import
+        end
+
+        rule %r/(type)(\s+)/ do
+          groups Keyword, Text
+          push :type
+        end
+
+        rule %r/""".*?"""(?!")/m, Str
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'/, Str::Char
+
+        rule idrest, Name
+        rule %r/`[^`]+`/, Name
+
+        rule %r/\[/, Operator, :typeparam
+        rule %r/[\(\)\{\};,.#]/, Operator
+        rule %r/#{op}+/, Operator
+
+        rule %r/([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?/, Num::Float
+        rule %r/([0-9][0-9]*[fFdD])/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/[0-9]+L?/, Num::Integer
+        rule %r/\n/, Text
+      end
+
+      state :class do
+        rule %r/(#{idrest}|#{op}+|`[^`]+`)(\s*)(\[)/ do
+          groups Name::Class, Text, Operator
+          push :typeparam
+        end
+
+        rule %r/\s+/, Text
+        rule %r/{/, Operator, :pop!
+        rule %r/\(/, Operator, :pop!
+        rule %r(//.*), Comment::Single, :pop!
+        rule %r(#{idrest}|#{op}+|`[^`]+`), Name::Class, :pop!
+      end
+
+      state :type do
+        rule %r/\s+/, Text
+        rule %r/<[%:]|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule %r/([,\);}]|=>|=)(\s*)/ do
+          groups Operator, Text
+          pop!
+        end
+        rule %r/[\(\{]/, Operator, :type
+
+        typechunk = /(?:#{idrest}|#{op}+\`[^`]+`)/
+        rule %r/(#{typechunk}(?:\.#{typechunk})*)(\s*)(\[)/ do
+          groups Keyword::Type, Text, Operator
+          pop!
+          push :typeparam
+        end
+
+        rule %r/(#{typechunk}(?:\.#{typechunk})*)(\s*)$/ do
+          groups Keyword::Type, Text
+          pop!
+        end
+
+        rule %r(//.*), Comment::Single, :pop!
+        rule %r/\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
+      end
+
+      state :typeparam do
+        rule %r/[\s,]+/, Text
+        rule %r/<[%:]|=>|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule %r/([\]\)\}])/, Operator, :pop!
+        rule %r/[\(\[\{]/, Operator, :typeparam
+        rule %r/\.|#{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,113 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+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 %r/;.*$/, Comment::Single
+        rule %r/\s+/m, Text
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
+
+        # Racket infinitites
+        rule %r/[+-]inf[.][f0]/, Num
+
+        rule %r/#b[01]+/, Num::Bin
+        rule %r/#o[0-7]+/, Num::Oct
+        rule %r/#d[0-9]+/, Num::Integer
+        rule %r/#x[0-9a-f]+/i, Num::Hex
+        rule %r/#[ei][\d.]+/, Num::Other
+
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/'#{id}/i, Str::Symbol
+        rule %r/#\\([()\/'"._!\$%& ?=+-]{1}|[a-z0-9]+)/i,
+          Str::Char
+        rule %r/#t|#f/, Name::Constant
+        rule %r/(?:'|#|`|,@|,|\.)/, Operator
+
+        rule %r/(['#])(\s*)(\()/m do
+          groups Str::Symbol, Text, Punctuation
+        end
+
+        rule %r/\(|\[/, Punctuation, :command
+        rule %r/\)|\]/, 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