src/vendor/html5ever/examples/tokenize.rs

   1 // Copyright 2014-2017 The html5ever Project Developers. See the
   2 // COPYRIGHT file at the top-level directory of this distribution.
   3 //
   4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   5 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   7 // option. This file may not be copied, modified, or distributed
   8 // except according to those terms.
   9
  10 extern crate html5ever;
  11
  12 use std::io;
  13 use std::default::Default;
  14
  15 use html5ever::tokenizer::{TokenSink, Tokenizer, Token, TokenizerOpts, ParseError, TokenSinkResult};
  16 use html5ever::tokenizer::{CharacterTokens, NullCharacterToken, TagToken, StartTag, EndTag};
  17 use html5ever::tokenizer::BufferQueue;
  18 use html5ever::tendril::*;
  19
  20 #[derive(Copy, Clone)]
  21 struct TokenPrinter {
  22     in_char_run: bool,
  23 }
  24
  25 impl TokenPrinter {
  26     fn is_char(&mut self, is_char: bool) {
  27         match (self.in_char_run, is_char) {
  28             (false, true ) => print!("CHAR : \""),
  29             (true,  false) => println!("\""),
  30             _ => (),
  31         }
  32         self.in_char_run = is_char;
  33     }
  34
  35     fn do_char(&mut self, c: char) {
  36         self.is_char(true);
  37         print!("{}", c.escape_default().collect::<String>());
  38     }
  39 }
  40
  41 impl TokenSink for TokenPrinter {
  42     type Handle = ();
  43
  44     fn process_token(&mut self, token: Token, _line_number: u64) -> TokenSinkResult<()> {
  45         match token {
  46             CharacterTokens(b) => {
  47                 for c in b.chars() {
  48                     self.do_char(c);
  49                 }
  50             }
  51             NullCharacterToken => self.do_char('\0'),
  52             TagToken(tag) => {
  53                 self.is_char(false);
  54                 // This is not proper HTML serialization, of course.
  55                 match tag.kind {
  56                     StartTag => print!("TAG  : <\x1b[32m{}\x1b[0m", tag.name),
  57                     EndTag   => print!("TAG  : <\x1b[31m/{}\x1b[0m", tag.name),
  58                 }
  59                 for attr in tag.attrs.iter() {
  60                     print!(" \x1b[36m{}\x1b[0m='\x1b[34m{}\x1b[0m'",
  61                         attr.name.local, attr.value);
  62                 }
  63                 if tag.self_closing {
  64                     print!(" \x1b[31m/\x1b[0m");
  65                 }
  66                 println!(">");
  67             }
  68             ParseError(err) => {
  69                 self.is_char(false);
  70                 println!("ERROR: {}", err);
  71             }
  72             _ => {
  73                 self.is_char(false);
  74                 println!("OTHER: {:?}", token);
  75             }
  76         }
  77         TokenSinkResult::Continue
  78     }
  79 }
  80
  81 fn main() {
  82     let mut sink = TokenPrinter {
  83         in_char_run: false,
  84     };
  85     let mut chunk = ByteTendril::new();
  86     io::stdin().read_to_tendril(&mut chunk).unwrap();
  87     let mut input = BufferQueue::new();
  88     input.push_back(chunk.try_reinterpret().unwrap());
  89
  90     let mut tok = Tokenizer::new(sink, TokenizerOpts {
  91         profile: true,
  92         .. Default::default()
  93     });
  94     let _ = tok.feed(&mut input);
  95     assert!(input.is_empty());
  96     tok.end();
  97     sink.is_char(false);
  98 }