rouge-alda 3.3.0

data/lib/rouge/lexers/handlebars.rb

@@ -0,0 +1,80 @@
+# -*- 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 /{{!--/, Comment, :comment
+        rule /{{!.*?}}/, Comment
+
+        rule /{{{?/ do
+          token Keyword
+          push :stache
+          push :open_sym
+        end
+
+        rule(/(.+?)(?=\\|{{)/m) { delegate parent }
+
+        # 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 /}}}?/, Keyword, :pop!
+        rule /\s+/m, Text
+        rule /[=]/, Operator
+        rule /[\[\]]/, Punctuation
+        rule /[.](?=[}\s])/, Name::Variable
+        rule /[.][.]/, Name::Variable
+        rule %r([/.]), Punctuation
+        rule /"(\\.|.)*?"/, Str::Double
+        rule /'(\\.|.)*?'/, Str::Single
+        rule /\d+(?=}\s)/, Num
+        rule /(true|false)(?=[}\s])/, Keyword::Constant
+        rule /else(?=[}\s])/, Keyword
+        rule /this(?=[}\s])/, Name::Builtin::Pseudo
+        rule /@#{id}/, Name::Attribute
+        rule id, Name::Variable
+      end
+
+      state :open_sym do
+        rule %r([#/]) do
+          token Keyword
+          goto :block_name
+        end
+
+        rule /[>^&]/, Keyword
+
+        rule(//) { pop! }
+      end
+
+      state :block_name do
+        rule /if(?=[}\s])/, Keyword
+        rule id, Name::Namespace, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/haskell.rb

@@ -0,0 +1,198 @@
+# -*- 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'
+      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 /\s+/m, Text
+        rule /{-#/, Comment::Preproc, :comment_preproc
+        rule /{-/, Comment::Multiline, :comment
+        rule /^--\s+\|.*?$/, Comment::Doc
+        # this is complicated in order to support custom symbols
+        # like -->
+        rule /--(?![!#\$\%&*+.\/<=>?@\^\|_~]).*?$/, Comment::Single
+      end
+
+      # nested commenting
+      state :comment do
+        rule /-}/, Comment::Multiline, :pop!
+        rule /{-/, Comment::Multiline, :comment
+        rule /[^-{}]+/, Comment::Multiline
+        rule /[-{}]/, Comment::Multiline
+      end
+
+      state :comment_preproc do
+        rule /-}/, Comment::Preproc, :pop!
+        rule /{-/, Comment::Preproc, :comment
+        rule /[^-{}]+/, Comment::Preproc
+        rule /[-{}]/, Comment::Preproc
+      end
+
+      state :root do
+        mixin :basic
+
+        rule /\bimport\b/, Keyword::Reserved, :import
+        rule /\bmodule\b/, Keyword::Reserved, :module
+        rule /\b(?:#{reserved.join('|')})\b/, Keyword::Reserved
+        # not sure why, but ^ doesn't work here
+        # rule /^[_a-z][\w']*/, Name::Function
+        rule /[_a-z][\w']*/, Name
+        rule /[A-Z][\w']*/, Keyword::Type
+
+        # lambda operator
+        rule %r(\\(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), Name::Function
+        # special operators
+        rule %r((<-|::|->|=>|=)(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), Operator
+        # constructor/type operators
+        rule %r(:[:!#\$\%&*+.\\/<=>?@^\|~-]*), Operator
+        # other operators
+        rule %r([:!#\$\%&*+.\\/<=>?@^\|~-]+), Operator
+
+        rule /\d+e[+-]?\d+/i, Num::Float
+        rule /\d+\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule /0o[0-7]+/i, Num::Oct
+        rule /0x[\da-f]+/i, Num::Hex
+        rule /\d+/, Num::Integer
+
+        rule /'/, Str::Char, :character
+        rule /"/, Str, :string
+
+        rule /\[\s*\]/, Keyword::Type
+        rule /\(\s*\)/, Name::Builtin
+
+        # Quasiquotations
+        rule /(\[)([_a-z][\w']*)(\|)/ do |m|
+          token Operator, m[1]
+          token Name, m[2]
+          token Operator, m[3]
+          push :quasiquotation
+        end
+
+        rule /[\[\](),;`{}]/, Punctuation
+      end
+
+      state :import do
+        rule /\s+/, Text
+        rule /"/, Str, :string
+        rule /\bqualified\b/, Keyword
+        # import X as Y
+        rule /([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 /([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()/ do
+          groups(
+            Name::Namespace, # X
+            Text, Keyword, # hiding
+            Text, Punctuation # (
+          )
+          goto :funclist
+        end
+
+        # import X (functions)
+        rule /([A-Z][\w.]*)(\s+)(\()/ do
+          groups(
+            Name::Namespace, # X
+            Text,
+            Punctuation # (
+          )
+          goto :funclist
+        end
+
+        rule /[\w.]+/, Name::Namespace, :pop!
+      end
+
+      state :module do
+        rule /\s+/, Text
+        # module Foo (functions)
+        rule /([A-Z][\w.]*)(\s+)(\()/ do
+          groups Name::Namespace, Text, Punctuation
+          push :funclist
+        end
+
+        rule /\bwhere\b/, Keyword::Reserved, :pop!
+
+        rule /[A-Z][a-zA-Z0-9_.]*/, Name::Namespace, :pop!
+      end
+
+      state :funclist do
+        mixin :basic
+        rule /[A-Z]\w*/, Keyword::Type
+        rule /(_[\w\']+|[a-z][\w\']*)/, Name::Function
+        rule /,/, Punctuation
+        rule /[:!#\$\%&*+.\\\/<=>?@^\|~-]+/, Operator
+        rule /\(/, Punctuation, :funclist
+        rule /\)/, Punctuation, :pop!
+      end
+
+      state :character do
+        rule /\\/ do
+          token Str::Escape
+          goto :character_end
+          push :escape
+        end
+
+        rule /./ do
+          token Str::Char
+          goto :character_end
+        end
+      end
+
+      state :character_end do
+        rule /'/, Str::Char, :pop!
+        rule /./, Error, :pop!
+      end
+
+      state :quasiquotation do
+        rule /\|\]/, Operator, :pop!
+        rule /[^\|]+/m, Text
+        rule /\|/, Text
+      end
+
+      state :string do
+        rule /"/, Str, :pop!
+        rule /\\/, Str::Escape, :escape
+        rule /[^\\"]+/, Str
+      end
+
+      state :escape do
+        rule /[abfnrtv"'&\\]/, Str::Escape, :pop!
+        rule /\^[\]\[A-Z@\^_]/, Str::Escape, :pop!
+        rule /#{ascii.join('|')}/, Str::Escape, :pop!
+        rule /o[0-7]+/i, Str::Escape, :pop!
+        rule /x[\da-f]+/i, Str::Escape, :pop!
+        rule /\d+/, Str::Escape, :pop!
+        rule /\s+\\/, Str::Escape, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/hcl.rb

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Hcl < RegexLexer
+      tag 'hcl'
+
+      title 'Hashicorp Configuration Language'
+      desc 'Hashicorp Configuration Language, used by Terraform and other Hashicorp tools'
+
+      state :multiline_comment do
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^*/]+), Comment::Multiline
+        rule %r([*/]), Comment::Multiline
+      end
+
+      state :comments_and_whitespace do
+        rule /\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(#.*?$), Comment::Single
+        rule %r(/[*]), Comment::Multiline, :multiline_comment
+      end
+
+      state :primitives do
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?([kKmMgG]b?)?/, Num::Float
+        rule /[0-9]+([kKmMgG]b?)?/, Num::Integer
+
+        rule /"/, Str::Double, :dq
+        rule /'/, Str::Single, :sq
+        rule /(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
+          groups Operator, Text, Str::Heredoc, Str::Heredoc, Name::Constant, Str::Heredoc
+          @heredocstr = Regexp.escape(m[5])
+          push :heredoc
+        end
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w()
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w()
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w()
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      def self.builtins
+        @builtins ||= %w()
+      end
+
+      id = /[$a-z_][a-z0-9_]*/io
+
+      state :root do
+        mixin :comments_and_whitespace
+        mixin :primitives
+
+        rule /\{/ do
+          token Punctuation
+          push :hash
+        end
+        rule /\[/ do
+          token Punctuation
+          push :array
+        end
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+            push :composite
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :composite
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Other
+            push :composite
+          end
+        end
+      end
+
+      state :composite do
+        mixin :comments_and_whitespace
+
+        rule /[{]/ do
+          token Punctuation
+          pop!
+          push :hash
+        end
+
+        rule /[\[]/ do
+          token Punctuation
+          pop!
+          push :array
+        end
+
+        mixin :root
+
+        rule //, Text, :pop!
+      end
+
+      state :hash do
+        mixin :comments_and_whitespace
+
+        rule /\=/, Punctuation
+        rule /\}/, Punctuation, :pop!
+
+        mixin :root
+      end
+
+      state :array do
+        mixin :comments_and_whitespace
+
+        rule /,/, Punctuation
+        rule /\]/, Punctuation, :pop!
+
+        mixin :root
+      end
+
+      state :dq do
+        rule /[^\\"]+/, Str::Double
+        rule /\\"/, Str::Escape
+        rule /"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        rule /[^\\']+/, Str::Single
+        rule /\\'/, Str::Escape
+        rule /'/, Str::Single, :pop!
+      end
+
+      state :heredoc do
+        rule /\n/, Str::Heredoc, :heredoc_nl
+        rule /[^$\n]+/, Str::Heredoc
+        rule /[$]/, Str::Heredoc
+      end
+
+      state :heredoc_nl do
+        rule /\s*(\w+)\s*\n/ do |m|
+          if m[1] == @heredocstr
+            token Name::Constant
+            pop! 2
+          else
+            token Str::Heredoc
+          end
+        end
+
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/html.rb

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class HTML < RegexLexer
+      title "HTML"
+      desc "HTML, the markup language of the web"
+      tag 'html'
+      filenames '*.htm', '*.html', '*.xhtml'
+      mimetypes 'text/html', 'application/xhtml+xml'
+
+      def self.detect?(text)
+        return true if text.doctype?(/\bhtml\b/i)
+        return true if text =~ /<\s*html\b/
+      end
+
+      start do
+        @javascript = Javascript.new(options)
+        @css = CSS.new(options)
+      end
+
+      state :root do
+        rule /[^<&]+/m, Text
+        rule /&\S*?;/, Name::Entity
+        rule /<!DOCTYPE .*?>/im, Comment::Preproc
+        rule /<!\[CDATA\[.*?\]\]>/m, Comment::Preproc
+        rule /<!--/, Comment, :comment
+        rule /<\?.*?\?>/m, Comment::Preproc # php? really?
+
+        rule /<\s*script\s*/m do
+          token Name::Tag
+          @javascript.reset!
+          push :script_content
+          push :tag
+        end
+
+        rule /<\s*style\s*/m do
+          token Name::Tag
+          @css.reset!
+          @lang = @css
+          push :style_content
+          push :tag
+        end
+
+        rule /<\//, Name::Tag, :tag_end
+        rule /</, Name::Tag, :tag_start
+
+        rule %r(<\s*[a-zA-Z0-9:-]+), Name::Tag, :tag # opening tags
+        rule %r(<\s*/\s*[a-zA-Z0-9:-]+\s*>), Name::Tag # closing tags
+      end
+
+      state :tag_end do
+        mixin :tag_end_end
+        rule /[a-zA-Z0-9:-]+/ do
+          token Name::Tag
+          goto :tag_end_end
+        end
+      end
+
+      state :tag_end_end do
+        rule /\s+/, Text
+        rule />/, Name::Tag, :pop!
+      end
+
+      state :tag_start do
+        rule /\s+/, Text
+
+        rule /[a-zA-Z0-9:-]+/ do
+          token Name::Tag
+          goto :tag
+        end
+
+        rule(//) { goto :tag }
+      end
+
+      state :comment do
+        rule /[^-]+/, Comment
+        rule /-->/, Comment, :pop!
+        rule /-/, Comment
+      end
+
+      state :tag do
+        rule /\s+/m, Text
+        rule /[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
+        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r(/?\s*>)m, Name::Tag, :pop!
+      end
+
+      state :attr do
+        # TODO: are backslash escapes valid here?
+        rule /"/ do
+          token Str
+          goto :dq
+        end
+
+        rule /'/ do
+          token Str
+          goto :sq
+        end
+
+        rule /[^\s>]+/, Str, :pop!
+      end
+
+      state :dq do
+        rule /"/, Str, :pop!
+        rule /[^"]+/, Str
+      end
+
+      state :sq do
+        rule /'/, Str, :pop!
+        rule /[^']+/, Str
+      end
+
+      state :script_content do
+        rule %r([^<]+) do
+          delegate @javascript
+        end
+
+        rule %r(<\s*/\s*script\s*>)m, Name::Tag, :pop!
+
+        rule %r(<) do
+          delegate @javascript
+        end
+      end
+
+      state :style_content do
+        rule /[^<]+/ do
+          delegate @lang
+        end
+
+        rule %r(<\s*/\s*style\s*>)m, Name::Tag, :pop!
+
+        rule /</ do
+          delegate @lang
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/http.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class HTTP < RegexLexer
+      tag 'http'
+      title "HTTP"
+      desc 'http requests and responses'
+
+      def self.http_methods
+        @http_methods ||= %w(GET POST PUT DELETE HEAD OPTIONS TRACE PATCH)
+      end
+
+      def content_lexer
+        return Lexers::PlainText unless @content_type
+
+        @content_lexer ||= Lexer.guess_by_mimetype(@content_type)
+      rescue Lexer::AmbiguousGuess
+        @content_lexer = Lexers::PlainText
+      end
+
+      start { @content_type = 'text/plain' }
+
+      state :root do
+        # request
+        rule %r(
+          (#{HTTP.http_methods.join('|')})([ ]+) # method
+          ([^ ]+)([ ]+)                     # path
+          (HTTPS?)(/)(1[.][01])(\r?\n|$)  # http version
+        )ox do
+          groups(
+            Name::Function, Text,
+            Name::Namespace, Text,
+            Keyword, Operator, Num, Text
+          )
+
+          push :headers
+        end
+
+        # response
+        rule %r(
+          (HTTPS?)(/)(1[.][01])([ ]+) # http version
+          (\d{3})([ ]+)               # status
+          ([^\r\n]+)(\r?\n|$)       # status message
+        )x do
+          groups(
+            Keyword, Operator, Num, Text,
+            Num, Text,
+            Name::Exception, Text
+          )
+          push :headers
+        end
+      end
+
+      state :headers do
+        rule /([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|$)/ do |m|
+          key = m[1]
+          value = m[5]
+          if key.strip.casecmp('content-type').zero?
+            @content_type = value.split(';')[0].downcase
+          end
+
+          groups Name::Attribute, Text, Punctuation, Text, Str, Text
+        end
+
+        rule /([^\r\n]+)(\r?\n|$)/ do
+          groups Str, Text
+        end
+
+        rule /\r?\n/, Text, :content
+      end
+
+      state :content do
+        rule /.+/m do |m|
+          delegate(content_lexer)
+        end
+      end
+    end
+  end
+end