class Rouge::Lexers::ConsoleLexer

def allow_comments?

simply "#", we flag this to on
whether to allow comments. if manually specifying a prompt that isn't
def allow_comments?
  case @comments
  when :guess
    @prompt && !@prompt.empty? && !end_chars.include?('#')
  else
    @comments
  end
end

def comment_regex

def comment_regex
  /\A\s*?#/
end

def end_chars

def end_chars
  @end_chars ||= if @prompt.any?
    @prompt.reject { |c| c.empty? }
  else
    %w($ # > ;)
  end
end

def initialize(*)

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 lang_lexer

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 line_regex

def line_regex
  /(\\.|[^\\])*?(\n|$)/m
end

def output_lexer

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 process_line(input, &output)

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

def prompt_prefix_regex

def prompt_prefix_regex
  if allow_comments?
    /[^<#]*?/m
  else
    /.*?/m
  end
end

def prompt_regex

def prompt_regex
  @prompt_regex ||= begin
    /^#{prompt_prefix_regex}(?:#{end_chars.map(&Regexp.method(:escape)).join('|')})/
  end
end

def stream_tokens(input, &output)

def stream_tokens(input, &output)
  input = StringScanner.new(input)
  lang_lexer.reset!
  output_lexer.reset!
  process_line(input, &output) while !input.eos?
end