18859797937

Committed 28 Oct 2025 12:13AM UTC coverage: 90.0% (-0.7%) from 90.704%

Build # 18859797937

Build Type

Pull #72

github

Committed by

tamada

Commit Message

Implement utility for generating  Filter instance and  add corresponding tests

Pull Request Pull Request #72: Release/v0.8.2

Run Details

146 of 174 new or added lines in 12 files covered. (83.91%)

38 existing lines in 2 files now uncovered.

1467 of 1630 relevant lines covered (90.0%)

20.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.54

/cli/src/defs_builder.rs

use std::fs::File;
use std::io::{BufRead, BufReader};

use btmeister::defs::{self, BuildToolDefs};
use btmeister::{Filter, Result};

use crate::cli;

pub fn construct(opts: cli::DefOpts) -> Result<BuildToolDefs> {
    let (d, a, f) = (opts.definition, opts.append_defs, opts.filter);
    match defs::construct(d, a) {
        Ok(r) => {
            let filter = f.build_filter();
            if filter == Filter::None {
                Ok(r)
            } else {
                Ok(r.filter(filter))
            }
        }
        Err(e) => Err(e),
    }
}

impl cli::FilterOpts {
    fn build_filter(self) -> Filter {
        match (
            self.includes,
            self.excludes,
            self.include_files,
            self.exclude_files,
        ) {
            (Some(v), _, _, _) => Filter::Includes(parse_item(v)),
            (_, Some(v), _, _) => Filter::Excludes(parse_item(v)),
            (_, _, Some(v), _) => Filter::IncludeFiles(parse_item(v)),
            (_, _, _, Some(v)) => Filter::ExcludeFiles(parse_item(v)),
            (None, None, None, None) => Filter::None,
        }
    }
}

fn parse_item(item: String) -> Vec<String> {
    if let Some(filename) = item.strip_prefix('@') {
        match File::open(filename) {
            Ok(f) => read_file_content(f),
            Err(_) => vec![],
        }
    } else {
        item.split(',')
            .map(|s| s.trim().to_string())
            .collect::<Vec<String>>()
    }
}

fn read_file_content(f: File) -> Vec<String> {
    BufReader::new(f)
        .lines()
        .map_while(|s| s.ok())
        .map(|s| s.trim().to_string())
        .collect::<Vec<_>>()
}

1	use std::fs::File;
2	use std::io::{BufRead, BufReader};
3
4	use btmeister::defs::{self, BuildToolDefs};
5	use btmeister::{Filter, Result};
6
7	use crate::cli;
8
9	pub fn construct(opts: cli::DefOpts) -> Result<BuildToolDefs> {	4✔
10	let (d, a, f) = (opts.definition, opts.append_defs, opts.filter);	4✔
11	match defs::construct(d, a) {	4✔
12	Ok(r) => {	4✔
13	let filter = f.build_filter();	4✔
14	if filter == Filter::None {	4✔
15	Ok(r)	4✔
16	} else {
NEW 17	Ok(r.filter(filter))	×
18	}
19	}
NEW 20	Err(e) => Err(e),	×
21	}
22	}	4✔
23
24	impl cli::FilterOpts {
25	fn build_filter(self) -> Filter {	4✔
26	match (
27	self.includes,	4✔
28	self.excludes,	4✔
29	self.include_files,	4✔
30	self.exclude_files,	4✔
31	) {
NEW 32	(Some(v), _, _, _) => Filter::Includes(parse_item(v)),	×
NEW 33	(_, Some(v), _, _) => Filter::Excludes(parse_item(v)),	×
NEW 34	(_, _, Some(v), _) => Filter::IncludeFiles(parse_item(v)),	×
NEW 35	(_, _, _, Some(v)) => Filter::ExcludeFiles(parse_item(v)),	×
36	(None, None, None, None) => Filter::None,	4✔
37	}
38	}	4✔
39	}
40
NEW 41	fn parse_item(item: String) -> Vec<String> {	×
NEW 42	if let Some(filename) = item.strip_prefix('@') {	×
NEW 43	match File::open(filename) {	×
NEW 44	Ok(f) => read_file_content(f),	×
NEW 45	Err(_) => vec![],	×
46	}
47	} else {
NEW 48	item.split(',')	×
NEW 49	.map(\|s\| s.trim().to_string())	×
NEW 50	.collect::<Vec<String>>()	×
51	}
NEW 52	}	×
53
NEW 54	fn read_file_content(f: File) -> Vec<String> {	×
NEW 55	BufReader::new(f)	×
NEW 56	.lines()	×
NEW 57	.map_while(\|s\| s.ok())	×
NEW 58	.map(\|s\| s.trim().to_string())	×
NEW 59	.collect::<Vec<_>>()	×
NEW 60	}	×

tamada / btmeister / 18859797937

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous