7319540133

Committed 25 Dec 2023 03:39AM UTC coverage: 72.884% (-0.1%) from 73.022%

Build # 7319540133

Build Type

push

github

Committed by

web-flow

Commit Message

Make ZeroVec have a niche via NonNull (#4491)

Run Details

7 of 7 new or added lines in 2 files covered. (100.0%)

2721 existing lines in 221 files now uncovered.

46318 of 63550 relevant lines covered (72.88%)

272438.55 hits per line

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

1.89

/tools/bakeddata-scripts/src/main.rs

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

extern crate icu_datagen;

use icu_datagen::baked_exporter::*;
use icu_datagen::prelude::*;
use std::path::Path;

const REPO_VERSION: &str = env!("CARGO_PKG_VERSION");

const COMPONENTS: &[(&str, &[DataKey], &str)] = &[
    ("calendar", icu::calendar::provider::KEYS, REPO_VERSION),
    ("casemap", icu::casemap::provider::KEYS, REPO_VERSION),
    ("collator", icu::collator::provider::KEYS, REPO_VERSION),
    (
        "compactdecimal",
        icu::compactdecimal::provider::KEYS,
        REPO_VERSION,
    ),
    ("datetime", icu::datetime::provider::KEYS, REPO_VERSION),
    ("decimal", icu::decimal::provider::KEYS, REPO_VERSION),
    (
        "displaynames",
        icu::displaynames::provider::KEYS,
        REPO_VERSION,
    ),
    ("list", icu::list::provider::KEYS, REPO_VERSION),
    (
        "locid_transform",
        icu::locid_transform::provider::KEYS,
        REPO_VERSION,
    ),
    ("normalizer", icu::normalizer::provider::KEYS, REPO_VERSION),
    ("plurals", icu::plurals::provider::KEYS, REPO_VERSION),
    ("properties", icu::properties::provider::KEYS, REPO_VERSION),
    (
        "relativetime",
        icu::relativetime::provider::KEYS,
        REPO_VERSION,
    ),
    ("segmenter", icu::segmenter::provider::KEYS, REPO_VERSION),
    ("timezone", icu::timezone::provider::KEYS, REPO_VERSION),
    (
        "unitsconversion",
        icu_unitsconversion::provider::KEYS,
        REPO_VERSION,
    ),
];

fn main() {
    simple_logger::SimpleLogger::new()
        .env()
        .with_level(log::LevelFilter::Info)
        .init()
        .unwrap();

    let args = std::env::args();

    let components = if args.len() == 1 {
        COMPONENTS
            .iter()
            .map(|(krate, keys, version)| (krate.to_string(), *keys, *version))
            .collect::<Vec<_>>()
    } else {
        let map = std::collections::HashMap::<&str, (&'static [DataKey], &'static str)>::from_iter(
            COMPONENTS
                .iter()
                .map(|(krate, keys, version)| (*krate, (*keys, *version))),
        );
        args.skip(1)
            .filter_map(|krate| {
                map.get(krate.as_str())
                    .map(|(keys, version)| (krate, *keys, *version))
            })
            .collect()
    };

    let source = DatagenProvider::new_latest_tested();

    let driver = DatagenDriver::new()
        .with_locales(
            source
                .locales_for_coverage_levels([
                    CoverageLevel::Modern,
                    CoverageLevel::Moderate,
                    CoverageLevel::Basic,
                ])
                .unwrap(),
        )
        .with_recommended_segmenter_models()
        .with_fallback_mode(FallbackMode::Runtime);

    let mut options = Options::default();
    options.overwrite = true;
    options.pretty = true;

    let template = Path::new("provider/baked/_template_");

    for (component, keys, version) in &components {
        let path = Path::new("provider/baked").join(component);

        let _ = std::fs::remove_dir_all(&path);
        for dir in ["", "src", "data"] {
            std::fs::create_dir(&path.join(dir)).unwrap();
        }
        for file in [
            "build.rs",
            "Cargo.toml",
            "LICENSE",
            "README.md",
            "src/lib.rs",
        ] {
            std::fs::write(
                path.join(file),
                &std::fs::read_to_string(template.join(file))
                    .unwrap()
                    .replace("_component_", component)
                    .replace("_version_", version)
                    .replace("_cldr_tag_", DatagenProvider::LATEST_TESTED_CLDR_TAG)
                    .replace(
                        "_icuexport_tag_",
                        DatagenProvider::LATEST_TESTED_ICUEXPORT_TAG,
                    )
                    .replace(
                        "_segmenter_lstm_tag_",
                        DatagenProvider::LATEST_TESTED_SEGMENTER_LSTM_TAG,
                    ),
            )
            .unwrap();
        }

        if component == "segmenter" {
            // segmenter uses hardcoded locales internally, so fallback is not necessary.
            driver.clone().with_fallback_mode(FallbackMode::Hybrid)
        } else {
            driver.clone()
        }
        .with_keys(keys.iter().copied())
        .export(
            &source,
            BakedExporter::new(path.join("data"), options).unwrap(),
        )
        .unwrap();

        for file in ["data/any.rs", "data/mod.rs"] {
            std::fs::remove_file(path.join(file)).unwrap();
        }
    }
}

1	// This file is part of ICU4X. For terms of use, please see the file	1✔
2	// called LICENSE at the top level of the ICU4X source tree
3	// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5	extern crate icu_datagen;
6
7	use icu_datagen::baked_exporter::*;
8	use icu_datagen::prelude::*;
9	use std::path::Path;
10
11	const REPO_VERSION: &str = env!("CARGO_PKG_VERSION");
12
13	const COMPONENTS: &[(&str, &[DataKey], &str)] = &[
14	("calendar", icu::calendar::provider::KEYS, REPO_VERSION),
15	("casemap", icu::casemap::provider::KEYS, REPO_VERSION),
16	("collator", icu::collator::provider::KEYS, REPO_VERSION),
17	(
18	"compactdecimal",
19	icu::compactdecimal::provider::KEYS,
20	REPO_VERSION,
21	),
22	("datetime", icu::datetime::provider::KEYS, REPO_VERSION),
23	("decimal", icu::decimal::provider::KEYS, REPO_VERSION),
24	(
25	"displaynames",
26	icu::displaynames::provider::KEYS,
27	REPO_VERSION,
28	),
29	("list", icu::list::provider::KEYS, REPO_VERSION),
30	(
31	"locid_transform",
32	icu::locid_transform::provider::KEYS,
33	REPO_VERSION,
34	),
35	("normalizer", icu::normalizer::provider::KEYS, REPO_VERSION),
36	("plurals", icu::plurals::provider::KEYS, REPO_VERSION),
37	("properties", icu::properties::provider::KEYS, REPO_VERSION),
38	(
39	"relativetime",
40	icu::relativetime::provider::KEYS,
41	REPO_VERSION,
42	),
43	("segmenter", icu::segmenter::provider::KEYS, REPO_VERSION),
44	("timezone", icu::timezone::provider::KEYS, REPO_VERSION),
45	(
46	"unitsconversion",
47	icu_unitsconversion::provider::KEYS,
48	REPO_VERSION,
49	),
50	];
51
UNCOV 52	fn main() {	×
UNCOV 53	simple_logger::SimpleLogger::new()	×
54	.env()
UNCOV 55	.with_level(log::LevelFilter::Info)	×
56	.init()
57	.unwrap();
58
59	let args = std::env::args();	×
60
UNCOV 61	let components = if args.len() == 1 {	×
62	COMPONENTS	×
63	.iter()
UNCOV 64	.map(\|(krate, keys, version)\| (krate.to_string(), keys, version))	×
65	.collect::<Vec<_>>()
66	} else {
67	let map = std::collections::HashMap::<&str, (&'static [DataKey], &'static str)>::from_iter(	×
68	COMPONENTS	×
69	.iter()
70	.map(\|(krate, keys, version)\| (krate, (keys, *version))),	×
71	);
UNCOV 72	args.skip(1)	×
73	.filter_map(\|krate\| {	×
UNCOV 74	map.get(krate.as_str())	×
75	.map(\|(keys, version)\| (krate, keys, version))	×
UNCOV 76	})	×
77	.collect()
UNCOV 78	};	×
79
80	let source = DatagenProvider::new_latest_tested();	×
81
82	let driver = DatagenDriver::new()	×
83	.with_locales(
UNCOV 84	source	×
UNCOV 85	.locales_for_coverage_levels([	×
86	CoverageLevel::Modern,	×
UNCOV 87	CoverageLevel::Moderate,	×
88	CoverageLevel::Basic,	×
89	])
90	.unwrap(),
91	)	×
92	.with_recommended_segmenter_models()
UNCOV 93	.with_fallback_mode(FallbackMode::Runtime);	×
94
UNCOV 95	let mut options = Options::default();	×
96	options.overwrite = true;	×
97	options.pretty = true;	×
98
99	let template = Path::new("provider/baked/_template_");	×
100
101	for (component, keys, version) in &components {	×
UNCOV 102	let path = Path::new("provider/baked").join(component);	×
103
UNCOV 104	let _ = std::fs::remove_dir_all(&path);	×
UNCOV 105	for dir in ["", "src", "data"] {	×
UNCOV 106	std::fs::create_dir(&path.join(dir)).unwrap();	×
107	}
UNCOV 108	for file in [	×
109	"build.rs",
110	"Cargo.toml",
111	"LICENSE",
112	"README.md",
113	"src/lib.rs",
114	] {
115	std::fs::write(	×
116	path.join(file),	×
117	&std::fs::read_to_string(template.join(file))	×
118	.unwrap()
UNCOV 119	.replace("_component_", component)	×
120	.replace("_version_", version)	×
121	.replace("_cldr_tag_", DatagenProvider::LATEST_TESTED_CLDR_TAG)
122	.replace(
123	"_icuexport_tag_",
124	DatagenProvider::LATEST_TESTED_ICUEXPORT_TAG,
125	)
126	.replace(
127	"_segmenter_lstm_tag_",
128	DatagenProvider::LATEST_TESTED_SEGMENTER_LSTM_TAG,
129	),
130	)	×
UNCOV 131	.unwrap();	×
132	}
133
134	if component == "segmenter" {	×
135	// segmenter uses hardcoded locales internally, so fallback is not necessary.
136	driver.clone().with_fallback_mode(FallbackMode::Hybrid)	×
137	} else {
UNCOV 138	driver.clone()	×
139	}
UNCOV 140	.with_keys(keys.iter().copied())	×
141	.export(
142	&source,
UNCOV 143	BakedExporter::new(path.join("data"), options).unwrap(),	×
UNCOV 144	)	×
145	.unwrap();
146
UNCOV 147	for file in ["data/any.rs", "data/mod.rs"] {	×
UNCOV 148	std::fs::remove_file(path.join(file)).unwrap();	×
149	}
UNCOV 150	}	×
UNCOV 151	}	×

zbraniecki / icu4x / 7319540133

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