rougegal 2.1.2

data/lib/rouge/lexers/properties.rb

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

data/lib/rouge/lexers/protobuf.rb

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*- #
+
+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 /[\s]+/, Text
+        rule /[,;{}\[\]()]/, Punctuation
+        rule /\/(\\\n)?\/(\n|(.|\n)*?[^\\]\n)/, Comment::Single
+        rule /\/(\\\n)?\*(.|\n)*?\*(\\\n)?\//, Comment::Multiline
+        rule kw, Keyword
+        rule datatype, Keyword::Type
+        rule /true|false/, Keyword::Constant
+        rule /(package)(\s+)/ do
+          groups Keyword::Namespace, Text
+          push :package
+        end
+
+        rule /(message|extend)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :message
+        end
+
+        rule /(enum|group|service)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :type
+        end
+
+        rule /".*?"/, Str
+        rule /'.*?'/, Str
+        rule /(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*/, Num::Float
+        rule /(\d+\.\d*|\.\d+|\d+[fF])[fF]?/, Num::Float
+        rule /(\-?(inf|nan))\b/, Num::Float
+        rule /0x[0-9a-fA-F]+[LlUu]*/, Num::Hex
+        rule /0[0-7]+[LlUu]*/, Num::Oct
+        rule /\d+[LlUu]*/, Num::Integer
+        rule /[+-=]/, Operator
+        rule /([a-zA-Z_][\w.]*)([ \t]*)(=)/ do
+          groups Name::Attribute, Text, Operator
+        end
+        rule /[a-zA-Z_][\w.]*/, Name
+      end
+
+      state :package do
+        rule /[a-zA-Z_]\w*/, Name::Namespace, :pop!
+        rule(//) { pop! }
+      end
+
+      state :message do
+        rule /[a-zA-Z_]\w*/, Name::Class, :pop!
+        rule(//) { pop! }
+      end
+
+      state :type do
+        rule /[a-zA-Z_]\w*/, Name, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/puppet.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*- #
+
+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.analyze_text(text)
+        return 1 if text.shebang? 'puppet-apply'
+        return 1 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 /\s+/m, Text
+        rule /#.*?\n/, Comment
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule /[$]#{qualname}/, Name::Variable
+        rule /(#{id})(?=\s*[=+]>)/m do |m|
+          if self.class.metaparameters.include? m[0]
+            token Keyword::Pseudo
+          else
+            token Name::Property
+          end
+        end
+
+        rule /(#{qualname})(?=\s*[(])/m, Name::Function
+        rule cap_id, Name::Class
+
+        rule /[+=|~-]>|<[|~-]/, Punctuation
+        rule /[:}();\[\]]/, Punctuation
+
+        # HACK for case statements and selectors
+        rule /{/, Punctuation, :regex_allowed
+        rule /,/, Punctuation, :regex_allowed
+
+        rule /(in|and|or)\b/, Operator::Word
+        rule /[=!<>]=/, Operator
+        rule /[=!]~/, Operator, :regex_allowed
+        rule %r([<>!+*/-]), Operator
+
+        rule /(class|include)(\s*)(#{qualname})/ do
+          groups Keyword, Text, Name::Class
+        end
+
+        rule /node\b/, Keyword, :regex_allowed
+
+        rule /'(\\[\\']|[^'])*'/m, Str::Single
+        rule /"/, Str::Double, :dquotes
+
+        rule /\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 /\\./, Str::Escape
+        rule /[(){}]/, Str::Interpol
+        rule /\[/, Str::Interpol, :regex_class
+        rule /./, Str::Regex
+      end
+
+      state :regex_class do
+        rule /\]/, Str::Interpol, :pop!
+        rule /(?<!\[)-(?=\])/, Str::Regex
+        rule /-/, Str::Interpol
+        rule /\\./, Str::Escape
+        rule /[^\\\]-]+/, Str::Regex
+      end
+
+      state :dquotes do
+        rule /"/, Str::Double, :pop!
+        rule /[^$\\"]+/m, Str::Double
+        rule /\\./m, Str::Escape
+        rule /[$]#{qualname}/, Name::Variable
+        rule /[$][{]#{qualname}[}]/, Name::Variable
+      end
+    end
+  end
+end

data/lib/rouge/lexers/python.rb

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*- #
+
+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'
+      mimetypes 'text/x-python', 'application/x-python'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang?(/pythonw?(3|2(\.\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
+        )
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          __import__ abs all any apply basestring bin bool buffer
+          bytearray bytes callable chr classmethod cmp coerce compile
+          complex delattr dict dir divmod enumerate eval execfile exit
+          file filter float frozenset getattr globals hasattr hash hex id
+          input int intern isinstance issubclass iter len list locals
+          long map max 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 DeprecationWarning EOFError EnvironmentError
+          Exception FloatingPointError FutureWarning GeneratorExit IOError
+          ImportError ImportWarning IndentationError IndexError KeyError
+          KeyboardInterrupt LookupError MemoryError NameError
+          NotImplemented NotImplementedError OSError OverflowError
+          OverflowWarning PendingDeprecationWarning ReferenceError
+          RuntimeError RuntimeWarning StandardError StopIteration
+          SyntaxError SyntaxWarning SystemError SystemExit TabError
+          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
+      state :root do
+        rule /\n+/m, Text
+        rule /^(:)(\s*)([ru]{,2}""".*?""")/mi do
+          groups Punctuation, Text, Str::Doc
+        end
+
+        rule /[^\S\n]+/, Text
+        rule /#.*$/, Comment
+        rule /[\[\]{}:(),;]/, Punctuation
+        rule /\\\n/, Text
+        rule /\\/, Text
+
+        rule /(in|is|and|or|not)\b/, Operator::Word
+        rule /!=|==|<<|>>|[-~+\/*%=<>&^|.]/, Operator
+
+        rule /(from)((?:\\\s|\s)+)(#{dotted_identifier})((?:\\\s|\s)+)(import)/ do
+          groups Keyword::Namespace,
+                 Text,
+                 Name::Namespace,
+                 Text,
+                 Keyword::Namespace
+        end
+
+        rule /(import)(\s+)(#{dotted_identifier})/ do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
+
+        rule /(def)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :funcname
+        end
+
+        rule /(class)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :classname
+        end
+
+        # TODO: not in python 3
+        rule /`.*?`/, Str::Backtick
+        rule /(?:r|ur|ru)"""/i, Str, :raw_tdqs
+        rule /(?:r|ur|ru)'''/i, Str, :raw_tsqs
+        rule /(?:r|ur|ru)"/i,   Str, :raw_dqs
+        rule /(?:r|ur|ru)'/i,   Str, :raw_sqs
+        rule /u?"""/i,          Str, :tdqs
+        rule /u?'''/i,          Str, :tsqs
+        rule /u?"/i,            Str, :dqs
+        rule /u?'/i,            Str, :sqs
+
+        rule /@#{dotted_identifier}/i, Name::Decorator
+
+        # using negative lookbehind so we don't match property names
+        rule /(?<!\.)#{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
+
+        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
+        rule /\d+e[+-]?[0-9]+/i, Num::Float
+        rule /0[0-7]+/, Num::Oct
+        rule /0x[a-f0-9]+/i, Num::Hex
+        rule /\d+L/, Num::Integer::Long
+        rule /\d+/, 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 /from\b/, Keyword
+        rule /raise\b/, Keyword
+        rule /yield\b/, Keyword
+        rule /\n/, Text, :pop!
+        rule /;/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :yield do
+        mixin :raise
+      end
+
+      state :strings do
+        rule /%(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, Str::Interpol
+      end
+
+      state :strings_double do
+        rule /[^\\"%\n]+/, Str
+        mixin :strings
+      end
+
+      state :strings_single do
+        rule /[^\\'%\n]+/, Str
+        mixin :strings
+      end
+
+      state :nl do
+        rule /\n/, Str
+      end
+
+      state :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, Str::Escape
+      end
+
+      state :raw_escape do
+        rule /\\./, Str
+      end
+
+      state :dqs do
+        rule /"/, Str, :pop!
+        mixin :escape
+        mixin :strings_double
+      end
+
+      state :sqs do
+        rule /'/, Str, :pop!
+        mixin :escape
+        mixin :strings_single
+      end
+
+      state :tdqs do
+        rule /"""/, Str, :pop!
+        rule /"/, Str
+        mixin :escape
+        mixin :strings_double
+        mixin :nl
+      end
+
+      state :tsqs do
+        rule /'''/, Str, :pop!
+        rule /'/, Str
+        mixin :escape
+        mixin :strings_single
+        mixin :nl
+      end
+
+      %w(tdqs tsqs dqs sqs).each do |qtype|
+        state :"raw_#{qtype}" do
+          mixin :raw_escape
+          mixin :"#{qtype}"
+        end
+      end
+
+    end
+  end
+end