rouge 3.6.0 → 3.12.0

data/lib/rouge/lexers/epp.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class EPP < TemplateLexer
+      title "EPP"
+      desc "Embedded Puppet template files"
+
+      tag 'epp'
+
+      filenames '*.epp'
+
+      def initialize(opts={})
+        super(opts)
+        @parent = lexer_option(:parent) { PlainText.new(opts) }
+        @puppet_lexer = Puppet.new(opts)
+      end
+
+      start do
+        parent.reset!
+        @puppet_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|(<%-|<%)(\s*\|)?/
+      close = /%%>|(\|\s*)?(-%>|%>)/
+
+      state :root do
+        rule %r/<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :puppet
+
+        rule %r/.+?(?=#{open})|.+/m do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule %r/.+?(?=#{close})|.+/m, Comment
+      end
+
+      state :puppet do
+        rule close, Comment::Preproc, :pop!
+
+        rule %r/.+?(?=#{close})|.+/m do
+          delegate @puppet_lexer
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/escape.rb

@@ -1,3 +1,6 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     class Escape < Lexer

data/lib/rouge/lexers/gdscript.rb

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class GDScript < RegexLexer
+      title "GDScript"
+      desc "The Godot Engine programming language (https://godotengine.org/)"
+      tag 'gdscript'
+      aliases 'gd', 'gdscript'
+      filenames '*.gd'
+      mimetypes 'text/x-gdscript', 'application/x-gdscript'
+
+      def self.keywords
+        @keywords = %w(
+          and in not or as breakpoint class class_name extends is func setget
+          signal tool const enum export onready static var break continue
+          if elif else for pass return match while remote master puppet
+          remotesync mastersync puppetsync
+        ).join('|')
+      end
+
+      # Reserved for future implementation
+      def self.keywords_reserved
+        @keywords_reserved = %w(
+          do switch case
+        ).join('|')
+      end
+
+      def self.builtins
+        builtins = %w(
+          Color8 ColorN abs acos asin assert atan atan2 bytes2var ceil char
+          clamp convert cos cosh db2linear decimals dectime deg2rad dict2inst
+          ease exp floor fmod fposmod funcref hash inst2dict instance_from_id
+          is_inf is_nan lerp linear2db load log max min nearest_po2 pow
+          preload print print_stack printerr printraw prints printt rad2deg
+          rand_range rand_seed randf randi randomize range round seed sign
+          sin sinh sqrt stepify str str2var tan tan tanh type_exist typeof
+          var2bytes var2str weakref yield
+        ).join('|')
+      end
+
+      def self.builtins_type
+        @builtins_type = %w(
+          bool int float String Vector2 Rect2 Transform2D Vector3 AABB
+          Plane Quat Basis Transform Color RID Object NodePath Dictionary
+          Array PoolByteArray PoolIntArray PoolRealArray PoolStringArray
+          PoolVector2Array PoolVector3Array PoolColorArray null
+        ).join('|')
+      end
+
+      state :root do
+        rule %r/\n/, Text
+        rule %r/[^\S\n]+/, Text
+        rule %r/#.*/, Comment::Single
+        rule %r/[\[\]{}:(),;]/, Punctuation
+        rule %r/\\\n/, Text
+        rule %r/(in|and|or|not)\b/, Operator::Word
+        rule %r/!=|==|<<|>>|&&|\+=|-=|\*=|\/=|%=|&=|\|=|\|\||[-~+\/*%=<>&^.!|$]/, Operator
+        rule %r/(func)((?:\s|\\)+)/ do
+          groups Keyword, Text
+          push :funcname
+        end
+        rule %r/(class)((?:\s|\\)+)/ do
+          groups Keyword, Text
+          push :classname
+        end
+        mixin :keywords
+        mixin :builtins
+        rule %r/"""/, Str::Double, :escape_tdqs
+        rule %r/'''/, Str::Double, :escape_tsqs
+        rule %r/"/, Str::Double, :escape_dqs
+        rule %r/'/, Str::Double, :escape_sqs
+        mixin :name
+        mixin :numbers
+      end
+
+      state :keywords do
+        rule %r/\b(#{GDScript.keywords})\b/, Keyword
+        rule %r/\b(#{GDScript.keywords_reserved})\b/, Keyword::Reserved
+      end
+
+      state :builtins do
+        rule %r/\b(#{GDScript.builtins})\b/, Name::Builtin
+        rule %r/\b((self|false|true)|(PI|TAU|NAN|INF))\b/, Name::Builtin::Pseudo
+        rule %r/\b(#{GDScript.builtins_type})\b/, Keyword::Type
+      end
+
+      state :numbers do
+        rule %r/(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, Num::Float
+        rule %r/\d+[eE][+-]?[0-9]+j?/, Num::Float
+        rule %r/0[xX][a-fA-F0-9]+/, Num::Hex
+        rule %r/\d+j?/, Num::Integer
+      end
+
+      state :name do
+        rule %r/[a-zA-Z_]\w*/, Name
+      end
+
+      state :funcname do
+        rule %r/[a-zA-Z_]\w*/, Name::Function, :pop!
+      end
+
+      state :classname do
+        rule %r/[a-zA-Z_]\w*/, Name::Class, :pop!
+      end
+
+      state :string_escape do
+        rule %r/\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})/, Str::Escape
+      end
+
+      state :strings_single do
+        rule %r/%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]/, Str::Interpol
+        rule %r/[^\\'%\n]+/, Str::Single
+        rule %r/["\\]/, Str::Single
+        rule %r/%/, Str::Single
+      end
+
+      state :strings_double do
+        rule %r/%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]/, Str::Interpol
+        rule %r/[^\\"%\n]+/, Str::Double
+        rule %r/['\\]/, Str::Double
+        rule %r/%/, Str::Double
+      end
+
+      state :dqs do
+        rule %r/"/, Str::Double, :pop!
+        rule %r/\\\\|\\"|\\\n/, Str::Escape
+        mixin :strings_double
+      end
+
+      state :escape_dqs do
+        mixin :string_escape
+        mixin :dqs
+      end
+
+      state :sqs do
+        rule %r/'/, Str::Single, :pop!
+        rule %r/\\\\|\\'|\\\n/, Str::Escape
+        mixin :strings_single
+      end
+
+      state :escape_sqs do
+        mixin :string_escape
+        mixin :sqs
+      end
+
+      state :tdqs do
+        rule %r/"""/, Str::Double, :pop!
+        mixin :strings_double
+        rule %r/\n/, Str::Double
+      end
+
+      state :escape_tdqs do
+        mixin :string_escape
+        mixin :tdqs
+      end
+
+      state :tsqs do
+        rule %r/'''/, Str::Single, :pop!
+        mixin :strings_single
+        rule %r/\n/, Str::Single
+      end
+
+      state :escape_tsqs do
+        mixin :string_escape
+        mixin :tsqs
+      end
+    end
+  end
+end

data/lib/rouge/lexers/gherkin.rb

@@ -8,7 +8,7 @@ module Rouge
       aliases 'cucumber', 'behat'
 
       title "Gherkin"
-      desc 'A business-readable spec DSL ( github.com/cucumber/cucumber/wiki/Gherkin )'
+      desc 'A business-readable spec DSL (github.com/cucumber/cucumber/wiki/Gherkin)'
 
       filenames '*.feature'
       mimetypes 'text/x-gherkin'
@@ -30,6 +30,8 @@ module Rouge
           keywords[:step].map do |w|
             if w.end_with? '<'
               Regexp.escape(w.chop)
+            elsif w.end_with?(' ')
+              Regexp.escape(w)
             else
               "#{Regexp.escape(w)}\\b"
             end
@@ -130,7 +132,7 @@ module Rouge
         mixin :basic
         rule %r/<.*?>/, Name::Variable
         rule %r/".*?"/, Str
-        rule %r/\S+/, Text
+        rule %r/\S[^\s<]*/, Text
         rule rest_of_line, Text, :pop!
       end
     end

data/lib/rouge/lexers/graphql.rb

@@ -20,19 +20,26 @@ module Rouge
         end
 
         rule %r/\bfragment\b/, Keyword, :fragment_definition
+        
+        rule %r/\bscalar\b/, Keyword, :value
 
         rule %r/\b(?:type|interface|enum)\b/, Keyword, :type_definition
+
         rule %r/\b(?:input|schema)\b/, Keyword, :type_definition
 
         rule %r/\bunion\b/, Keyword, :union_definition
 
+        rule %r/\bextend\b/, Keyword
+
         mixin :basic
 
         # Markdown descriptions
-        rule %r/(""")(.*?)(""")/m do |m|
+        rule %r/(""")(\n)(.*?)(\n)(""")/m do |m|
           token Str::Double, m[1]
-          delegate Markdown, m[2]
-          token Str::Double, m[3]
+          token Text::Whitespace, m[2]
+          delegate Markdown, m[3]
+          token Text::Whitespace, m[4]
+          token Str::Double, m[5]
         end
       end
 

data/lib/rouge/lexers/handlebars.rb

@@ -27,7 +27,15 @@ module Rouge
           push :open_sym
         end
 
-        rule(/(.+?)(?=\\|{{)/m) { delegate parent }
+        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
@@ -43,9 +51,12 @@ module Rouge
 
       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
@@ -65,7 +76,7 @@ module Rouge
           goto :block_name
         end
 
-        rule %r/[>^&]/, Keyword
+        rule %r/[>^&~]/, Keyword
 
         rule(//) { pop! }
       end
@@ -77,4 +88,4 @@ module Rouge
       end
     end
   end
-end
+end

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