rouge 3.18.0

data/lib/rouge/lexers/haml.rb

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # A lexer for the Haml templating system for Ruby.
+    # @see http://haml.info
+    class Haml < RegexLexer
+      include Indentation
+
+      title "Haml"
+      desc "The Haml templating system for Ruby (haml.info)"
+
+      tag 'haml'
+      aliases 'HAML'
+
+      filenames '*.haml'
+      mimetypes 'text/x-haml'
+
+      option 'filters[filter_name]', 'Mapping of lexers to use for haml :filters'
+      attr_reader :filters
+      # @option opts :filters
+      #   A hash of filter name to lexer of how various filters should be
+      #   highlighted.  By default, :javascript, :css, :ruby, and :erb
+      #   are supported.
+      def initialize(opts={})
+        super
+
+        default_filters = {
+          'javascript' => Javascript.new(options),
+          'css' => CSS.new(options),
+          'ruby' => ruby,
+          'erb' => ERB.new(options),
+          'markdown' => Markdown.new(options),
+          'sass' => Sass.new(options),
+          # TODO
+          # 'textile' => Textile.new(options),
+          # 'maruku' => Maruku.new(options),
+        }
+
+        @filters = hash_option(:filters, default_filters) do |v|
+          as_lexer(v) || PlainText.new(@options)
+        end
+      end
+
+      def ruby
+        @ruby ||= Ruby.new(@options)
+      end
+
+      def html
+        @html ||= HTML.new(@options)
+      end
+
+      def ruby!(state)
+        ruby.reset!
+        push state
+      end
+
+      start { ruby.reset!; html.reset! }
+
+      identifier = /[\w:-]+/
+      ruby_var = /[a-z]\w*/
+
+      # Haml can include " |\n" anywhere,
+      # which is ignored and used to wrap long lines.
+      # To accomodate this, use this custom faux dot instead.
+      dot = /[ ]\|\n(?=.*[ ]\|)|./
+
+      state :root do
+        rule %r/\s*\n/, Text
+        rule(/\s*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        mixin :css
+        rule(/%#{identifier}/) { token Name::Tag; goto :tag }
+        rule %r/!!!#{dot}*\n/, Name::Namespace, :pop!
+        rule %r(
+          (/) (\[#{dot}*?\]) (#{dot}*\n)
+        )x do
+          groups Comment, Comment::Special, Comment
+          pop!
+        end
+
+        rule %r(/#{dot}*\n) do
+          token Comment
+          pop!
+          starts_block :html_comment_block
+        end
+
+        rule %r/-##{dot}*\n/ do
+          token Comment
+          pop!
+          starts_block :haml_comment_block
+        end
+
+        rule %r/-/ do
+          token Punctuation
+          reset_stack
+          ruby! :ruby_line
+        end
+
+        # filters
+        rule %r/:(#{dot}*)\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 "    haml: filter #{filter_name.inspect} #{@filter_lexer.inspect}" if @debug
+        end
+
+        mixin :eval_or_plain
+      end
+
+      state :css do
+        rule(/\.#{identifier}/) { token Name::Class; goto :tag }
+        rule(/##{identifier}/) { token Name::Function; goto :tag }
+      end
+
+      state :tag do
+        mixin :css
+        rule(/[{]/) { token Punctuation; ruby! :ruby_tag }
+        rule(/\[#{dot}*?\]/) { delegate ruby }
+
+        rule %r/\(/, Punctuation, :html_attributes
+        rule %r/\s*\n/, Text, :pop!
+
+        # whitespace chompers
+        rule %r/[<>]{1,2}(?=[ \t=])/, Punctuation
+
+        mixin :eval_or_plain
+      end
+
+      state :plain do
+        rule(/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/) { delegate html }
+        mixin :interpolation
+        rule(/\n/) { token Text; reset_stack }
+      end
+
+      state :eval_or_plain do
+        rule %r/[&!]?==/, Punctuation, :plain
+        rule %r/[&!]?[=!]/ do
+          token Punctuation
+          reset_stack
+          ruby! :ruby_line
+        end
+
+        rule(//) { push :plain }
+      end
+
+      state :ruby_line do
+        rule %r/\n/, Text, :pop!
+        rule(/,[ \t]*\n/) { delegate ruby }
+        rule %r/[ ]\|[ \t]*\n/, Str::Escape
+        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+      end
+
+      state :ruby_tag do
+        mixin :ruby_inner
+      end
+
+      state :html_attributes do
+        rule %r/\s+/, Text
+        rule %r/#{identifier}\s*=/, Name::Attribute, :html_attribute_value
+        rule identifier, Name::Attribute
+        rule %r/\)/, Text, :pop!
+      end
+
+      state :html_attribute_value do
+        rule %r/\s+/, Text
+        rule ruby_var, Name::Variable, :pop!
+        rule %r/@#{ruby_var}/, Name::Variable::Instance, :pop!
+        rule %r/\$#{ruby_var}/, Name::Variable::Global, :pop!
+        rule %r/'(\\\\|\\'|[^'\n])*'/, Str, :pop!
+        rule %r/"(\\\\|\\"|[^"\n])*"/, Str, :pop!
+      end
+
+      state :html_comment_block do
+        rule %r/#{dot}+/, Comment
+        mixin :indented_block
+      end
+
+      state :haml_comment_block do
+        rule %r/#{dot}+/, Comment::Preproc
+        mixin :indented_block
+      end
+
+      state :filter_block do
+        rule %r/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+          if @filter_lexer
+            delegate @filter_lexer
+          else
+            token Name::Decorator
+          end
+        end
+
+        mixin :interpolation
+        mixin :indented_block
+      end
+
+      state :interpolation do
+        rule %r/#[{]/, Str::Interpol, :ruby
+      end
+
+      state :ruby do
+        rule %r/[}]/, Str::Interpol, :pop!
+        mixin :ruby_inner
+      end
+
+      state :ruby_inner do
+        rule(/[{]/) { delegate ruby; push :ruby_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/handlebars.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Handlebars < TemplateLexer
+      title "Handlebars"
+      desc 'the Handlebars and Mustache templating languages'
+      tag 'handlebars'
+      aliases 'hbs', 'mustache'
+      filenames '*.handlebars', '*.hbs', '*.mustache'
+      mimetypes 'text/x-handlebars', 'text/x-mustache'
+
+      id = %r([\w$-]+)
+
+      state :root do
+        # escaped slashes
+        rule(/\\{+/) { delegate parent }
+
+        # block comments
+        rule %r/{{!--/, Comment, :comment
+        rule %r/{{!.*?}}/, Comment
+
+        rule %r/{{{?/ do
+          token Keyword
+          push :stache
+          push :open_sym
+        end
+
+        rule(/(.+?)(?=\\|{{)/m) do
+          delegate parent
+
+          # if parent state is attr, then we have an html attribute without quotes
+          # pop the parent state to return to the tag state
+          if parent.state?('attr')
+            parent.pop!
+          end
+        end
+
+        # if we get here, there's no more mustache tags, so we eat
+        # the rest of the doc
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :comment do
+        rule(/{{/) { token Comment; push }
+        rule(/}}/) { token Comment; pop! }
+        rule(/[^{}]+/m) { token Comment }
+        rule(/[{}]/) { token Comment }
+      end
+
+      state :stache do
+        rule %r/}}}?/, Keyword, :pop!
+        rule %r/\|/, Punctuation
+        rule %r/~/, Keyword
+        rule %r/\s+/m, Text
+        rule %r/[=]/, Operator
+        rule %r/[\[\]]/, Punctuation
+        rule %r/[\(\)]/, Punctuation
+        rule %r/[.](?=[}\s])/, Name::Variable
+        rule %r/[.][.]/, Name::Variable
+        rule %r([/.]), Punctuation
+        rule %r/"(\\.|.)*?"/, Str::Double
+        rule %r/'(\\.|.)*?'/, Str::Single
+        rule %r/\d+(?=}\s)/, Num
+        rule %r/(true|false)(?=[}\s])/, Keyword::Constant
+        rule %r/else(?=[}\s])/, Keyword
+        rule %r/this(?=[}\s])/, Name::Builtin::Pseudo
+        rule %r/@#{id}/, Name::Attribute
+        rule id, Name::Variable
+      end
+
+      state :open_sym do
+        rule %r([#/]) do
+          token Keyword
+          goto :block_name
+        end
+
+        rule %r/[>^&~]/, Keyword
+
+        rule(//) { pop! }
+      end
+
+      state :block_name do
+        rule %r/if(?=[}\s])/, Keyword
+        rule id, Name::Namespace, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/haskell.rb

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Haskell < RegexLexer
+      title "Haskell"
+      desc "The Haskell programming language (haskell.org)"
+
+      tag 'haskell'
+      aliases 'hs'
+      filenames '*.hs', '*.hs-boot'
+      mimetypes 'text/x-haskell'
+
+      def self.detect?(text)
+        return true if text.shebang?('runhaskell')
+      end
+
+      reserved = %w(
+        _ case class data default deriving do else if in
+        infix[lr]? instance let newtype of then type where
+      )
+
+      ascii = %w(
+        NUL SOH [SE]TX EOT ENQ ACK BEL BS HT LF VT FF CR S[OI] DLE
+        DC[1-4] NAK SYN ETB CAN EM SUB ESC [FGRU]S SP DEL
+      )
+
+      state :basic do
+        rule %r/\s+/m, Text
+        rule %r/{-#/, Comment::Preproc, :comment_preproc
+        rule %r/{-/, Comment::Multiline, :comment
+        rule %r/^--\s+\|.*?$/, Comment::Doc
+        # this is complicated in order to support custom symbols
+        # like -->
+        rule %r/--(?![!#\$\%&*+.\/<=>?@\^\|_~]).*?$/, Comment::Single
+      end
+
+      # nested commenting
+      state :comment do
+        rule %r/-}/, Comment::Multiline, :pop!
+        rule %r/{-/, Comment::Multiline, :comment
+        rule %r/[^-{}]+/, Comment::Multiline
+        rule %r/[-{}]/, Comment::Multiline
+      end
+
+      state :comment_preproc do
+        rule %r/-}/, Comment::Preproc, :pop!
+        rule %r/{-/, Comment::Preproc, :comment
+        rule %r/[^-{}]+/, Comment::Preproc
+        rule %r/[-{}]/, Comment::Preproc
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/\bimport\b/, Keyword::Reserved, :import
+        rule %r/\bmodule\b/, Keyword::Reserved, :module
+        rule %r/\b(?:#{reserved.join('|')})\b/, Keyword::Reserved
+        # not sure why, but ^ doesn't work here
+        # rule %r/^[_a-z][\w']*/, Name::Function
+        rule %r/[_a-z][\w']*/, Name
+        rule %r/[A-Z][\w']*/, Keyword::Type
+        rule %r/'[A-Z]\w+'?/, Keyword::Type  # promoted data constructor
+
+        # lambda operator
+        rule %r(\\(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), Name::Function
+        # special operators
+        rule %r((<-|::|->|=>|=)(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), Operator
+        # constructor/type operators
+        rule %r(:[:!#\$\%&*+.\\/<=>?@^\|~-]*), Operator
+        # other operators
+        rule %r([:!#\$\%&*+.\\/<=>?@^\|~-]+), Operator
+
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/\d+\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule %r/0o[0-7]+/i, Num::Oct
+        rule %r/0x[\da-f]+/i, Num::Hex
+        rule %r/\d+/, Num::Integer
+
+        rule %r/'/, Str::Char, :character
+        rule %r/"/, Str, :string
+
+        rule %r/\[\s*\]/, Keyword::Type
+        rule %r/\(\s*\)/, Name::Builtin
+
+        # Quasiquotations
+        rule %r/(\[)([_a-z][\w']*)(\|)/ do |m|
+          token Operator, m[1]
+          token Name, m[2]
+          token Operator, m[3]
+          push :quasiquotation
+        end
+
+        rule %r/[\[\](),;`{}]/, Punctuation
+      end
+
+      state :import do
+        rule %r/\s+/, Text
+        rule %r/"/, Str, :string
+        rule %r/\bqualified\b/, Keyword
+        # import X as Y
+        rule %r/([A-Z][\w.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)/ do
+          groups(
+            Name::Namespace, # X
+            Text, Keyword, # as
+            Text, Name # Y
+          )
+          pop!
+        end
+
+        # import X hiding (functions)
+        rule %r/([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()/ do
+          groups(
+            Name::Namespace, # X
+            Text, Keyword, # hiding
+            Text, Punctuation # (
+          )
+          goto :funclist
+        end
+
+        # import X (functions)
+        rule %r/([A-Z][\w.]*)(\s+)(\()/ do
+          groups(
+            Name::Namespace, # X
+            Text,
+            Punctuation # (
+          )
+          goto :funclist
+        end
+
+        rule %r/[\w.]+/, Name::Namespace, :pop!
+      end
+
+      state :module do
+        rule %r/\s+/, Text
+        # module Foo (functions)
+        rule %r/([A-Z][\w.]*)(\s+)(\()/ do
+          groups Name::Namespace, Text, Punctuation
+          push :funclist
+        end
+
+        rule %r/\bwhere\b/, Keyword::Reserved, :pop!
+
+        rule %r/[A-Z][a-zA-Z0-9_.]*/, Name::Namespace, :pop!
+      end
+
+      state :funclist do
+        mixin :basic
+        rule %r/[A-Z]\w*/, Keyword::Type
+        rule %r/(_[\w\']+|[a-z][\w\']*)/, Name::Function
+        rule %r/,/, Punctuation
+        rule %r/[:!#\$\%&*+.\\\/<=>?@^\|~-]+/, Operator
+        rule %r/\(/, Punctuation, :funclist
+        rule %r/\)/, Punctuation, :pop!
+      end
+
+      state :character do
+        rule %r/\\/ do
+          token Str::Escape
+          goto :character_end
+          push :escape
+        end
+
+        rule %r/./ do
+          token Str::Char
+          goto :character_end
+        end
+      end
+
+      state :character_end do
+        rule %r/'/, Str::Char, :pop!
+        rule %r/./, Error, :pop!
+      end
+
+      state :quasiquotation do
+        rule %r/\|\]/, Operator, :pop!
+        rule %r/[^\|]+/m, Text
+        rule %r/\|/, Text
+      end
+
+      state :string do
+        rule %r/"/, Str, :pop!
+        rule %r/\\/, Str::Escape, :escape
+        rule %r/[^\\"]+/, Str
+      end
+
+      state :escape do
+        rule %r/[abfnrtv"'&\\]/, Str::Escape, :pop!
+        rule %r/\^[\]\[A-Z@\^_]/, Str::Escape, :pop!
+        rule %r/#{ascii.join('|')}/, Str::Escape, :pop!
+        rule %r/o[0-7]+/i, Str::Escape, :pop!
+        rule %r/x[\da-f]+/i, Str::Escape, :pop!
+        rule %r/\d+/, Str::Escape, :pop!
+        rule %r/\s+\\/, Str::Escape, :pop!
+      end
+    end
+  end
+end