rugments 1.0.0.beta1

data/lib/rugments/lexers/properties.rb

@@ -0,0 +1,53 @@
+module Rugments
+  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/rugments/lexers/puppet.rb

@@ -0,0 +1,126 @@
+module Rugments
+  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/rugments/lexers/python.rb

@@ -0,0 +1,225 @@
+module Rugments
+  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
+        )
+      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 /(def)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :funcname
+        end
+
+        rule /(class)((?:\s|\\\s)+)/ do
+          groups Keyword, Text
+          push :classname
+        end
+
+        rule /(from)((?:\s|\\\s)+)/ do
+          groups Keyword::Namespace, Text
+          push :fromimport
+        end
+
+        rule /(import)((?:\s|\\\s)+)/ do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+
+        # TODO: not in python 3
+        rule /`.*?`/, Str::Backtick
+        rule /(?:r|ur|ru)"""/i, Str, :tdqs
+        rule /(?:r|ur|ru)'''/i, Str, :tsqs
+        rule /(?:r|ur|ru)"/i,   Str, :dqs
+        rule /(?:r|ur|ru)'/i,   Str, :sqs
+        rule /u?"""/i,          Str, :escape_tdqs
+        rule /u?'''/i,          Str, :escape_tsqs
+        rule /u?"/i,            Str, :escape_dqs
+        rule /u?'/i,            Str, :escape_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 :import do
+        # non-line-terminating whitespace
+        rule /(?:[ \t]|\\\n)+/, Text
+
+        rule /as\b/, Keyword::Namespace
+        rule /,/, Operator
+        rule dotted_identifier, Name::Namespace
+        rule(//) { pop! } # anything else -> go back
+      end
+
+      state :fromimport do
+        # non-line-terminating whitespace
+        rule /(?:[ \t]|\\\n)+/, Text
+
+        rule /import\b/, Keyword::Namespace, :pop!
+        rule dotted_identifier, Name::Namespace
+      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{.*?}
+          | 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 :dqs do
+        rule /"/, Str, :pop!
+        rule /\\\\|\\"|\\\n/, Str::Escape
+        mixin :strings_double
+      end
+
+      state :sqs do
+        rule /'/, Str, :pop!
+        rule /\\\\|\\'|\\\n/, Str::Escape
+        mixin :strings_single
+      end
+
+      state :tdqs do
+        rule /"""/, Str, :pop!
+        rule /"/, Str
+        mixin :strings_double
+        mixin :nl
+      end
+
+      state :tsqs do
+        rule /'''/, Str, :pop!
+        rule /'/, Str
+        mixin :strings_single
+        mixin :nl
+      end
+
+      %w(tdqs tsqs dqs sqs).each do |qtype|
+        state :"escape_#{qtype}" do
+          mixin :escape
+          mixin :"#{qtype}"
+        end
+      end
+    end
+  end
+end

data/lib/rugments/lexers/qml.rb

@@ -0,0 +1,70 @@
+module Rugments
+  module Lexers
+    load_const :Javascript, 'javascript.rb'
+    class Qml < Javascript
+      title 'QML'
+      desc 'QML, a UI markup language'
+      tag 'qml'
+      aliases 'qml'
+      filenames '*.qml'
+
+      mimetypes 'application/x-qml', 'text/x-qml'
+
+      id_with_dots = /[$a-zA-Z_][a-zA-Z0-9_.]*/
+
+      prepend :root do
+        rule /(#{id_with_dots})(\s*)({)/ do
+          groups Keyword::Type, Text, Punctuation
+          push :type_block
+        end
+        rule /(#{id_with_dots})(\s+)(on)(\s+)(#{id_with_dots})(\s*)({)/ do
+          groups Keyword::Type, Text, Keyword, Text, Name::Label, Text, Punctuation
+          push :type_block
+        end
+
+        rule /[{]/, Punctuation, :push
+      end
+
+      state :type_block do
+        rule /(id)(\s*)(:)(\s*)(#{id_with_dots})/ do
+          groups Name::Label, Text, Punctuation, Text, Keyword::Declaration
+        end
+
+        rule /(#{id_with_dots})(\s*)(:)/ do
+          groups Name::Label, Text, Punctuation
+          push :expr_start
+        end
+
+        rule /(signal)(\s+)(#{id_with_dots})/ do
+          groups Keyword::Declaration, Text, Name::Label
+          push :signal
+        end
+
+        rule /(property)(\s+)(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(:?)/ do
+          groups Keyword::Declaration, Text, Keyword::Type, Text, Name::Label, Text, Punctuation
+          push :expr_start
+        end
+
+        rule /[}]/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :signal do
+        mixin :comments_and_whitespace
+        rule /\(/ do
+          token Punctuation
+          goto :signal_args
+        end
+        rule //, Text, :pop!
+      end
+
+      state :signal_args do
+        mixin :comments_and_whitespace
+        rule /(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(,?)/ do
+          groups Keyword::Type, Text, Name, Text, Punctuation
+        end
+        rule /\)/, Punctuation, :pop!
+      end
+    end
+  end
+end

data/lib/rugments/lexers/r.rb

@@ -0,0 +1,55 @@
+module Rugments
+  module Lexers
+    class R < RegexLexer
+      title 'R'
+      desc 'The R statistics language (r-project.org)'
+      tag 'r'
+      aliases 'r', 'R', 's', 'S'
+      filenames '*.R', '*.S', '.Rhistory', '.Rprofile'
+      mimetypes 'text/x-r-source', 'text/x-r', 'text/x-R'
+
+      mimetypes 'text/x-r', 'application/x-r'
+
+      def self.keywords
+        @keywords ||= %w(
+          if else for while repeat in next break return switch function
+        )
+      end
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'Rscript'
+        return 0.1 if text.include? '->'
+      end
+
+      state :root do
+        rule /#.*?\n/, Comment::Single
+        rule /\s+/m, Text
+        rule /[.]?[a-zA-Z_][\w.]*/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule /`.*?`/, Str::Backtick
+        rule /'(\\.|.)*?'/m, Str::Single
+        rule /"(\\.|.)*?"/m, Str::Double
+
+        rule /\b(NULL|Inf|TRUE|FALSE|NaN)\b/, Keyword::Constant
+        rule /\bNA(_(integer|real|complex|character)_)?\b/,
+             Keyword::Constant
+        rule /\b[TF]\b/, Keyword::Variable
+
+        rule /0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?/, Num::Hex
+        rule /[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?[Li]?/,
+             Num
+
+        rule /[\[\]{}();,]/, Punctuation
+
+        rule %r{[-<>?*+^/!=~$@:%&|]}, Operator
+        rule /[.][.][.]/, Keyword
+      end
+    end
+  end
+end