rougegal 2.1.2

data/lib/rouge/lexers/conf.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Conf < RegexLexer
+      tag 'conf'
+      aliases 'config', 'configuration'
+
+      title "Config File"
+      desc 'A generic lexer for configuration files'
+      filenames '*.conf', '*.config'
+
+      # short and sweet
+      state :root do
+        rule /#.*?\n/, Comment
+        rule /".*?"/, Str::Double
+        rule /'.*?'/, Str::Single
+        rule /[a-z]\w*/i, Name
+        rule /\d+/, Num
+        rule /[^\d\w#"']+/, Text
+      end
+    end
+  end
+end

data/lib/rouge/lexers/console.rb

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class ConsoleLexer < Lexer
+      tag 'console'
+      aliases 'terminal', 'shell_session', 'shell-session'
+      filenames '*.cap'
+      desc 'A generic lexer for shell sessions. Accepts ?lang and ?output lexer options, a ?prompt option, and ?comments to enable # comments.'
+
+      option :lang, 'the shell language to lex (default: shell)'
+      option :output, 'the output language (default: plaintext?token=Generic.Output)'
+      option :prompt, 'comma-separated list of strings that indicate the end of a prompt. (default: $,#,>,;)'
+      option :comments, 'enable hash-comments at the start of a line - otherwise interpreted as a prompt. (default: false, implied by ?prompt not containing `#`)'
+
+      def initialize(*)
+        super
+        @prompt = list_option(:prompt) { nil }
+        @lang = lexer_option(:lang) { 'shell' }
+        @output = lexer_option(:output) { PlainText.new(token: Generic::Output) }
+        @comments = bool_option(:comments) { :guess }
+      end
+
+      def prompt_regex
+        @prompt_regex ||= begin
+          /^#{prompt_prefix_regex}(?:#{end_chars.map(&Regexp.method(:escape)).join('|')})/
+        end
+      end
+
+      def end_chars
+        @end_chars ||= if @prompt.any?
+          @prompt.reject { |c| c.empty? }
+        else
+          %w($ # > ;)
+        end
+      end
+
+      # whether to allow comments. if manually specifying a prompt that isn't
+      # simply "#", we flag this to on
+      def allow_comments?
+        case @comments
+        when :guess
+          @prompt && !@prompt.empty? && !end_chars.include?('#')
+        else
+          @comments
+        end
+      end
+
+      def prompt_prefix_regex
+        if allow_comments?
+          /[^<#]*?/m
+        else
+          /.*?/m
+        end
+      end
+
+      def lang_lexer
+        @lang_lexer ||= case @lang
+        when Lexer
+          @lang
+        when nil
+          Shell.new(options)
+        when Class
+          @lang.new(options)
+        when String
+          Lexer.find(@lang).new(options)
+        end
+      end
+
+      def output_lexer
+        @output_lexer ||= case @output
+        when nil
+          PlainText.new(token: Generic::Output)
+        when Lexer
+          @output
+        when Class
+          @output.new(options)
+        when String
+          Lexer.find(@output).new(options)
+        end
+      end
+
+      def line_regex
+        /(\\.|[^\\])*?(\n|$)/m
+      end
+
+      def comment_regex
+        /\A\s*?#/
+      end
+
+      def stream_tokens(input, &output)
+        input = StringScanner.new(input)
+        lang_lexer.reset!
+        output_lexer.reset!
+
+        process_line(input, &output) while !input.eos?
+      end
+
+      def process_line(input, &output)
+        input.scan(line_regex)
+
+        if input[0] =~ /\A\s*(?:<[.]+>|[.]+)\s*\z/
+          puts "console: matched snip #{input[0].inspect}" if @debug
+          output_lexer.reset!
+          lang_lexer.reset!
+
+          yield Comment, input[0]
+        elsif prompt_regex =~ input[0]
+          puts "console: matched prompt #{input[0].inspect}" if @debug
+          output_lexer.reset!
+
+          yield Generic::Prompt, $&
+
+          # make sure to take care of initial whitespace
+          # before we pass to the lang lexer so it can determine where
+          # the "real" beginning of the line is
+          $' =~ /\A\s*/
+          yield Text, $& unless $&.empty?
+
+          lang_lexer.lex($', continue: true, &output)
+        elsif comment_regex =~ input[0].strip
+          puts "console: matched comment #{input[0].inspect}" if @debug
+          output_lexer.reset!
+          lang_lexer.reset!
+
+          yield Comment, input[0]
+        else
+          puts "console: matched output #{input[0].inspect}" if @debug
+          lang_lexer.reset!
+
+          output_lexer.lex(input[0], continue: true, &output)
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/coq.rb

@@ -0,0 +1,191 @@
+# -*- 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 :escape_sequence do
+        rule /\\[\\"'ntbr]/, Str::Escape
+      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

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_lexer 'c.rb'
+
+    class Cpp < C
+      title "C++"
+      desc "The C++ programming language"
+
+      tag 'cpp'
+      aliases 'c++'
+      # the many varied filenames of c++ source files...
+      filenames '*.cpp', '*.hpp',
+                '*.c++', '*.h++',
+                '*.cc',  '*.hh',
+                '*.cxx', '*.hxx',
+                '*.pde', '*.ino',
+                '*.tpp'
+      mimetypes 'text/x-c++hdr', 'text/x-c++src'
+
+      def self.keywords
+        @keywords ||= super + Set.new(%w(
+          asm auto catch const_cast delete dynamic_cast explicit export
+          friend mutable namespace new operator private protected public
+          reinterpret_cast restrict size_of static_cast template this throw
+          throws typeid typename using virtual final override
+
+          alignas alignof constexpr decltype noexcept static_assert
+          thread_local try
+        ))
+      end
+
+      def self.keywords_type
+        @keywords_type ||= super + Set.new(%w(
+          bool
+        ))
+      end
+
+      def self.reserved
+        @reserved ||= super + Set.new(%w(
+          __virtual_inheritance __uuidof __super __single_inheritance
+          __multiple_inheritance __interface __event
+        ))
+      end
+
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      prepend :root do
+        # Offload C++ extensions, http://offload.codeplay.com/
+        rule /(?:__offload|__blockingoffload|__outer)\b/, Keyword::Pseudo
+      end
+
+      # digits with optional inner quotes
+      # see www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3781.pdf
+      dq = /\d('?\d)*/
+
+      prepend :statements do
+        rule /class\b/, Keyword, :classname
+        rule %r((#{dq}[.]#{dq}?|[.]#{dq})(e[+-]?#{dq}[lu]*)?)i, Num::Float
+        rule %r(#{dq}e[+-]?#{dq}[lu]*)i, Num::Float
+        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
+        rule id, Name::Class, :pop!
+
+        # template specification
+        rule /\s*(?=>)/m, Text, :pop!
+        mixin :whitespace
+      end
+    end
+  end
+end

data/lib/rouge/lexers/csharp.rb

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class CSharp < RegexLexer
+      tag 'csharp'
+      aliases 'c#', 'cs'
+      filenames '*.cs'
+      mimetypes 'text/x-csharp'
+
+      title "C#"
+      desc 'a multi-paradigm language targeting .NET'
+
+      # TODO: support more of unicode
+      id = /@?[_a-z]\w*/i
+
+      #Reserved Identifiers
+      #Contextual Keywords
+      #LINQ Query Expressions
+      keywords = %w(
+        abstract as base break case catch checked const continue
+        default delegate do else enum event explicit extern false
+        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 volatile while
+        add alias async await get global partial remove set value where
+        yield nameof
+        ascending by descending equals from group in into join let on
+        orderby select
+      )
+
+      keywords_type = %w(
+        bool byte char decimal double dynamic float int long object
+        sbyte short string uint ulong ushort var
+      )
+
+      cpp_keywords = %w(
+        if endif else elif define undef line error warning region
+        endregion pragma
+      )
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :nest do
+        rule /{/, Punctuation, :nest
+        rule /}/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :splice_string do
+        rule /\\./, Str
+        rule /{/, Punctuation, :nest
+        rule /"|\n/, Str, :pop!
+        rule /./, Str
+      end
+
+      state :splice_literal do
+        rule /""/, Str
+        rule /{/, Punctuation, :nest
+        rule /"/, Str, :pop!
+        rule /./, Str
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule /^\s*\[.*?\]/, Name::Attribute
+        rule /[$]\s*"/, Str, :splice_string
+        rule /[$]@\s*"/, Str, :splice_literal
+
+        rule /(<\[)\s*(#{id}:)?/, Keyword
+        rule /\]>/, Keyword
+
+        rule /[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule /@"(""|[^"])*"/m, Str
+        rule /"(\\.|.)*?["\n]/, Str
+        rule /'(\\.|.)'/, Str::Char
+        rule /0x[0-9a-f]+[lu]?/i, Num
+        rule %r(
+          [0-9]
+          ([.][0-9]*)? # decimal
+          (e[+-][0-9]+)? # exponent
+          [fldu]? # type
+        )ix, Num
+        rule /\b(?:class|struct|interface)\b/, Keyword, :class
+        rule /\b(?:namespace|using)\b/, Keyword, :namespace
+        rule /^#[ \t]*(#{cpp_keywords.join('|')})\b.*?\n/,
+          Comment::Preproc
+        rule /\b(#{keywords.join('|')})\b/, Keyword
+        rule /\b(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule /#{id}(?=\s*[(])/, Name::Function
+        rule id, Name
+      end
+
+      state :class do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule /(?=[(])/, Text, :pop!
+        rule /(#{id}|[.])+/, Name::Namespace, :pop!
+      end
+
+    end
+  end
+end