用Rust来辅助报表解析

pub struct InputFixer<'a> {
    raw_fname: &'a str,  
    local_fname: String, 
}

impl<'a> InputFixer<'a> {
    pub fn new(fpath: &'a str) -> InputFixer<'a> {
        InputFixer {
            raw_fname: fpath,
            local_fname: format!("{}_trunct.csv", fpath),
        }
    }

    pub fn fix(&'a self) -> Result<&'a str, std::io::Error> {
        if Path::new(&self.local_fname).exists() {
            Ok(self.local_fname.as_str())
        } else {
            self.fix_and_save()
        }
    }
    //...
}

//Remove extra headlines from reports, save until we found valid header
fn fix_and_save(&'a self) -> Result<&'a str, std::io::Error> {
    let mut outf = BufWriter::new(File::create(&self.local_fname)?);

    let inf = File::open(self.raw_fname)?;
    let mut line = String::new();
    let mut reader = BufReader::new(inf);

    let mut found_header = false;
    while !found_header {
        reader.read_line(&mut line)?;
        if line.find(r#""Problem ID","Title","#).is_some() {
            found_header = true;
            outf.write(format!("{}", line).as_bytes())?;
        } else {
            //warn!("Skip bad line {}", line);
        }
        line.clear();
    }

    info!("Copying remaining bytes...");
    loop {
        let buf_len = {
            let buf = reader.fill_buf()?;
            if buf.len() > 0 {
                outf.write(buf)?;
            }
            buf.len()
        };

        if buf_len == 0 {
            break;
        }
        reader.consume(buf_len);
    }
    info!("New file created = {}", self.local_fname);
    Ok(self.local_fname.as_str())
}

pub fn analyze(fpath: &str) {
    info!("Started to parse {}", fpath);
    let fixer = InputFixer::new(fpath);
    let _result = fixer.fix().map_err(|err| error!("Truncting file failed by {}", err))
        .ok()
        .map(|fpath| Reader::from_path(&fpath).as_mut()
            .map(|rdr| { 
                rdr.deserialize::<Record>()
                    .filter_map(|it| it.ok().map(|rec| ParsedRecord::new(rec)))
                    .collect()
            })
            .map(|records| parse_and_save(&fpath, records))
            .map_err(|err| error!("CSV parsing failed by {}", err))
        );
}

//Parsing given R&D information and filter out interested items
pub fn parse(revision: &str) -> Vec<RevisionItem> {
    lazy_static! {
        static ref PATTERN_DELIMITER : Regex = Regex::new("(, )?(201[789]-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}) ").unwrap();
        static ref PATTERN_STATECHANGE: Regex = Regex::new("(.*) The state of the problem changed from ([a-zA-Z ]+) [tT]o ([a-zA-Z ]+)").unwrap();
        static ref PATTERN_STATECHANGE_EX: Regex = Regex::new("(.*) State changed from ([a-zA-Z ]+) to ([a-zA-Z ]+)").unwrap();
        static ref PATTERN_TRANSFER: Regex = Regex::new("(.*) The group in charge changed from ([_A-Z0-9]+) [tT]o ([_A-Z0-9]+)").unwrap();
        static ref PATTERN_STATE_REOPEN  : Regex = Regex::new("(.*) Reopened").unwrap();
        static ref PATTERN_ATTACHED: Regex = Regex::new("(.*) Problem attached to ([^. ]+)").unwrap();
        static ref PATTERN_DETACHED: Regex = Regex::new("(.*) Problem detached. The problem report was detached from ([^., ]+)").unwrap();
        static ref PATTERN_POSTPONE: Regex = Regex::new("(.*) ((Postponed)|(Reactivated))").unwrap();
    }

    PATTERN_DELIMITER
        .replace_all(revision, |caps: &Captures|format!("\n{}|", &caps[2]))
        .split('\n')
        .filter_map(|line| line.find('|').and_then(|pos| {
            let (when, rem) = line.split_at(pos);
            let rem = &rem[1..rem.len()];

            PATTERN_STATECHANGE.captures(rem)
                .or(
                    PATTERN_STATECHANGE_EX.captures(rem))
                        .map(|caps| (caps[1].to_string(), StateChange{
                            from: caps[2].to_string(), to: caps[3].to_string()}))
                .or(
                    PATTERN_TRANSFER.captures(rem)
                        .map(|caps| (caps[1].to_string(), GroupChange{
                            from: caps[2].to_string(), to: caps[3].to_string()})))
                .or(
                    PATTERN_STATE_REOPEN.captures(rem)
                        .map(|caps| (caps[1].to_string(), StateChange{
                            from: "Finalized".to_string(), to: "New".to_string()})))
                .or(
                    PATTERN_ATTACHED.captures(rem)
                        .map(|caps| (caps[1].to_string(), Attached {to: caps[2].to_string()})))
                .or(
                    PATTERN_DETACHED.captures(rem)
                        .map(|caps| (caps[1].to_string(), Detached {from: caps[2].to_string()})))
                .or(
                    PATTERN_POSTPONE.captures(rem)
                        .map(|caps| (caps[1].to_string(), if caps[2].find("Postpone").is_some() {Postponed} else {ReActivated} )))
                .map(|(auth, extra)| RevisionItem { 
                    author: auth, when: when.to_string(), extra: extra
                })
            })).collect()

#[derive(Debug)]
pub struct Revisions {
    revisions: Vec<RevisionItem>,
}

impl Revisions {
    pub fn get_first_group(self: &Revisions, mygrp: &str) -> String {
        self.revisions.iter()
            .rev()
            .filter_map(|x| x.get_from_group())
            .nth(0)
            .unwrap_or(mygrp)
            .to_string()
    }
    //...
}

//definition of get_from_group in RevisionItem struct
pub fn get_from_group<'a>(self: &'a RevisionItem) -> Option<&'a str> {
    match self.extra {
        GroupChange{ref from, to:_} => Some(&from),
        _ => None,
    }
}

struct AttachInfo<'a> {
    my_id: &'a str,
    attached_list: &'a str,
}

pub struct AttachGraph<'a> {
    pub mapping: HashMap<&'a str, &'a str>,
    //A set of nodes that are associated with one given first id
    pub components: HashMap<&'a str, HashSet<&'a str>>,
}

    let mut new_mapping = HashMap::new();
    graph.components.iter()
        .map(|(from, attached)|
            if !interested.contains(from) {
                attached.intersection(interested)
                    .nth(0)
                    .map(|y| (*y, attached) )
                    .unwrap_or((*from, attached))
            } else {
                (*from, attached)
            }
        ).for_each(|(from, attached)| {
            attached.iter().for_each(|x| {
                new_mapping.insert(*x, from);
            });
    });

    graph.mapping = new_mapping;
    graph