rougegal 2.1.2

data/lib/rouge/lexers/slim.rb

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    # A lexer for the Slim tempalte language
+    # @see http://slim-lang.org
+    class Slim < RegexLexer
+      include Indentation
+
+      title "Slim"
+      desc 'The Slim template language'
+
+      tag 'slim'
+
+      filenames '*.slim'
+
+      # Ruby identifier characters
+      ruby_chars = /[\w\!\?\@\$]/
+
+      # Since you are allowed to wrap lines with a backslash, include \\\n in characters
+      dot = /(\\\n|.)/
+
+      def ruby
+        @ruby ||= Ruby.new(options)
+      end
+
+      def html
+        @html ||= HTML.new(options)
+      end
+
+      def filters
+        @filters ||= {
+          'ruby' => ruby,
+          'erb' => ERB.new(options),
+          'javascript' => Javascript.new(options),
+          'css' => CSS.new(options),
+          'coffee' => Coffeescript.new(options),
+          'markdown' => Markdown.new(options),
+          'scss' => Scss.new(options),
+          'sass' => Sass.new(options)
+        }
+      end
+
+      start { ruby.reset!; html.reset! }
+
+      state :root do
+        rule /\s*\n/, Text
+        rule(/\s*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        mixin :css
+
+        rule /\/#{dot}*/, Comment, :indented_block
+
+        rule /(doctype)(\s+)(.*)/ do
+          groups Name::Namespace, Text::Whitespace, Text
+          pop!
+        end
+
+        # filters, shamelessly ripped from HAML
+        rule /(\w*):\s*\n/ do |m|
+          token Name::Decorator
+          pop!
+          starts_block :filter_block
+
+          filter_name = m[1].strip
+
+          @filter_lexer = self.filters[filter_name]
+          @filter_lexer.reset! unless @filter_lexer.nil?
+
+          puts "    slim: filter #{filter_name.inspect} #{@filter_lexer.inspect}" if @debug
+        end
+
+        # Text
+        rule %r([\|'](?=\s)) do
+          token Punctuation
+          pop!
+          starts_block :plain_block
+          goto :plain_block
+        end
+
+        rule /-|==|=/, Punctuation, :ruby_line
+
+        # Dynamic tags
+        rule /(\*)(#{ruby_chars}+\(.*?\))/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        #rule /<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
+        rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
+          delegate html, m[1]
+          pop!
+        end
+
+        # Ordinary slim tags
+        rule /\w+/, Name::Tag, :tag
+
+      end
+
+      state :tag do
+        mixin :css
+        mixin :indented_block
+        mixin :interpolation
+
+        # Whitespace control
+        rule /[<>]/, Punctuation
+
+        # Trim whitespace
+        rule /\s+?/, Text::Whitespace
+
+        # Splats, these two might be mergable?
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        rule /(\*)(\{#{dot}+?\})/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        # Attributes
+        rule /([\w\-]+)(\s*)(\=)/ do |m|
+          token Name::Attribute, m[1]
+          token Text::Whitespace, m[2]
+          token Punctuation, m[3]
+          push :html_attr
+        end
+
+        # Ruby value
+        rule /(\=)(#{dot}+)/ do |m|
+          token Punctuation, m[1]
+          #token Keyword::Constant, m[2]
+          delegate ruby, m[2]
+        end
+
+        # HTML Entities
+        rule(/&\S*?;/, Name::Entity)
+
+        rule /#{dot}+?/, Text
+
+        rule /\s*\n/, Text::Whitespace, :pop!
+      end
+
+      state :css do
+        rule(/\.[\w-]*/) { token Name::Class; goto :tag }
+        rule(/#[a-zA-Z][\w:-]*/) { token Name::Function; goto :tag }
+      end
+
+      state :html_attr do
+        # Strings, double/single quoted
+        rule(/\s*(['"])#{dot}*?\1/, Literal::String, :pop!)
+
+        # Ruby stuff
+        rule(/(#{ruby_chars}+\(.*?\))/) { |m| delegate ruby, m[1]; pop! }
+        rule(/(#{ruby_chars}+)/) { |m| delegate ruby, m[1]; pop! }
+
+        rule /\s+/, Text::Whitespace
+      end
+
+      state :ruby_line do
+        # Need at top
+        mixin :indented_block
+
+        rule(/,\s*\n/) { delegate ruby }
+        rule /[ ]\|[ \t]*\n/, Str::Escape
+        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+      end
+
+      state :filter_block do
+        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+          if @filter_lexer
+            delegate @filter_lexer
+          else
+            token Name::Decorator
+          end
+        end
+
+        mixin :interpolation
+        mixin :indented_block
+      end
+
+      state :plain_block do
+        mixin :interpolation
+
+        rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
+          delegate html, m[1]
+        end
+
+        # HTML Entities
+        rule(/&\S*?;/, Name::Entity)
+
+        #rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule /#{dot}+?/, Text
+
+        mixin :indented_block
+      end
+
+      state :interpolation do
+        rule /#[{]/, Str::Interpol, :ruby_interp
+      end
+
+      state :ruby_interp do
+        rule /[}]/, Str::Interpol, :pop!
+        mixin :ruby_interp_inner
+      end
+
+      state :ruby_interp_inner do
+        rule(/[{]/) { delegate ruby; push :ruby_interp_inner }
+        rule(/[}]/) { delegate ruby; pop! }
+        rule(/[^{}]+/) { delegate ruby }
+      end
+
+      state :indented_block do
+        rule(/(?<!\\)\n/) { token Text; reset_stack }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/smalltalk.rb

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Smalltalk < RegexLexer
+      title "Smalltalk"
+      desc 'The Smalltalk programming language'
+
+      tag 'smalltalk'
+      aliases 'st', 'squeak'
+      filenames '*.st'
+      mimetypes 'text/x-smalltalk'
+
+      ops = %r([-+*/\\~<>=|&!?,@%])
+
+      state :root do
+        rule /(<)(\w+:)(.*?)(>)/ do
+          groups Punctuation, Keyword, Text, Punctuation
+        end
+
+        # mixin :squeak_fileout
+        mixin :whitespaces
+        mixin :method_definition
+        rule /([|])([\w\s]*)([|])/ do
+          groups Punctuation, Name::Variable, Punctuation
+        end
+        mixin :objects
+        rule /\^|:=|_/, Operator
+
+        rule /[)}\]]/, Punctuation, :after_object
+        rule /[({\[!]/, Punctuation
+      end
+
+      state :method_definition do
+        rule /([a-z]\w*:)(\s*)(\w+)/i do
+          groups Name::Function, Text, Name::Variable
+        end
+
+        rule /^(\s*)(\b[a-z]\w*\b)(\s*)$/i do
+          groups Text, Name::Function, Text
+        end
+
+        rule %r(^(\s*)(#{ops}+)(\s*)(\w+)(\s*)$) do
+          groups Text, Name::Function, Text, Name::Variable, Text
+        end
+      end
+
+      state :block_variables do
+        mixin :whitespaces
+        rule /(:)(\s*)(\w+)/ do
+          groups Operator, Text, Name::Variable
+        end
+
+        rule /[|]/, Punctuation, :pop!
+
+        rule(//) { pop! }
+      end
+
+      state :literals do
+        rule /'(''|.)*?'/m, Str, :after_object
+        rule /[$]./, Str::Char, :after_object
+        rule /#[(]/, Str::Symbol, :parenth
+        rule /(\d+r)?-?\d+(\.\d+)?(e-?\d+)?/,
+          Num, :after_object
+        rule /#("[^"]*"|#{ops}+|[\w:]+)/,
+          Str::Symbol, :after_object
+      end
+
+      state :parenth do
+        rule /[)]/ do
+          token Str::Symbol
+          goto :after_object
+        end
+
+        mixin :inner_parenth
+      end
+
+      state :inner_parenth do
+        rule /#[(]/, Str::Symbol, :inner_parenth
+        rule /[)]/, Str::Symbol, :pop!
+        mixin :whitespaces
+        mixin :literals
+        rule /(#{ops}|[\w:])+/, Str::Symbol
+      end
+
+      state :whitespaces do
+        rule /! !$/, Keyword # squeak chunk delimiter
+        rule /\s+/m, Text
+        rule /".*?"/m, Comment
+      end
+
+      state :objects do
+        rule /\[/, Punctuation, :block_variables
+        rule /(self|super|true|false|nil|thisContext)\b/,
+          Name::Builtin::Pseudo, :after_object
+        rule /[A-Z]\w*(?!:)\b/, Name::Class, :after_object
+        rule /[a-z]\w*(?!:)\b/, Name::Variable, :after_object
+        mixin :literals
+      end
+
+      state :after_object do
+        mixin :whitespaces
+        rule /(ifTrue|ifFalse|whileTrue|whileFalse|timesRepeat):/,
+          Name::Builtin, :pop!
+        rule /new(?!:)\b/, Name::Builtin
+        rule /:=|_/, Operator, :pop!
+        rule /[a-z]+\w*:/i, Name::Function, :pop!
+        rule /[a-z]+\w*/i, Name::Function
+        rule /#{ops}+/, Name::Function, :pop!
+        rule /[.]/, Punctuation, :pop!
+        rule /;/, Punctuation
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/smarty.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Smarty < TemplateLexer
+      title "Smarty"
+      desc 'Smarty Template Engine'
+      tag 'smarty'
+      aliases 'smarty'
+      filenames '*.tpl', '*.smarty'
+      mimetypes 'application/x-smarty', 'text/x-smarty'
+
+      def self.analyze_text(text)
+        rv = 0.0
+        rv += 0.15 if text =~ /\{if\s+.*?\}.*?\{\/if\}/
+        rv += 0.15 if text =~ /\{include\s+file=.*?\}/
+        rv += 0.15 if text =~ /\{foreach\s+.*?\}.*?\{\/foreach\}/
+        rv += 0.01 if text =~ /\{\$.*?\}/
+        return rv
+      end
+
+
+
+      def self.builtins
+        @builtins ||= %w(
+          append assign block call capture config_load debug extends
+          for foreach foreachelse break continue function if elseif
+          else include include_php insert ldelim rdelim literal nocache
+          php section sectionelse setfilter strip while
+          counter cycle eval fetch html_checkboxes html_image html_options
+          html_radios html_select_date html_select_time html_table
+          mailto math textformat
+          capitalize cat count_characters count_paragraphs
+          count_sentences count_words date_format default escape
+          from_charset indent lower nl2br regex_replace replace spacify
+          string_format strip strip_tags to_charset truncate unescape
+          upper wordwrap
+        )
+      end
+
+
+      state :root do
+        rule(/\{\s+/) { delegate parent }
+
+        # block comments
+        rule /\{\*.*?\*\}/m, Comment
+
+        rule /\{\/?(?![\s*])/ do
+          token Keyword
+          push :smarty
+        end
+
+
+        rule(/.*?(?={[\/a-zA-Z0-9$#*"'])|.*/m) { delegate parent }
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :comment do
+        rule(/{\*/) { token Comment; push }
+        rule(/\*}/) { token Comment; pop! }
+        rule(/[^{}]+/m) { token Comment }
+      end
+
+      state :smarty do
+        # allow nested tags
+        rule /\{\/?(?![\s*])/ do
+          token Keyword
+          push :smarty
+        end
+
+        rule /}/, Keyword, :pop!
+        rule /\s+/m, Text
+        rule %r([~!%^&*()+=|\[\]:;,.<>/@?-]), Operator
+        rule /#[a-zA-Z_]\w*#/, Name::Variable
+        rule /\$[a-zA-Z_]\w*(\.\w+)*/, Name::Variable
+        rule /(true|false|null)\b/, Keyword::Constant
+	rule /[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?/, Num
+	rule /"(\\.|.)*?"/, Str::Double
+        rule /'(\\.|.)*?'/, Str::Single
+	rule /([a-zA-Z_]\w*)/ do |m|
+	  if self.class.builtins.include? m[0]
+	    token Name::Builtin
+	  else
+	    token Name::Attribute
+	  end
+	end
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/sml.rb

@@ -0,0 +1,348 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class SML < RegexLexer
+      title "SML"
+      desc 'Standard ML'
+      tag 'sml'
+      aliases 'ml'
+      filenames '*.sml', '*.sig', '*.fun'
+
+      mimetypes 'text/x-standardml', 'application/x-standardml'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abstype and andalso as case datatype do else end exception
+          fn fun handle if in infix infixr let local nonfix of op open
+          orelse raise rec then type val with withtype while
+          eqtype functor include sharing sig signature struct structure
+          where
+        )
+      end
+
+      def self.symbolic_reserved
+        @symbolic_reserved ||= Set.new %w(: | = => -> # :>)
+      end
+
+      id = /[\w']+/i
+      symbol = %r([!%&$#/:<=>?@\\~`^|*+-]+)
+
+      def self.analyze_text(text)
+        return 0
+      end
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule /[(][*]/, Comment, :comment
+      end
+
+      state :delimiters do
+        rule /[(\[{]/, Punctuation, :main
+        rule /[)\]}]/, Punctuation, :pop!
+
+        rule /\b(let|if|local)\b(?!')/ do
+          token Keyword::Reserved
+          push; push
+        end
+
+        rule /\b(struct|sig|while)\b(?!')/ do
+          token Keyword::Reserved
+          push
+        end
+
+        rule /\b(do|else|end|in|then)\b(?!')/, Keyword::Reserved, :pop!
+      end
+
+      def token_for_id_with_dot(id)
+        if self.class.keywords.include? id
+          Error
+        else
+          Name::Namespace
+        end
+      end
+
+      def token_for_final_id(id)
+        if self.class.keywords.include? id or self.class.symbolic_reserved.include? id
+          Error
+        else
+          Name
+        end
+      end
+
+      def token_for_id(id)
+        if self.class.keywords.include? id
+          Keyword::Reserved
+        elsif self.class.symbolic_reserved.include? id
+          Punctuation
+        else
+          Name
+        end
+      end
+
+      state :core do
+        rule /[()\[\]{},;_]|[.][.][.]/, Punctuation
+        rule /#"/, Str::Char, :char
+        rule /"/, Str::Double, :string
+        rule /~?0x[0-9a-fA-F]+/, Num::Hex
+        rule /0wx[0-9a-fA-F]+/, Num::Hex
+        rule /0w\d+/, Num::Integer
+        rule /~?\d+([.]\d+)?[eE]~?\d+/, Num::Float
+        rule /~?\d+[.]\d+/, Num::Float
+        rule /~?\d+/, Num::Integer
+
+        rule /#\s*[1-9][0-9]*/, Name::Label
+        rule /#\s*#{id}/, Name::Label
+        rule /#\s+#{symbol}/, Name::Label
+
+        rule /\b(datatype|abstype)\b(?!')/, Keyword::Reserved, :dname
+        rule(/(?=\bexception\b(?!'))/) { push :ename }
+        rule /\b(functor|include|open|signature|structure)\b(?!')/,
+          Keyword::Reserved, :sname
+        rule /\b(type|eqtype)\b(?!')/, Keyword::Reserved, :tname
+
+        rule /'#{id}/, Name::Decorator
+        rule /(#{id})([.])/ do |m|
+          groups(token_for_id_with_dot(m[1]), Punctuation)
+          push :dotted
+        end
+
+        rule id do |m|
+          token token_for_id(m[0])
+        end
+
+        rule symbol do |m|
+          token token_for_id(m[0])
+        end
+      end
+
+      state :dotted do
+        rule /(#{id})([.])/ do |m|
+          groups(token_for_id_with_dot(m[1]), Punctuation)
+        end
+
+        rule id do |m|
+          token token_for_id(m[0])
+          pop!
+        end
+
+        rule symbol do |m|
+          token token_for_id(m[0])
+          pop!
+        end
+      end
+
+      state :root do
+        rule /#!.*?\n/, Comment::Preproc
+        rule(//) { push :main }
+      end
+
+      state :main do
+        mixin :whitespace
+
+        rule /\b(val|and)\b(?!')/, Keyword::Reserved, :vname
+        rule /\b(fun)\b(?!')/ do
+          token Keyword::Reserved
+          goto :main_fun
+          push :fname
+        end
+
+        mixin :delimiters
+        mixin :core
+      end
+
+      state :main_fun do
+        mixin :whitespace
+        rule /\b(fun|and)\b(?!')/, Keyword::Reserved, :fname
+        rule /\bval\b(?!')/ do
+          token Keyword::Reserved
+          goto :main
+          push :vname
+        end
+
+        rule /[|]/, Punctuation, :fname
+        rule /\b(case|handle)\b(?!')/ do
+          token Keyword::Reserved
+          goto :main
+        end
+
+        mixin :delimiters
+        mixin :core
+      end
+
+      state :has_escapes do
+        rule /\\[\\"abtnvfr]/, Str::Escape
+        rule /\\\^[\x40-\x5e]/, Str::Escape
+        rule /\\[0-9]{3}/, Str::Escape
+        rule /\\u\h{4}/, Str::Escape
+        rule /\\\s+\\/, Str::Interpol
+      end
+
+      state :string do
+        rule /[^"\\]+/, Str::Double
+        rule /"/, Str::Double, :pop!
+        mixin :has_escapes
+      end
+
+      state :char do
+        rule /[^"\\]+/, Str::Char
+        rule /"/, Str::Char, :pop!
+        mixin :has_escapes
+      end
+
+      state :breakout do
+        rule /(?=\b(#{SML.keywords.to_a.join('|')})\b(?!'))/ do
+          pop!
+        end
+      end
+
+      state :sname do
+        mixin :whitespace
+        mixin :breakout
+        rule id, Name::Namespace
+        rule(//) { pop! }
+      end
+
+      state :has_annotations do
+        rule /'[\w']*/, Name::Decorator
+        rule /[(]/, Punctuation, :tyvarseq
+      end
+
+      state :fname do
+        mixin :whitespace
+        mixin :has_annotations
+
+        rule id, Name::Function, :pop!
+        rule symbol, Name::Function, :pop!
+      end
+
+      state :vname do
+        mixin :whitespace
+        mixin :has_annotations
+
+        rule /(#{id})(\s*)(=(?!#{symbol}))/m do
+          groups Name::Variable, Text, Punctuation
+          pop!
+        end
+
+        rule /(#{symbol})(\s*)(=(?!#{symbol}))/m do
+          groups Name::Variable, Text, Punctuation
+        end
+
+        rule id, Name::Variable, :pop!
+        rule symbol, Name::Variable, :pop!
+
+        rule(//) { pop! }
+      end
+
+      state :tname do
+        mixin :whitespace
+        mixin :breakout
+        mixin :has_annotations
+
+        rule /'[\w']*/, Name::Decorator
+        rule /[(]/, Punctuation, :tyvarseq
+
+        rule %r(=(?!#{symbol})) do
+          token Punctuation
+          goto :typbind
+        end
+
+        rule id, Keyword::Type
+        rule symbol, Keyword::Type
+      end
+
+      state :typbind do
+        mixin :whitespace
+
+        rule /\b(and)\b(?!')/ do
+          token Keyword::Reserved
+          goto :tname
+        end
+
+        mixin :breakout
+        mixin :core
+      end
+
+      state :dname do
+        mixin :whitespace
+        mixin :breakout
+        mixin :has_annotations
+
+        rule /(=)(\s*)(datatype)\b/ do
+          groups Punctuation, Text, Keyword::Reserved
+          pop!
+        end
+
+        rule %r(=(?!#{symbol})) do
+          token Punctuation
+          goto :datbind
+          push :datcon
+        end
+
+        rule id, Keyword::Type
+        rule symbol, Keyword::Type
+      end
+
+      state :datbind do
+        mixin :whitespace
+        rule /\b(and)\b(?!')/ do
+          token Keyword::Reserved; goto :dname
+        end
+        rule /\b(withtype)\b(?!')/ do
+          token Keyword::Reserved; goto :tname
+        end
+        rule /\bof\b(?!')/, Keyword::Reserved
+        rule /([|])(\s*)(#{id})/ do
+          groups(Punctuation, Text, Name::Class)
+        end
+
+        rule /([|])(\s+)(#{symbol})/ do
+          groups(Punctuation, Text, Name::Class)
+        end
+
+        mixin :breakout
+        mixin :core
+      end
+
+      state :ename do
+        mixin :whitespace
+        rule /(exception|and)(\s+)(#{id})/ do
+          groups Keyword::Reserved, Text, Name::Class
+        end
+
+        rule /(exception|and)(\s*)(#{symbol})/ do
+          groups Keyword::Reserved, Text, Name::Class
+        end
+
+        rule /\b(of)\b(?!')/, Keyword::Reserved
+        mixin :breakout
+        mixin :core
+      end
+
+      state :datcon do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+        rule symbol, Name::Class, :pop!
+      end
+
+      state :tyvarseq do
+        mixin :whitespace
+        rule /'[\w']*/, Name::Decorator
+        rule id, Name
+        rule /,/, Punctuation
+        rule /[)]/, Punctuation, :pop!
+        rule symbol, Name
+      end
+
+      state :comment do
+        rule /[^(*)]+/, Comment::Multiline
+        rule /[(][*]/ do
+          token Comment::Multiline; push
+        end
+        rule /[*][)]/, Comment::Multiline, :pop!
+        rule /[(*)]/, Comment::Multiline
+      end
+    end
+  end
+end