rouge 1.10.1 → 1.11.0

data/lib/rouge/lexers/coffeescript.rb

@@ -43,7 +43,7 @@ module Rouge
       state :comments_and_whitespace do
         rule /\s+/m, Text
         rule /###.*?###/m, Comment::Multiline
-        rule /#.*?\n/, Comment::Single
+        rule /#.*$/, Comment::Single
       end
 
       state :multiline_regex do

data/lib/rouge/lexers/coq.rb

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Coq < RegexLexer
+      title "Coq"
+      desc 'Coq (coq.inria.fr)'
+      tag 'coq'
+      mimetypes 'text/x-coq'
+
+      def self.analyze_text(text)
+        return 0.3 if text.include? "Require"
+      end
+
+      def self.gallina
+        @gallina ||= Set.new %w(
+          as fun if in let match then else return end Type Set Prop
+          forall
+        )
+      end
+
+      def self.coq
+        @coq ||= Set.new %w(
+          Definition Theorem Lemma Remark Example Fixpoint CoFixpoint
+          Record Inductive CoInductive Corollary Goal Proof
+          Ltac Require Import Export Module Section End Variable
+          Context Polymorphic Monomorphic Universe Universes
+          Variables Class Instance Global Local Include
+          Printing Notation Infix Arguments Hint Rewrite Immediate
+          Qed Defined Opaque Transparent Existing
+          Compute Eval Print SearchAbout Search About Check
+        )
+      end
+
+      def self.ltac
+        @ltac ||= Set.new %w(
+          apply eapply auto eauto rewrite setoid_rewrite
+          with in as at destruct split inversion injection
+          intro intros unfold fold cbv cbn lazy subst
+          clear symmetry transitivity etransitivity erewrite
+          edestruct constructor econstructor eexists exists
+          f_equal refine instantiate revert simpl
+          specialize generalize dependent red induction
+          beta iota zeta delta exfalso autorewrite setoid_rewrite
+          compute vm_compute native_compute
+        )
+      end
+
+      def self.tacticals
+        @tacticals ||= Set.new %w(
+          repeat first try
+        )
+      end
+
+      def self.terminators
+        @terminators ||= Set.new %w(
+          omega solve congruence reflexivity exact
+          assumption eassumption
+        )
+      end
+
+      def self.keyopts
+        @keyopts ||= Set.new %w(
+          := => -> /\\ \\/ _ ; :> :
+        )
+      end
+
+      def self.end_sentence
+        @end_sentence ||= Punctuation::Indicator
+      end
+
+      def self.classify(x)
+        if self.coq.include? x
+          return Keyword
+        elsif self.gallina.include? x
+          return Keyword::Reserved
+        elsif self.ltac.include? x
+          return Keyword::Pseudo
+        elsif self.terminators.include? x
+          return Name::Exception
+        elsif self.tacticals.include? x
+          return Keyword::Pseudo
+        else
+          return Name::Constant
+        end
+      end
+
+      operator = %r([\[\];,{}_()!$%&*+./:<=>?@^|~#-]+)
+      id = /(?:[a-z][\w']*)|(?:[_a-z][\w']+)/i
+      dot_id = /\.((?:[a-z][\w']*)|(?:[_a-z][\w']+))/i
+      dot_space = /\.(\s+)/
+      module_type = /Module(\s+)Type(\s+)/
+      set_options = /(Set|Unset)(\s+)(Universe|Printing|Implicit|Strict)(\s+)(Polymorphism|All|Notations|Arguments|Universes|Implicit)(\s*)\./m
+
+      state :root do
+        rule /[(][*](?![)])/, Comment, :comment
+        rule /\s+/m, Text::Whitespace
+        rule module_type do |m|
+          token Keyword , 'Module'
+          token Text::Whitespace , m[1]
+          token Keyword , 'Type'
+          token Text::Whitespace , m[2]
+        end
+        rule set_options do |m|
+          token Keyword , m[1]
+          i = 2
+          while m[i] != ''
+            token Text::Whitespace , m[i]
+            token Keyword , m[i+1]
+            i += 2
+          end
+          token self.class.end_sentence , '.'
+        end
+        rule id do |m|
+          @name = m[0]
+          @continue = false
+          push :continue_id
+        end
+        rule /\/\\/, Operator
+        rule /\\\//, Operator
+        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 /\d[\d_]*/, Num::Integer
+
+        rule /'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, 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 :continue_id do
+        # the stream starts with an id (stored in @name) and continues here
+        rule dot_id do |m|
+          token Name::Namespace , @name
+          token Punctuation , '.'
+          @continue = true
+          @name = m[1]
+        end
+        rule dot_space do |m|
+          if @continue
+            token Name::Constant , @name
+          else
+            token self.class.classify(@name) , @name
+          end
+          token self.class.end_sentence , '.'
+          token Text::Whitespace , m[1]
+          @name = false
+          @continue = false
+          pop!
+        end
+        rule // do
+          if @continue
+            token Name::Constant , @name
+          else
+            token self.class.classify(@name) , @name
+          end
+          @name = false
+          @continue = false
+          pop!
+        end
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/cpp.rb

@@ -24,6 +24,15 @@ module Rouge
           friend mutable namespace new operator private protected public
           reinterpret_cast restrict static_cast template this throw
           throws typeid typename using virtual
+
+          alignas alignof constexpr decltype noexcept static_assert
+          thread_local try
+        ))
+      end
+
+      def self.keywords_type
+        @keywords_type ||= super + Set.new(%w(
+          bool
         ))
       end
 
@@ -34,7 +43,7 @@ module Rouge
         ))
       end
 
-      id = /[a-zA-Z_][a-zA-Z0-9]*/
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       prepend :root do
         # Offload C++ extensions, http://offload.codeplay.com/
@@ -52,6 +61,8 @@ module Rouge
         rule /0x\h('?\h)*[lu]*/i, Num::Hex
         rule /0[0-7]('?[0-7])*[lu]*/i, Num::Oct
         rule /#{dq}[lu]*/i, Num::Integer
+        rule /\bnullptr\b/, Name::Builtin
+        rule /(?:u8|u|U|L)?R"([a-zA-Z0-9_{}\[\]#<>%:;.?*\+\-\/\^&|~!=,"']{,16})\(.*?\)\1"/m, Str
       end
 
       state :classname do

data/lib/rouge/lexers/csharp.rb

@@ -14,19 +14,26 @@ module Rouge
       # TODO: support more of unicode
       id = /@?[_a-z]\w*/i
 
+      #Reserved Identifiers
+      #Contextual Keywords
+      #LINQ Query Expressions
       keywords = %w(
-        abstract alias as base break case catch checked const continue
+        abstract as base break case catch checked const continue
         default delegate do else enum event explicit extern false
-        finally fixed for foreach global goto if implicit in interface
+        finally fixed for foreach goto if implicit in interface
         internal is lock new null operator out override params private
         protected public readonly ref return sealed sizeof stackalloc
         static switch this throw true try typeof unchecked unsafe
-        virtual void while get set new partial yield add remove value
+        virtual void volatile while
+        add alias async await get global partial remove set value where
+        yield
+        ascending by descending equals from group in into join let on
+        orderby select
       )
 
       keywords_type = %w(
-        bool byte char decimal double float int long object sbyte
-        short string uint ulong ushort
+        bool byte char decimal double dynamic float int long object
+        sbyte short string uint ulong ushort var
       )
 
       cpp_keywords = %w(

data/lib/rouge/lexers/css.rb

@@ -191,6 +191,8 @@ module Rouge
         rule /@#{identifier}/, Keyword, :at_rule
         rule identifier, Name::Tag
         rule %r([~^*!%&\[\]()<>|+=@:;,./?-]), Operator
+        rule /"(\\\\|\\"|[^"])*"/, Str::Single
+        rule /'(\\\\|\\'|[^'])*'/, Str::Double
       end
 
       state :value do

data/lib/rouge/lexers/d.rb

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class D < RegexLexer
+      tag 'd'
+      aliases 'dlang'
+      filenames '*.d', '*.di'
+      mimetypes 'application/x-dsrc', 'text/x-dsrc'
+
+      title "D"
+      desc 'The D programming language(dlag.org)'
+
+      keywords = %w(
+        abstract alias align asm assert auto body
+        break case cast catch class const continue
+        debug default delegate delete deprecated do else
+        enum export extern finally final foreach_reverse
+        foreach for function goto if immutable import
+        interface invariant inout in is lazy mixin
+        module new nothrow out override package pragma
+        private protected public pure ref return scope
+        shared static struct super switch synchronized
+        template this throw try typedef typeid typeof
+        union unittest version volatile while with
+        __gshared __traits __vector __parameters
+      )
+
+      keywords_type = %w(
+        bool byte cdouble cent cfloat char creal
+        dchar double float idouble ifloat int ireal
+        long real short ubyte ucent uint ulong
+        ushort void wchar
+      )
+
+      keywords_pseudo = %w(
+        __FILE__ __MODULE__ __LINE__ __FUNCTION__ __PRETTY_FUNCTION__
+         __DATE__ __EOF__ __TIME__ __TIMESTAMP__ __VENDOR__
+        __VERSION__
+      )
+
+      state :whitespace do
+        rule /\n/m, Text
+        rule /\s+/m, Text
+      end
+
+      state :root do
+        mixin :whitespace
+        # Comments
+        rule %r(//(.*?)\n), Comment::Single
+        rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :nested_comment
+        # Keywords
+        rule /(#{keywords.join('|')})\b/, Keyword
+        rule /(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule /(false|true|null)\b/, Keyword::Constant
+        rule /(#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo
+        rule /macro\b/, Keyword::Reserved
+        rule /(string|wstring|dstring|size_t|ptrdiff_t)\b/, Name::Builtin
+        # Literals
+        # HexFloat
+        rule /0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
+        # DecimalFloat
+        rule /[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
+        rule /\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
+        # IntegerLiteral
+        # Binary
+        rule /0[Bb][01_]+/, Num::Bin
+        # Octal
+        # TODO: 0[0-7] isn't supported use octal![0-7] instead
+        rule /0[0-7_]+/, Num::Oct
+        # Hexadecimal
+        rule /0[xX][0-9a-fA-F_]+/, Num::Hex
+        # Decimal
+        rule /(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
+        # CharacterLiteral
+        rule /'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'/, Str::Char
+        # StringLiteral
+        # WysiwygString
+        rule /r"[^"]*"[cwd]?/, Str
+        # Alternate WysiwygString
+        rule /`[^`]*`[cwd]?/, Str
+        # DoubleQuotedString
+        rule /"(\\\\|\\"|[^"])*"[cwd]?/, Str
+        # EscapeSequence
+        rule /\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)/, Str
+        # HexString
+        rule /x"[0-9a-fA-F_\s]*"[cwd]?/, Str
+        # DelimitedString
+        rule /q"\[/, Str, :delimited_bracket
+        rule /q"\(/, Str, :delimited_parenthesis
+        rule /q"</, Str, :delimited_angle
+        rule /q"\{/, Str, :delimited_curly
+        rule /q"([a-zA-Z_]\w*)\n.*?\n\1"/, Str
+        rule /q"(.).*?\1"/, Str
+        # TokenString
+        rule /q\{/, Str, :token_string
+        # Attributes
+        rule /@([a-zA-Z_]\w*)?/, Name::Decorator
+        # Tokens
+        rule %r`(~=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>=|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)|[/.&|\-+<>!()\[\]{}?,;:$=*%^~]`, Punctuation
+        # Identifier
+        rule /[a-zA-Z_]\w*/, Name
+        # Line
+        rule /#line\s.*\n/, Comment::Special
+      end
+
+      state :nested_comment do
+        rule %r([^+/]+), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :push
+        rule %r(\+/), Comment::Multiline, :pop!
+        rule %r([+/]), Comment::Multiline
+      end
+
+      state :token_string do
+        rule /\{/, Punctuation, :token_string_nest
+        rule /\}/, Str, :pop!
+        mixin :root
+      end
+
+      state :token_string_nest do
+        rule /\{/, Punctuation, :push
+        rule /\}/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :delimited_bracket do
+        rule /[^\[\]]+/, Str
+        rule /\[/, Str, :delimited_inside_bracket
+        rule /\]"/, Str, :pop!
+      end
+
+      state :delimited_inside_bracket do
+        rule /[^\[\]]+/, Str
+        rule /\[/, Str, :push
+        rule /\]/, Str, :pop!
+      end
+
+      state :delimited_parenthesis do
+        rule /[^()]+/, Str
+        rule /\(/, Str, :delimited_inside_parenthesis
+        rule /\)"/, Str, :pop!
+      end
+
+      state :delimited_inside_parenthesis do
+        rule /[^()]+/, Str
+        rule /\(/, Str, :push
+        rule /\)/, Str, :pop!
+      end
+
+      state :delimited_angle do
+        rule /[^<>]+/, Str
+        rule /</, Str, :delimited_inside_angle
+        rule />"/, Str, :pop!
+      end
+
+      state :delimited_inside_angle do
+        rule /[^<>]+/, Str
+        rule /</, Str, :push
+        rule />/, Str, :pop!
+      end
+
+      state :delimited_curly do
+        rule /[^{}]+/, Str
+        rule /\{/, Str, :delimited_inside_curly
+        rule /\}"/, Str, :pop!
+      end
+
+      state :delimited_inside_curly do
+        rule /[^{}]+/, Str
+        rule /\{/, Str, :push
+        rule /\}/, Str, :pop!
+      end
+    end
+  end
+end