gitlab-rouge 1.9.2

data/lib/rouge/lexers/nginx.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Nginx < RegexLexer
+      title "nginx"
+      desc 'configuration files for the nginx web server (nginx.org)'
+      tag 'nginx'
+      mimetypes 'text/x-nginx-conf'
+      filenames 'nginx.conf'
+
+      id = /[^\s$;{}()#]+/
+
+      state :root do
+        rule /(include)(\s+)([^\s;]+)/ do
+          groups Keyword, Text, Name
+        end
+
+        rule id, Keyword, :statement
+
+        mixin :base
+      end
+
+      state :block do
+        rule /}/, Punctuation, :pop!
+        rule id, Keyword::Namespace, :statement
+        mixin :base
+      end
+
+      state :statement do
+        rule /{/ do
+          token Punctuation; pop!; push :block
+        end
+
+        rule /;/, Punctuation, :pop!
+
+        mixin :base
+      end
+
+      state :base do
+        rule /\s+/, Text
+
+        rule /#.*?\n/, Comment::Single
+        rule /(?:on|off)\b/, Name::Constant
+        rule /[$][\w-]+/, Name::Variable
+
+        # host/port
+        rule /([a-z0-9.-]+)(:)([0-9]+)/i do
+          groups Name::Function, Punctuation, Num::Integer
+        end
+
+        # mimetype
+        rule %r([a-z-]+/[a-z-]+)i, Name::Class
+
+        rule /[0-9]+[kmg]?\b/i, Num::Integer
+        rule /(~)(\s*)([^\s{]+)/ do
+          groups Punctuation, Text, Str::Regex
+        end
+
+        rule /[:=~]/, Punctuation
+
+        # pathname
+        rule %r(/#{id}?), Name
+
+        rule /[^#\s;{}$\\]+/, Str # catchall
+
+        rule /[$;]/, Text
+      end
+    end
+  end
+end

data/lib/rouge/lexers/nim.rb

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Nim < RegexLexer
+      # This is pretty much a 1-1 port of the pygments NimrodLexer class
+      title "Nim"
+      desc "The Nim programming language (http://nim-lang.org/)"
+
+      tag 'nim'
+      aliases 'nimrod'
+      filenames '*.nim'
+
+      KEYWORDS = %w(
+        addr as asm atomic bind block break case cast const continue
+        converter defer discard distinct do elif else end enum except export
+        func finally for from generic if import include interface iterator let
+        macro method mixin nil object of out proc ptr raise ref return static
+        template try tuple type using var when while with without yield
+      )
+
+      OPWORDS = %w(
+        and or not xor shl shr div mod in notin is isnot
+      )
+
+      PSEUDOKEYWORDS = %w(
+        nil true false
+      )
+
+      TYPES = %w(
+       int int8 int16 int32 int64 float float32 float64 bool char range array
+       seq set string
+      )
+
+      NAMESPACE = %w(
+        from import include
+      )
+
+      def self.underscorize(words)
+        words.map do |w|
+          w.gsub(/./) { |x| "#{Regexp.escape(x)}_?" }
+        end.join('|')
+      end
+
+      state :chars do
+        rule(/\\([\\abcefnrtvl"\']|x[a-fA-F0-9]{2}|[0-9]{1,3})/, Str::Escape)
+        rule(/'/, Str::Char, :pop!)
+        rule(/./, Str::Char)
+      end
+
+      state :strings do
+        rule(/(?<!\$)\$(\d+|#|\w+)+/, Str::Interpol)
+        rule(/[^\\\'"\$\n]+/,         Str)
+        rule(/[\'"\\]/,               Str)
+        rule(/\$/,                    Str)
+      end
+
+      state :dqs do
+        rule(/\\([\\abcefnrtvl"\']|\n|x[a-fA-F0-9]{2}|[0-9]{1,3})/,
+             Str::Escape)
+        rule(/"/, Str, :pop!)
+        mixin :strings
+      end
+
+      state :rdqs do
+        rule(/"(?!")/, Str, :pop!)
+        rule(/"/,      Str::Escape, :pop!)
+        mixin :strings
+      end
+
+      state :tdqs do
+        rule(/"""(?!")/, Str, :pop!)
+        mixin :strings
+        mixin :nl
+      end
+
+      state :funcname do
+        rule(/((?![\d_])\w)(((?!_)\w)|(_(?!_)\w))*/, Name::Function, :pop!)
+        rule(/`.+`/,                                 Name::Function, :pop!)
+      end
+
+      state :nl do
+        rule(/\n/, Str)
+      end
+
+      state :floatnumber do
+        rule(/\.(?!\.)[0-9_]*/,       Num::Float)
+        rule(/[eE][+-]?[0-9][0-9_]*/, Num::Float)
+        rule(//,                      Text, :pop!)
+      end
+
+      # Making apostrophes optional, as only hexadecimal with type suffix
+      # possibly ambiguous.
+      state :floatsuffix do
+        rule(/'?[fF](32|64)/,          Num::Float)
+        rule(//,                      Text, :pop!)
+      end
+
+      state :intsuffix do
+        rule(/'?[iI](32|64)/,          Num::Integer::Long)
+        rule(/'?[iI](8|16)/,           Num::Integer)
+        rule(/'?[uU]/,                 Num::Integer)
+        rule(//,                      Text, :pop!)
+      end
+
+      state :root do
+        rule(/##.*$/, Str::Doc)
+        rule(/#.*$/,  Comment)
+        rule(/\*|=|>|<|\+|-|\/|@|\$|~|&|%|\!|\?|\||\\|\[|\]/, Operator)
+        rule(/\.\.|\.|,|\[\.|\.\]|{\.|\.}|\(\.|\.\)|{|}|\(|\)|:|\^|`|;/,
+             Punctuation)
+
+        # Strings
+        rule(/(?:[\w]+)"/,Str, :rdqs)
+        rule(/"""/,       Str, :tdqs)
+        rule(/"/,         Str, :dqs)
+
+        # Char
+        rule(/'/, Str::Char, :chars)
+
+        # Keywords
+        rule(%r[(#{Nim.underscorize(OPWORDS)})\b], Operator::Word)
+        rule(/(p_?r_?o_?c_?\s)(?![\(\[\]])/, Keyword, :funcname)
+        rule(%r[(#{Nim.underscorize(KEYWORDS)})\b],  Keyword)
+        rule(%r[(#{Nim.underscorize(NAMESPACE)})\b], Keyword::Namespace)
+        rule(/(v_?a_?r)\b/, Keyword::Declaration)
+        rule(%r[(#{Nim.underscorize(TYPES)})\b],          Keyword::Type)
+        rule(%r[(#{Nim.underscorize(PSEUDOKEYWORDS)})\b], Keyword::Pseudo)
+        # Identifiers
+        rule(/\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*/, Name)
+
+        # Numbers
+        # Note: Have to do this with a block to push multiple states first,
+        #       since we can't pass array of states like w/ Pygments.
+        rule(/[0-9][0-9_]*(?=([eE.]|'?[fF](32|64)))/) do |number|
+         push :floatsuffix
+         push :floatnumber
+         token Num::Float
+        end
+        rule(/0[xX][a-fA-F0-9][a-fA-F0-9_]*/, Num::Hex,     :intsuffix)
+        rule(/0[bB][01][01_]*/,               Num,          :intsuffix)
+        rule(/0o[0-7][0-7_]*/,                Num::Oct,     :intsuffix)
+        rule(/[0-9][0-9_]*/,                  Num::Integer, :intsuffix)
+
+        # Whitespace
+        rule(/\s+/, Text)
+        rule(/.+$/, Error)
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/objective_c.rb

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_const :C, 'c.rb'
+
+    class ObjectiveC < C
+      tag 'objective_c'
+      title "Objective-C"
+      desc 'an extension of C commonly used to write Apple software'
+      aliases 'objc'
+      filenames '*.m', '*.h'
+
+      mimetypes 'text/x-objective_c', 'application/x-objective_c'
+
+      def self.at_keywords
+        @at_keywords ||= %w(
+          selector private protected public encode synchronized try
+          throw catch finally end property synthesize dynamic optional
+          interface implementation import
+        )
+      end
+
+      def self.at_builtins
+        @at_builtins ||= %w(true false YES NO)
+      end
+
+      def self.builtins
+        @builtins ||= %w(YES NO nil)
+      end
+
+      def self.analyze_text(text)
+        return 1 if text =~ /@(end|implementation|protocol|property)\b/
+
+        id = /[a-z$_][a-z0-9$_]*/i
+        return 0.4 if text =~ %r(
+          \[ \s* #{id} \s+
+          (?:
+            #{id} \s* \]
+            | #{id}? :
+          )
+        )x
+        return 0.4 if text.include? '@"'
+      end
+
+      id = /[a-z$_][a-z0-9$_]*/i
+
+      prepend :statements do
+        rule /@"/, Str, :string
+        rule /@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/,
+          Str::Char
+        rule /@(\d+[.]\d*|[.]\d+|\d+)e[+-]?\d+l?/i,
+          Num::Float
+        rule /@(\d+[.]\d*|[.]\d+|\d+f)f?/i, Num::Float
+        rule /@0x\h+[lL]?/, Num::Hex
+        rule /@0[0-7]+l?/i, Num::Oct
+        rule /@\d+l?/, Num::Integer
+        rule /\bin\b/, Keyword
+
+        rule /@(?:interface|implementation)\b/ do
+          token Keyword
+          goto :classname
+        end
+
+        rule /@(?:class|protocol)\b/ do
+          token Keyword
+          goto :forward_classname
+        end
+
+        rule /@([[:alnum:]]+)/ do |m|
+          if self.class.at_keywords.include? m[1]
+            token Keyword
+          elsif self.class.at_builtins.include? m[1]
+            token Name::Builtin
+          else
+            token Error
+          end
+        end
+
+        rule /[?]/, Punctuation, :ternary
+        rule /\[/,  Punctuation, :message
+        rule /@\[/, Punctuation, :array_literal
+      end
+
+      state :ternary do
+        rule /:/, Punctuation, :pop!
+        mixin :statements
+      end
+
+      state :message_shared do
+        rule /\]/, Punctuation, :pop!
+        rule /;/, Error
+
+        mixin :statement
+      end
+
+      state :message do
+        rule /(#{id})(\s*)(:)/ do
+          groups(Name::Function, Text, Punctuation)
+          goto :message_with_args
+        end
+
+        rule /(#{id})(\s*)(\])/ do
+          groups(Name::Function, Text, Punctuation)
+          pop!
+        end
+
+        mixin :message_shared
+      end
+
+      state :message_with_args do
+        rule /(#{id})(\s*)(:)/ do
+          groups(Name::Function, Text, Punctuation)
+        end
+
+        mixin :message_shared
+      end
+
+      state :array_literal do
+        rule /]/, Punctuation, :pop!
+        rule /,/, Punctuation
+        mixin :statements
+      end
+
+      state :classname do
+        mixin :whitespace
+
+        rule /(#{id})(\s*)(:)(\s*)(#{id})/ do
+          groups(Name::Class, Text,
+                 Punctuation, Text,
+                 Name::Class)
+          pop!
+        end
+
+        rule /(#{id})(\s*)([(])(\s*)(#{id})(\s*)([)])/ do
+          groups(Name::Class, Text,
+                 Punctuation, Text,
+                 Name::Label, Text,
+                 Punctuation)
+        end
+
+        rule id, Name::Class, :pop!
+      end
+
+      state :forward_classname do
+        mixin :whitespace
+
+        rule /(#{id})(\s*)(,)(\s*)/ do
+          groups(Name::Class, Text, Punctuation, Text)
+          push
+        end
+
+        rule /(#{id})(\s*)(;?)/ do
+          groups(Name::Class, Text, Punctuation)
+          pop!
+        end
+      end
+
+      prepend :root do
+        rule %r(
+          ([-+])(\s*)
+          ([(].*?[)])?(\s*)
+          (?=#{id}:?)
+        )ix do |m|
+          token Keyword, m[1]; token Text, m[2]
+          recurse m[3]; token Text, m[4]
+          push :method_definition
+        end
+      end
+
+      state :method_definition do
+        rule /,/, Punctuation
+        rule /[.][.][.]/, Punctuation
+        rule /([(].*?[)])(#{id})/ do |m|
+          recurse m[1]; token Name::Variable, m[2]
+        end
+
+        rule /(#{id})(\s*)(:)/m do
+          groups(Name::Function, Text, Punctuation)
+        end
+
+        rule /;/, Punctuation, :pop!
+
+        rule /{/ do
+          token Punctuation
+          goto :function
+        end
+
+        mixin :inline_whitespace
+        rule %r(//.*?\n), Comment::Single
+        rule /\s+/m, Text
+
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/ocaml.rb

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class OCaml < RegexLexer
+      title "OCaml"
+      desc 'Objective CAML (ocaml.org)'
+      tag 'ocaml'
+      filenames '*.ml', '*.mli', '*.mll', '*.mly'
+      mimetypes 'text/x-ocaml'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          as assert begin class constraint do done downto else end
+          exception external false for fun function functor if in include
+          inherit initializer lazy let match method module mutable new
+          object of open private raise rec sig struct then to true try
+          type value val virtual when while with
+        )
+      end
+
+      def self.keyopts
+        @keyopts ||= Set.new %w(
+          != # & && ( ) * \+ , - -. -> . .. : :: := :> ; ;; < <- =
+          > >] >} ? ?? [ [< [> [| ] _ ` { {< | |] } ~
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(and asr land lor lsl lxor mod or)
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(unit int float bool string char list array)
+      end
+
+      operator = %r([\[\];,{}_()!$%&*+./:<=>?@^|~#-]+)
+      id = /[a-z][\w']*/i
+      upper_id = /[A-Z][\w']*/
+
+      state :root do
+        rule /\s+/m, Text
+        rule /false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule /#{upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+        rule upper_id, Name::Class
+        rule /[(][*](?![)])/, Comment, :comment
+        rule id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule operator do |m|
+          match = m[0]
+          if self.class.keyopts.include? match
+            token Punctuation
+          else
+            token Operator
+          end
+        end
+
+        rule /-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule /0x\h[\h_]*/i, Num::Hex
+        rule /0o[0-7][0-7_]*/i, Num::Oct
+        rule /0b[01][01_]*/i, Num::Bin
+        rule /\d[\d_]*/, Num::Integer
+
+        rule /'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule /'[.]'/, Str::Char
+        rule /'/, Keyword
+        rule /"/, Str::Double, :string
+        rule /[~?]#{id}/, Name::Variable
+      end
+
+      state :comment do
+        rule /[^(*)]+/, Comment
+        rule(/[(][*]/) { token Comment; push }
+        rule /[*][)]/, Comment, :pop!
+        rule /[(*)]/, Comment
+      end
+
+      state :string do
+        rule /[^\\"]+/, Str::Double
+        mixin :escape_sequence
+        rule /\\\n/, Str::Double
+        rule /"/, Str::Double, :pop!
+      end
+
+      state :escape_sequence do
+        rule /\\[\\"'ntbr]/, Str::Escape
+        rule /\\\d{3}/, Str::Escape
+        rule /\\x\h{2}/, Str::Escape
+      end
+
+      state :dotted do
+        rule /\s+/m, Text
+        rule /[.]/, Punctuation
+        rule /#{upper_id}(?=\s*[.])/, Name::Namespace
+        rule upper_id, Name::Class, :pop!
+        rule id, Name, :pop!
+      end
+    end
+  end
+end