rouge 3.18.0

data/lib/rouge/lexers/properties.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Properties < RegexLexer
+      title ".properties"
+      desc '.properties config files for Java'
+      tag 'properties'
+
+      filenames '*.properties'
+      mimetypes 'text/x-java-properties'
+
+      identifier = /[\w.-]+/
+
+      state :basic do
+        rule %r/[!#].*?\n/, Comment
+        rule %r/\s+/, Text
+        rule %r/\\\n/, Str::Escape
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/(#{identifier})(\s*)([=:])/ do
+          groups Name::Property, Text, Punctuation
+          push :value
+        end
+      end
+
+      state :value do
+        rule %r/\n/, Text, :pop!
+        mixin :basic
+        rule %r/"/, Str, :dq
+        rule %r/'.*?'/, Str
+        mixin :esc_str
+        rule %r/[^\\\n]+/, Str
+      end
+
+      state :dq do
+        rule %r/"/, Str, :pop!
+        mixin :esc_str
+        rule %r/[^\\"]+/m, Str
+      end
+
+      state :esc_str do
+        rule %r/\\u[0-9]{4}/, Str::Escape
+        rule %r/\\./m, Str::Escape
+      end
+    end
+  end
+end

data/lib/rouge/lexers/protobuf.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Protobuf < RegexLexer
+      title 'Protobuf'
+      desc 'Google\'s language-neutral, platform-neutral, extensible mechanism for serializing structured data'
+      tag 'protobuf'
+      aliases 'proto'
+      filenames '*.proto'
+      mimetypes 'text/x-proto'
+
+      kw = /\b(ctype|default|extensions|import|max|oneof|option|optional|packed|repeated|required|returns|rpc|to)\b/
+      datatype = /\b(bool|bytes|double|fixed32|fixed64|float|int32|int64|sfixed32|sfixed64|sint32|sint64|string|uint32|uint64)\b/
+
+      state :root do
+        rule %r/[\s]+/, Text
+        rule %r/[,;{}\[\]()]/, Punctuation
+        rule %r/\/(\\\n)?\/($|(.|\n)*?[^\\]$)/, Comment::Single
+        rule %r/\/(\\\n)?\*(.|\n)*?\*(\\\n)?\//, Comment::Multiline
+        rule kw, Keyword
+        rule datatype, Keyword::Type
+        rule %r/true|false/, Keyword::Constant
+        rule %r/(package)(\s+)/ do
+          groups Keyword::Namespace, Text
+          push :package
+        end
+
+        rule %r/(message|extend)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :message
+        end
+
+        rule %r/(enum|group|service)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :type
+        end
+
+        rule %r/".*?"/, Str
+        rule %r/'.*?'/, Str
+        rule %r/(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*/, Num::Float
+        rule %r/(\d+\.\d*|\.\d+|\d+[fF])[fF]?/, Num::Float
+        rule %r/(\-?(inf|nan))\b/, Num::Float
+        rule %r/0x[0-9a-fA-F]+[LlUu]*/, Num::Hex
+        rule %r/0[0-7]+[LlUu]*/, Num::Oct
+        rule %r/\d+[LlUu]*/, Num::Integer
+        rule %r/[+-=]/, Operator
+        rule %r/([a-zA-Z_][\w.]*)([ \t]*)(=)/ do
+          groups Name::Attribute, Text, Operator
+        end
+        rule %r/[a-zA-Z_][\w.]*/, Name
+      end
+
+      state :package do
+        rule %r/[a-zA-Z_]\w*/, Name::Namespace, :pop!
+        rule(//) { pop! }
+      end
+
+      state :message do
+        rule %r/[a-zA-Z_]\w*/, Name::Class, :pop!
+        rule(//) { pop! }
+      end
+
+      state :type do
+        rule %r/[a-zA-Z_]\w*/, Name, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/puppet.rb

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Puppet < RegexLexer
+      title "Puppet"
+      desc 'The Puppet configuration management language (puppetlabs.org)'
+      tag 'puppet'
+      aliases 'pp'
+      filenames '*.pp'
+
+      def self.detect?(text)
+        return true if text.shebang? 'puppet-apply'
+        return true if text.shebang? 'puppet'
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          and case class default define else elsif if in import inherits
+          node unless
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          false true undef
+        )
+      end
+
+      def self.metaparameters
+        @metaparameters ||= Set.new %w(
+          before require notify subscribe
+        )
+      end
+
+      id = /[a-z]\w*/
+      cap_id = /[A-Z]\w*/
+      qualname = /(::)?(#{id}::)*\w+/
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r/#.*?\n/, Comment
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/[$]#{qualname}/, Name::Variable
+        rule %r/(#{id})(?=\s*[=+]>)/m do |m|
+          if self.class.metaparameters.include? m[0]
+            token Keyword::Pseudo
+          else
+            token Name::Property
+          end
+        end
+
+        rule %r/(#{qualname})(?=\s*[(])/m, Name::Function
+        rule cap_id, Name::Class
+
+        rule %r/[+=|~-]>|<[|~-]/, Punctuation
+        rule %r/[|:}();\[\]]/, Punctuation
+
+        # HACK for case statements and selectors
+        rule %r/{/, Punctuation, :regex_allowed
+        rule %r/,/, Punctuation, :regex_allowed
+
+        rule %r/(in|and|or)\b/, Operator::Word
+        rule %r/[=!<>]=/, Operator
+        rule %r/[=!]~/, Operator, :regex_allowed
+        rule %r([.=<>!+*/-]), Operator
+
+        rule %r/(class|include)(\s*)(#{qualname})/ do
+          groups Keyword, Text, Name::Class
+        end
+
+        rule %r/node\b/, Keyword, :regex_allowed
+
+        rule %r/'(\\[\\']|[^'])*'/m, Str::Single
+        rule %r/"/, Str::Double, :dquotes
+
+        rule %r/\d+([.]\d+)?(e[+-]\d+)?/, Num
+
+        # a valid regex.  TODO: regexes are only allowed
+        # in certain places in puppet.
+        rule qualname do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          else
+            token Name
+          end
+        end
+      end
+
+      state :regex_allowed do
+        mixin :whitespace
+        rule %r(/), Str::Regex, :regex
+
+        rule(//) { pop! }
+      end
+
+      state :regex do
+        rule %r(/), Str::Regex, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/[(){}]/, Str::Interpol
+        rule %r/\[/, Str::Interpol, :regex_class
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_class do
+        rule %r/\]/, Str::Interpol, :pop!
+        rule %r/(?<!\[)-(?=\])/, Str::Regex
+        rule %r/-/, Str::Interpol
+        rule %r/\\./, Str::Escape
+        rule %r/[^\\\]-]+/, Str::Regex
+      end
+
+      state :dquotes do
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^$\\"]+/m, Str::Double
+        rule %r/\\./m, Str::Escape
+        rule %r/[$]#{qualname}/, Name::Variable
+        rule %r/[$][{]#{qualname}[}]/, Name::Variable
+      end
+    end
+  end
+end

data/lib/rouge/lexers/python.rb

@@ -0,0 +1,257 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Python < RegexLexer
+      title "Python"
+      desc "The Python programming language (python.org)"
+      tag 'python'
+      aliases 'py'
+      filenames '*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac',
+                '*.bzl', 'BUCK', 'BUILD', 'BUILD.bazel', 'WORKSPACE'
+      mimetypes 'text/x-python', 'application/x-python'
+
+      def self.detect?(text)
+        return true if text.shebang?(/pythonw?(?:[23](?:\.\d+)?)?/)
+      end
+
+      def self.keywords
+        @keywords ||= %w(
+          assert break continue del elif else except exec
+          finally for global if lambda pass print raise
+          return try while yield as with from import yield
+          async await nonlocal
+        )
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          __import__ abs all any apply ascii basestring bin bool buffer
+          bytearray bytes callable chr classmethod cmp coerce compile
+          complex delattr dict dir divmod enumerate eval execfile exit
+          file filter float format frozenset getattr globals hasattr hash hex id
+          input int intern isinstance issubclass iter len list locals
+          long map max memoryview min next object oct open ord pow property range
+          raw_input reduce reload repr reversed round set setattr slice
+          sorted staticmethod str sum super tuple type unichr unicode
+          vars xrange zip
+        )
+      end
+
+      def self.builtins_pseudo
+        @builtins_pseudo ||= %w(self None Ellipsis NotImplemented False True)
+      end
+
+      def self.exceptions
+        @exceptions ||= %w(
+          ArithmeticError AssertionError AttributeError
+          BaseException BlockingIOError BrokenPipeError BufferError
+          BytesWarning ChildProcessError ConnectionAbortedError
+          ConnectionError ConnectionRefusedError ConnectionResetError
+          DeprecationWarning EOFError EnvironmentError
+          Exception FileExistsError FileNotFoundError
+          FloatingPointError FutureWarning GeneratorExit IOError
+          ImportError ImportWarning IndentationError IndexError
+          InterruptedError IsADirectoryError KeyError KeyboardInterrupt
+          LookupError MemoryError ModuleNotFoundError NameError
+          NotADirectoryError NotImplemented NotImplementedError OSError
+          OverflowError OverflowWarning PendingDeprecationWarning
+          ProcessLookupError RecursionError ReferenceError ResourceWarning
+          RuntimeError RuntimeWarning StandardError StopAsyncIteration
+          StopIteration SyntaxError SyntaxWarning SystemError SystemExit
+          TabError TimeoutError TypeError UnboundLocalError UnicodeDecodeError
+          UnicodeEncodeError UnicodeError UnicodeTranslateError
+          UnicodeWarning UserWarning ValueError VMSError Warning
+          WindowsError ZeroDivisionError
+        )
+      end
+
+      identifier =        /[a-z_][a-z0-9_]*/i
+      dotted_identifier = /[a-z_.][a-z0-9_.]*/i
+
+      def current_string
+        @string_register ||= StringRegister.new
+      end
+
+      state :root do
+        rule %r/\n+/m, Text
+        rule %r/^(:)(\s*)([ru]{,2}""".*?""")/mi do
+          groups Punctuation, Text, Str::Doc
+        end
+
+        rule %r/[^\S\n]+/, Text
+        rule %r(#(.*)?\n?), Comment::Single
+        rule %r/[\[\]{}:(),;.]/, Punctuation
+        rule %r/\\\n/, Text
+        rule %r/\\/, Text
+
+        rule %r/(in|is|and|or|not)\b/, Operator::Word
+        rule %r/(<<|>>|\/\/|\*\*)=?/, Operator
+        rule %r/[-~+\/*%=<>&^|@]=?|!=/, Operator
+
+        rule %r/(from)((?:\\\s|\s)+)(#{dotted_identifier})((?:\\\s|\s)+)(import)/ do
+          groups Keyword::Namespace,
+                 Text,
+                 Name::Namespace,
+                 Text,
+                 Keyword::Namespace
+        end
+
+        rule %r/(import)(\s+)(#{dotted_identifier})/ do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
+
+        rule %r/(def)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :funcname
+        end
+
+        rule %r/(class)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :classname
+        end
+
+        # TODO: not in python 3
+        rule %r/`.*?`/, Str::Backtick
+        rule %r/([rfbu]{0,2})('''|"""|['"])/i do |m|
+          token Str
+          current_string.register type: m[1].downcase, delim: m[2]
+          push :generic_string
+        end
+
+        rule %r/@#{dotted_identifier}/i, Name::Decorator
+
+        # using negative lookbehind so we don't match property names
+        rule %r/(?<!\.)#{identifier}/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.exceptions.include? m[0]
+            token Name::Builtin
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif self.class.builtins_pseudo.include? m[0]
+            token Name::Builtin::Pseudo
+          else
+            token Name
+          end
+        end
+
+        rule identifier, Name
+
+        digits = /[0-9](_?[0-9])*/
+        decimal = /((#{digits})?\.#{digits}|#{digits}\.)/
+        exponent = /e[+-]?#{digits}/i
+        rule %r/#{decimal}(#{exponent})?j?/i, Num::Float
+        rule %r/#{digits}#{exponent}j?/i, Num::Float
+        rule %r/#{digits}j/i, Num::Float
+
+        rule %r/0b(_?[0-1])+/i, Num::Bin
+        rule %r/0o(_?[0-7])+/i, Num::Oct
+        rule %r/0x(_?[a-f0-9])+/i, Num::Hex
+        rule %r/\d+L/, Num::Integer::Long
+        rule %r/([1-9](_?[0-9])*|0(_?0)*)/, Num::Integer
+      end
+
+      state :funcname do
+        rule identifier, Name::Function, :pop!
+      end
+
+      state :classname do
+        rule identifier, Name::Class, :pop!
+      end
+
+      state :raise do
+        rule %r/from\b/, Keyword
+        rule %r/raise\b/, Keyword
+        rule %r/yield\b/, Keyword
+        rule %r/\n/, Text, :pop!
+        rule %r/;/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :yield do
+        mixin :raise
+      end
+
+      state :generic_string do
+        rule %r/[^'"\\{]+/, Str
+        rule %r/{{/, Str
+
+        rule %r/'''|"""|['"]/ do |m|
+          token Str
+          if current_string.delim? m[0]
+            current_string.remove
+            pop!
+          end
+        end
+
+        rule %r/\\/ do |m|
+          if current_string.type? "r"
+            token Str
+          else
+            token Str::Interpol
+          end
+          push :generic_escape
+        end
+
+        rule %r/{/ do |m|
+          if current_string.type? "f"
+            token Str::Interpol
+            push :generic_interpol
+          else
+            token Str
+          end
+        end
+      end
+
+      state :generic_escape do
+        rule %r(
+          ( [\\abfnrtv"']
+          | \n
+          | N{[a-zA-Z][a-zA-Z ]+[a-zA-Z]}
+          | u[a-fA-F0-9]{4}
+          | U[a-fA-F0-9]{8}
+          | x[a-fA-F0-9]{2}
+          | [0-7]{1,3}
+          )
+        )x do
+          if current_string.type? "r"
+            token Str
+          else
+            token Str::Escape
+          end
+          pop!
+        end
+      end
+
+      state :generic_interpol do
+        rule %r/[^{}]+/ do |m|
+          recurse m[0]
+        end
+        rule %r/{/, Str::Interpol, :generic_interpol
+        rule %r/}/, Str::Interpol, :pop!
+      end
+
+      class StringRegister < Array
+        def delim?(delim)
+          self.last[1] == delim
+        end
+
+        def register(type: "u", delim: "'")
+          self.push [type, delim]
+        end
+
+        def remove
+          self.pop
+        end
+
+        def type?(type)
+          self.last[0].include? type
+        end
+      end
+
+      private_constant :StringRegister
+    end
+  end
+end