rugments 1.0.0.beta1

data/lib/rugments/lexers/objective_c.rb

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

@@ -0,0 +1,109 @@
+module Rugments
+  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

data/lib/rugments/lexers/perl.rb

@@ -0,0 +1,195 @@
+module Rugments
+  module Lexers
+    class Perl < RegexLexer
+      title 'Perl'
+      desc 'The Perl scripting language (perl.org)'
+
+      tag 'perl'
+      aliases 'pl'
+
+      filenames '*.pl', '*.pm'
+      mimetypes 'text/x-perl', 'application/x-perl'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'perl'
+        return 0.4 if text.include? 'my $'
+      end
+
+      keywords = %w(
+        case continue do else elsif for foreach if last my next our
+        redo reset then unless until while use print new BEGIN CHECK
+        INIT END return
+      )
+
+      builtins = %w(
+        abs accept alarm atan2 bind binmode bless caller chdir chmod
+        chomp chop chown chr chroot close closedir connect continue cos
+        crypt dbmclose dbmopen defined delete die dump each endgrent
+        endhostent endnetent endprotoent endpwent endservent eof eval
+        exec exists exit exp fcntl fileno flock fork format formline getc
+        getgrent getgrgid getgrnam gethostbyaddr gethostbyname gethostent
+        getlogin getnetbyaddr getnetbyname getnetent getpeername
+        getpgrp getppid getpriority getprotobyname getprotobynumber
+        getprotoent getpwent getpwnam getpwuid getservbyname getservbyport
+        getservent getsockname getsockopt glob gmtime goto grep hex
+        import index int ioctl join keys kill last lc lcfirst length
+        link listen local localtime log lstat map mkdir msgctl msgget
+        msgrcv msgsnd my next no oct open opendir ord our pack package
+        pipe pop pos printf prototype push quotemeta rand read readdir
+        readline readlink readpipe recv redo ref rename require reverse
+        rewinddir rindex rmdir scalar seek seekdir select semctl semget
+        semop send setgrent sethostent setnetent setpgrp setpriority
+        setprotoent setpwent setservent setsockopt shift shmctl shmget
+        shmread shmwrite shutdown sin sleep socket socketpair sort splice
+        split sprintf sqrt srand stat study substr symlink syscall sysopen
+        sysread sysseek system syswrite tell telldir tie tied time times
+        tr truncate uc ucfirst umask undef unlink unpack unshift untie
+        utime values vec wait waitpid wantarray warn write
+      )
+
+      re_tok = Str::Regex
+
+      state :balanced_regex do
+        rule %r{/(\\\\|\\/|[^/])*/[egimosx]*}m, re_tok, :pop!
+        rule %r{!(\\\\|\\!|[^!])*![egimosx]*}m, re_tok, :pop!
+        rule %r{\\(\\\\|[^\\])*\\[egimosx]*}m, re_tok, :pop!
+        rule %r({(\\\\|\\}|[^}])*}[egimosx]*), re_tok, :pop!
+        rule %r{<(\\\\|\\>|[^>])*>[egimosx]*}, re_tok, :pop!
+        rule %r{\[(\\\\|\\\]|[^\]])*\][egimosx]*}, re_tok, :pop!
+        rule %r{\((\\\\|\\\)|[^\)])*\)[egimosx]*}, re_tok, :pop!
+        rule %r{@(\\\\|\\\@|[^\@])*@[egimosx]*}, re_tok, :pop!
+        rule %r{%(\\\\|\\\%|[^\%])*%[egimosx]*}, re_tok, :pop!
+        rule %r{\$(\\\\|\\\$|[^\$])*\$[egimosx]*}, re_tok, :pop!
+      end
+
+      state :root do
+        rule /#.*?$/, Comment::Single
+        rule /^=[a-zA-Z0-9]+\s+.*?\n=cut/, Comment::Multiline
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+
+        rule /(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
+          groups Keyword, Text, Name, Text, Punctuation, Text
+
+          push :format
+        end
+
+        rule /(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
+
+        # common delimiters
+        rule %r{s/(\\\\|\\/|[^/])*/(\\\\|\\/|[^/])*/[egimosx]*}, re_tok
+        rule %r{s!(\\\\|\\!|[^!])*!(\\\\|\\!|[^!])*![egimosx]*}, re_tok
+        rule %r{s\\(\\\\|[^\\])*\\(\\\\|[^\\])*\\[egimosx]*}, re_tok
+        rule %r{s@(\\\\|\\@|[^@])*@(\\\\|\\@|[^@])*@[egimosx]*}, re_tok
+        rule %r{s%(\\\\|\\%|[^%])*%(\\\\|\\%|[^%])*%[egimosx]*}, re_tok
+
+        # balanced delimiters
+        rule %r(s{(\\\\|\\}|[^}])*}\s*), re_tok, :balanced_regex
+        rule %r{s<(\\\\|\\>|[^>])*>\s*}, re_tok, :balanced_regex
+        rule %r{s\[(\\\\|\\\]|[^\]])*\]\s*}, re_tok, :balanced_regex
+        rule %r{s\((\\\\|\\\)|[^\)])*\)\s*}, re_tok, :balanced_regex
+
+        rule %r{m?/(\\\\|\\/|[^/\n])*/[gcimosx]*}, re_tok
+        rule %r(m(?=[/!\\{<\[\(@%\$])), re_tok, :balanced_regex
+        rule %r{((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[gcimosx]*},
+             re_tok, :balanced_regex
+
+        rule /\s+/, Text
+        rule /(?:#{builtins.join('|')})\b/, Name::Builtin
+        rule /((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b/,
+             Name::Builtin::Pseudo
+
+        rule /<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
+
+        rule /__END__\b/, Comment::Preproc, :end_part
+        rule /\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
+        rule /\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
+        rule /[$@%#]+/, Name::Variable, :varname
+
+        rule /0_?[0-7]+(_[0-7]+)*/, Num::Oct
+        rule /0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
+        rule /0b[01]+(_[01]+)*/, Num::Bin
+        rule /(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
+             Num::Float
+        rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
+        rule /\d+(_\d+)*/, Num::Integer
+
+        rule /'(\\\\|\\'|[^'])*'/, Str
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /`(\\\\|\\`|[^`])*`/, Str::Backtick
+        rule /<([^\s>]+)>/, re_tok
+        rule /(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
+        rule /(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
+        rule /(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
+        rule /(q|qq|qw|qr|qx)</, Str::Other, :lt_string
+        rule /(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
+
+        rule /package\s+/, Keyword, :modulename
+        rule /sub\s+/, Keyword, :funcname
+        rule /\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
+             Operator
+        rule /[-+\/*%=<>&^\|!\\~]=?/, Operator
+        rule /[()\[\]:;,<>\/?{}]/, Punctuation
+        rule(/(?=\w)/) { push :name }
+      end
+
+      state :format do
+        rule /\.\n/, Str::Interpol, :pop!
+        rule /.*?\n/, Str::Interpol
+      end
+
+      state :name_common do
+        rule /\w+::/, Name::Namespace
+        rule /[\w:]+/, Name::Variable, :pop!
+      end
+
+      state :varname do
+        rule /\s+/, Text
+        rule /\{/, Punctuation, :pop! # hash syntax
+        rule /\)|,/, Punctuation, :pop! # arg specifier
+        mixin :name_common
+      end
+
+      state :name do
+        mixin :name_common
+        rule /[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
+        rule(/(?=\W)/) { pop! }
+      end
+
+      state :modulename do
+        rule /[a-z_]\w*/i, Name::Namespace, :pop!
+      end
+
+      state :funcname do
+        rule /[a-zA-Z_]\w*[!?]?/, Name::Function
+        rule /\s+/, Text
+
+        # argument declaration
+        rule /(\([$@%]*\))(\s*)/ do
+          groups Punctuation, Text
+        end
+
+        rule /.*?{/, Punctuation, :pop!
+        rule /;/, Punctuation, :pop!
+      end
+
+      [[:cb, '\{', '\}'],
+       [:rb, '\(', '\)'],
+       [:sb, '\[', '\]'],
+       [:lt, '<',  '>']].each do |name, open, close|
+        tok = Str::Other
+        state :"#{name}_string" do
+          rule /\\[#{open}#{close}\\]/, tok
+          rule /\\/, tok
+          rule(/#{open}/) { token tok; push }
+          rule /#{close}/, tok, :pop!
+          rule /[^#{open}#{close}\\]+/, tok
+        end
+      end
+
+      state :end_part do
+        # eat the rest of the stream
+        rule /.+/m, Comment::Preproc, :pop!
+      end
+    end
+  end
+end