rugments 1.0.0.beta1

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

@@ -0,0 +1,172 @@
+module Rugments
+  module Lexers
+    # shared states with SCSS
+    class SassCommon < RegexLexer
+      id = /[\w-]+/
+
+      state :content_common do
+        rule /@for\b/, Keyword, :for
+        rule /@(debug|warn|if|while)/, Keyword, :value
+        rule /(@mixin)(\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/rugments/lexers/sass.rb

@@ -0,0 +1,72 @@
+module Rugments
+  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/rugments/lexers/scala.rb

@@ -0,0 +1,140 @@
+module Rugments
+  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/rugments/lexers/scheme.rb

@@ -0,0 +1,109 @@
+module Rugments
+  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

data/lib/rugments/lexers/scss.rb

@@ -0,0 +1,32 @@
+module Rugments
+  module Lexers
+    load_const :SassCommon, 'sass/common.rb'
+
+    class Scss < SassCommon
+      title 'SCSS'
+      desc 'SCSS stylesheets (sass-lang.com)'
+      tag 'scss'
+      filenames '*.scss'
+      mimetypes 'text/x-scss'
+
+      state :root do
+        rule /\s+/, Text
+        rule %r{//.*?\n}, Comment::Single
+        rule %r{/[*].*?[*]/}m, Comment::Multiline
+        rule /@import\b/, Keyword, :value
+
+        mixin :content_common
+
+        rule(/(?=[^;{}][;}])/) { push :attribute }
+        rule(/(?=[^;{}:]+:[^a-z])/) { push :attribute }
+
+        rule(//) { push :selector }
+      end
+
+      state :end_section do
+        rule /\n/, Text
+        rule(/[;{}]/) { token Punctuation; reset_stack }
+      end
+    end
+  end
+end

data/lib/rugments/lexers/sed.rb

@@ -0,0 +1,167 @@
+module Rugments
+  module Lexers
+    class Sed < RegexLexer
+      title 'sed'
+      desc 'sed, the ultimate stream editor'
+
+      tag 'sed'
+      filenames '*.sed'
+      mimetypes 'text/x-sed'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'sed'
+      end
+
+      class Regex < RegexLexer
+        state :root do
+          rule /\\./, Str::Escape
+          rule /\[/, Punctuation, :brackets
+          rule /[$^.*]/, Operator
+          rule /[()]/, Punctuation
+          rule /./, Str::Regex
+        end
+
+        state :brackets do
+          rule /\^?/ do
+            token Punctuation
+            goto :brackets_int
+          end
+        end
+
+        state :brackets_int do
+          # ranges
+          rule /.-./, Name::Variable
+          rule /\]/, Punctuation, :pop!
+          rule /./, Str::Regex
+        end
+      end
+
+      class Replacement < RegexLexer
+        state :root do
+          rule /\\./m, Str::Escape
+          rule /&/, Operator
+          rule /[^\\&]+/m, Text
+        end
+      end
+
+      def regex
+        @regex ||= Regex.new(options)
+      end
+
+      def replacement
+        @replacement ||= Replacement.new(options)
+      end
+
+      start { regex.reset!; replacement.reset! }
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule(/#.*?\n/) { token Comment; reset_stack }
+        rule(/\n/) { token Text; reset_stack }
+        rule(/;/) { token Punctuation; reset_stack }
+      end
+
+      state :root do
+        mixin :addr_range
+      end
+
+      edot = /\\.|./m
+
+      state :command do
+        mixin :whitespace
+
+        # subst and transliteration
+        rule /(s)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
+          token Keyword, m[1]
+          token Punctuation, m[2]
+          delegate regex, m[3]
+          token Punctuation, m[4]
+          delegate replacement, m[5]
+          token Punctuation, m[6]
+
+          goto :flags
+        end
+
+        rule /(y)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
+          token Keyword, m[1]
+          token Punctuation, m[2]
+          delegate replacement, m[3]
+          token Punctuation, m[4]
+          delegate replacement, m[5]
+          token Punctuation, m[6]
+
+          pop!
+        end
+
+        # commands that take a text segment as an argument
+        rule /([aic])(\s*)/ do
+          groups Keyword, Text; goto :text
+        end
+
+        rule /[pd]/, Keyword
+
+        # commands that take a number argument
+        rule /([qQl])(\s+)(\d+)/i do
+          groups Keyword, Text, Num
+          pop!
+        end
+
+        # no-argument commands
+        rule /[={}dDgGhHlnpPqx]/, Keyword, :pop!
+
+        # commands that take a filename argument
+        rule /([rRwW])(\s+)(\S+)/ do
+          groups Keyword, Text, Name
+          pop!
+        end
+
+        # commands that take a label argument
+        rule /([:btT])(\s+)(\S+)/ do
+          groups Keyword, Text, Name::Label
+          pop!
+        end
+      end
+
+      state :addr_range do
+        mixin :whitespace
+
+        ### address ranges ###
+        addr_tok = Keyword::Namespace
+        rule /\d+/, addr_tok
+        rule /[$,~+!]/, addr_tok
+
+        rule %r{(/)(\\.|.)*?(/)} do |m|
+          token addr_tok, m[1]; delegate regex, m[2]; token addr_tok, m[3]
+        end
+
+        # alternate regex rage delimiters
+        rule %r{(\\)(.)(\\.|.)*?(\2)} do |m|
+          token addr_tok, m[1] + m[2]
+          delegate regex, m[3]
+          token addr_tok, m[4]
+        end
+
+        rule(//) { push :command }
+      end
+
+      state :text do
+        rule /[^\\\n]+/, Str
+        rule /\\\n/, Str::Escape
+        rule /\\/, Str
+        rule /\n/, Text, :pop!
+      end
+
+      state :flags do
+        rule /[gp]+/, Keyword, :pop!
+
+        # writing to a file with the subst command.
+        # who'da thunk...?
+        rule /([wW])(\s+)(\S+)/ do
+          token Keyword; token Text; token Name
+        end
+
+        rule(//) { pop! }
+      end
+    end
+  end
+end