fucke.rs

extern crate hyper;
extern crate hyper_native_tls;
extern crate kuchiki;
extern crate itertools;

use std::cell::{Ref, RefCell};
use std::collections::HashMap;
use std::io;

use itertools::Itertools;

use hyper::Client;
use hyper::header::UserAgent;
use hyper::net::HttpsConnector;
use hyper_native_tls::NativeTlsClient;

use kuchiki::*;
use kuchiki::traits::*;

fn main() {
    let ssl = NativeTlsClient::new().unwrap();
    let connector = HttpsConnector::new(ssl);
    let client = Client::with_connector(connector);

    let url = "https://action.donaldjtrump.com/mainstream-media-accountability-survey/";
    let req = client.get(url).header(UserAgent("fucke.rs".to_owned()));
    let mut rsp = req.send().unwrap();

    let dom = kuchiki::parse_html()
        .from_utf8()
        .read_from(&mut rsp).ok().expect("parse error");
    let form = dom.select("#survey-form")
        .ok().expect("no #survey-form")
        .next().unwrap();

    let fields = form.as_node().select("input")
        .ok().expect("no inputs")
        .filter_map(mk_field);

    let by_q = fields.group_by(|f| f.name.to_owned());

    for (q, fs) in by_q.into_iter() {
        println!("q={:?}", q);
        for f in fs {
            println!("  {:?}", f);
        }
    }
}

fn mk_field(n: NodeDataRef<ElementData>) -> Option<Field> {
    let el: &ElementData = n.as_node().as_element().unwrap();

    if el.name.local.eq_str_ignore_ascii_case("input") {
        // println!("node[{}] input {:?}", i, el);
        let ref attrs = el.attributes.borrow().map;

        let kind = attrs.iter()
            .find(|&(n, _)| n.local.eq_str_ignore_ascii_case("type"))
            .map(|(_, v)| v.to_owned());
        let name = attrs.iter()
            .find(|&(n, _)| n.local.eq_str_ignore_ascii_case("name"))
            .map(|(_, v)| v.to_owned());
        let value = attrs.iter()
            .find(|&(n, _)| n.local.eq_str_ignore_ascii_case("value"))
            .map(|(_, v)| v.to_owned());
        match (kind, name, value) {
            (Some(k), Some(n), Some(v)) =>
                Some(Field {
                    kind: k,
                    name: n,
                    value: v,
                }),
            _ => None
        }
    } else { None }
}

#[derive(Debug)]
struct Field {
    kind: String,
    name: String,
    value: String,
}