rouge 3.17.0

data/lib/rouge/lexers/haxe.rb

@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Haxe < RegexLexer
+      title "Haxe"
+      desc "Haxe Cross-platform Toolkit (http://haxe.org)"
+
+      tag 'haxe'
+      aliases 'hx', 'haxe'
+      filenames '*.hx'
+      mimetypes 'text/haxe', 'text/x-haxe', 'text/x-hx'
+
+      def self.detect?(text)
+        return true if text.shebang? "haxe"
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          break case cast catch class continue default do else enum false for
+          function if import interface macro new null override package private
+          public return switch this throw true try untyped while
+        )
+      end
+
+      def self.imports
+        @imports ||= Set.new %w(
+          import using
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          abstract dynamic extern extends from implements inline static to
+          typedef var
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          super trace inline build autoBuild enum
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          Void Dynamic Math Class Any Float Int UInt String StringTools Sys
+          EReg isNaN parseFloat parseInt this Array Map Date DateTools Bool
+          Lambda Reflect Std File FileSystem
+        )
+      end
+
+      id = /[$a-zA-Z_][a-zA-Z0-9_]*/
+
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+      end
+
+      state :expr_start do
+        mixin :comments_and_whitespace
+
+        rule %r/#(?:if|elseif|else|end).*/, Comment::Preproc
+
+        rule %r(~) do
+          token Str::Regex
+          goto :regex
+        end
+
+        rule %r/[{]/, Punctuation, :object
+
+        rule %r//, Text, :pop!
+      end
+
+      state :regex do
+        rule %r(/) do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r([^/]\n), Error, :pop!
+
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_end do
+        rule %r/[gim]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        # specially highlight / in a group to indicate that it doesn't
+        # close the regex
+        rule %r/\//, Str::Escape
+
+        rule %r([^/]\n) do
+          token Error
+          pop! 2
+        end
+
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :bad_regex do
+        rule %r/[^\n]+/, Error, :pop!
+      end
+
+      state :root do
+        rule %r/\n/, Text, :statement
+        rule %r(\{), Punctuation, :expr_start
+        
+        mixin :comments_and_whitespace
+
+        rule %r/@/, Name::Decorator, :metadata
+        rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >> | ==
+               | != )x,
+          Operator, :expr_start
+        rule %r([-:<>+*%&|\^/!=]=?), Operator, :expr_start
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\]}.]/, Punctuation
+
+        rule %r/[?]/ do
+          token Punctuation
+          push :ternary
+          push :expr_start
+        end
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+            push :expr_start
+          elsif self.class.imports.include? m[0]
+            token Keyword
+            push :namespace
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :expr_start
+          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
+          end
+        end
+
+        rule %r/\-?\d+\.\d+(?:[eE]\d+)?[fd]?/, Num::Float
+        rule %r/0x\h+/, Num::Hex
+        rule %r/\-?[0-9]+/, Num::Integer
+        rule %r/"/, Str::Double, :str_double
+        rule %r/'/, Str::Single, :str_single
+      end
+
+      # braced parts that aren't object literals
+      state :statement do
+        rule %r/(#{id})(\s*)(:)/ do
+          groups Name::Label, Text, Punctuation
+        end
+
+        mixin :expr_start
+      end
+
+      # object literals
+      state :object do
+        mixin :comments_and_whitespace
+        rule %r/[}]/ do
+          token Punctuation
+          goto :statement
+        end
+
+        rule %r/(#{id})(\s*)(:)/ do
+          groups Name::Attribute, Text, Punctuation
+          push :expr_start
+        end
+
+        rule %r/:/, Punctuation
+        mixin :root
+      end
+
+      state :metadata do
+        rule %r/(#{id})(\()?/ do |m|
+          groups Name::Decorator, Punctuation
+          pop! unless m[2]
+        end
+        rule %r/:#{id}(?:\.#{id})*/, Name::Decorator, :pop!
+        rule %r/\)/, Name::Decorator, :pop!
+        mixin :root
+      end
+
+      # ternary expressions, where <id>: is not a label!
+      state :ternary do
+        rule %r/:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
+        mixin :root
+      end
+
+      state :str_double do
+        mixin :str_escape
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^\\"]+/, Str::Double
+      end
+
+      state :str_single do
+        mixin :str_escape
+        rule %r/'/, Str::Single, :pop!
+        rule %r/\$\$/, Str::Single
+        rule %r/\$#{id}/, Str::Interpol
+        rule %r/\$\{/, Str::Interpol, :str_interpol
+        rule %r/[^\\$']+/, Str::Single
+      end
+
+      state :str_escape do
+        rule %r/\\[\\tnr'"]/, Str::Escape
+        rule %r/\\[0-7]{3}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
+        rule %r/\\u\h{4}/, Str::Escape
+        rule %r/\\u\{\h{1,6}\}/, Str::Escape
+      end 
+
+      state :str_interpol do
+        rule %r/\}/, Str::Interpol, :pop!
+        mixin :root
+      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 %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(#.*?$), Comment::Single
+        rule %r(/[*]), Comment::Multiline, :multiline_comment
+      end
+
+      state :primitives do
+        rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?([kKmMgG]b?)?/, Num::Float
+        rule %r/[0-9]+([kKmMgG]b?)?/, Num::Integer
+
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
+        rule %r/(<<-?)(\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 %r/\{/ do
+          token Punctuation
+          push :hash
+        end
+        rule %r/\[/ 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 %r/[{]/ do
+          token Punctuation
+          pop!
+          push :hash
+        end
+
+        rule %r/[\[]/ do
+          token Punctuation
+          pop!
+          push :array
+        end
+
+        mixin :root
+
+        rule %r//, Text, :pop!
+      end
+
+      state :hash do
+        mixin :comments_and_whitespace
+
+        rule %r/\=/, Punctuation
+        rule %r/\}/, Punctuation, :pop!
+
+        mixin :root
+      end
+
+      state :array do
+        mixin :comments_and_whitespace
+
+        rule %r/,/, Punctuation
+        rule %r/\]/, Punctuation, :pop!
+
+        mixin :root
+      end
+
+      state :dq do
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/\\"/, Str::Escape
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        rule %r/[^\\']+/, Str::Single
+        rule %r/\\'/, Str::Escape
+        rule %r/'/, Str::Single, :pop!
+      end
+
+      state :heredoc do
+        rule %r/\n/, Str::Heredoc, :heredoc_nl
+        rule %r/[^$\n]+/, Str::Heredoc
+        rule %r/[$]/, Str::Heredoc
+      end
+
+      state :heredoc_nl do
+        rule %r/\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/hocon.rb

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'json.rb'
+
+    class HOCON < JSON
+      title 'HOCON'
+      desc "Human-Optimized Config Object Notation (https://github.com/lightbend/config)"
+      tag 'hocon'
+      filenames '*.hocon'
+
+      state :comments do
+        # Comments
+        rule %r(//.*?$), Comment::Single
+        rule %r(#.*?$), Comment::Single
+      end
+
+      prepend :root do
+        mixin :comments
+      end
+
+      prepend :object do
+        # Keywords
+        rule %r/\b(?:include|url|file|classpath)\b/, Keyword
+      end
+
+      state :name do
+        rule %r/("(?:\"|[^"\n])*?")(\s*)([:=]|(?={))/ do
+          groups Name::Label, Text::Whitespace, Punctuation
+        end
+
+        rule %r/([-\w.]+)(\s*)([:=]|(?={))/ do
+          groups Name::Label, Text::Whitespace, Punctuation
+        end
+      end
+
+      state :value do
+        mixin :comments
+
+        rule %r/\n/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
+
+        mixin :constants
+
+        # Interpolation
+        rule %r/[$][{][?]?/, Literal::String::Interpol, :interpolation
+
+        # Strings
+        rule %r/"""/, Literal::String::Double, :multiline_string
+        rule %r/"/, Str::Double, :string
+
+        rule %r/\[/, Punctuation, :array
+        rule %r/{/, Punctuation, :object
+
+        # Symbols (only those not handled by JSON)
+        rule %r/[()=]/, Punctuation
+
+        # Values
+        rule %r/[^$"{}\[\]:=,\+#`^?!@*&]+?/, Literal
+      end
+
+      state :interpolation do
+        rule %r/[\w\-\.]+?/, Name::Variable
+        rule %r/}/, Literal::String::Interpol, :pop!
+      end
+
+      prepend :string do
+        rule %r/[$][{][?]?/, Literal::String::Interpol, :interpolation
+        rule %r/[^\\"\${]+/, Literal::String::Double
+      end
+
+      state :multiline_string do
+        rule %r/"[^"]{1,2}/, Literal::String::Double
+        mixin :string
+        rule %r/"""/, Literal::String::Double, :pop!
+      end
+
+      prepend :constants do
+        # Numbers (handle the case where we have multiple periods, ie. IP addresses)
+        rule %r/\d+\.(\d+\.?){3,}/, Literal
+      end
+    end
+  end
+end