8219362155

Committed 08 Mar 2024 01:21PM UTC coverage: 75.985% (+3.0%) from 73.009%

Build # 8219362155

Build Type

push

github

Committed by

web-flow

Commit Message

Bump diplomat (#4671)

And fix some Dart renames

Run Details

49581 of 65251 relevant lines covered (75.99%)

519628.46 hits per line

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

1.79

/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 EXPERIMENTAL_VERSION: &str = "0.0.0";
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),
    ("datetime", icu::datetime::provider::KEYS, REPO_VERSION),
    ("decimal", icu::decimal::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),
    ("segmenter", icu::segmenter::provider::KEYS, REPO_VERSION),
    ("timezone", icu::timezone::provider::KEYS, REPO_VERSION),
    (
        "experimental",
        icu_experimental::provider::KEYS,
        EXPERIMENTAL_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;

    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, template) in [
            ("build.rs", include_str!("../template/build.rs.template")),
            (
                "Cargo.toml",
                include_str!("../template/Cargo.toml.template"),
            ),
            ("LICENSE", include_str!("../LICENSE")),
            ("README.md", include_str!("../template/README.md.template")),
            (
                "src/lib.rs",
                include_str!("../template/src/lib.rs.template"),
            ),
        ] {
            std::fs::write(
                path.join(file),
                template
                    .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();
        }

        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	const EXPERIMENTAL_VERSION: &str = "0.0.0";
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	("datetime", icu::datetime::provider::KEYS, REPO_VERSION),
18	("decimal", icu::decimal::provider::KEYS, REPO_VERSION),
19	("list", icu::list::provider::KEYS, REPO_VERSION),
20	(
21	"locid_transform",
22	icu::locid_transform::provider::KEYS,
23	REPO_VERSION,
24	),
25	("normalizer", icu::normalizer::provider::KEYS, REPO_VERSION),
26	("plurals", icu::plurals::provider::KEYS, REPO_VERSION),
27	("properties", icu::properties::provider::KEYS, REPO_VERSION),
28	("segmenter", icu::segmenter::provider::KEYS, REPO_VERSION),
29	("timezone", icu::timezone::provider::KEYS, REPO_VERSION),
30	(
31	"experimental",
32	icu_experimental::provider::KEYS,
33	EXPERIMENTAL_VERSION,
34	),
35	];
36
37	fn main() {	×
38	simple_logger::SimpleLogger::new()	×
39	.env()
40	.with_level(log::LevelFilter::Info)	×
41	.init()
42	.unwrap();
43
44	let args = std::env::args();	×
45
46	let components = if args.len() == 1 {	×
47	COMPONENTS	×
48	.iter()
49	.map(\|(krate, keys, version)\| (krate.to_string(), keys, version))	×
50	.collect::<Vec<_>>()
51	} else {
52	let map = std::collections::HashMap::<&str, (&'static [DataKey], &'static str)>::from_iter(	×
53	COMPONENTS	×
54	.iter()
55	.map(\|(krate, keys, version)\| (krate, (keys, *version))),	×
56	);
57	args.skip(1)	×
58	.filter_map(\|krate\| {	×
59	map.get(krate.as_str())	×
60	.map(\|(keys, version)\| (krate, keys, version))	×
61	})	×
62	.collect()
63	};	×
64
65	let source = DatagenProvider::new_latest_tested();	×
66
67	let driver = DatagenDriver::new()	×
68	.with_locales(
69	source	×
70	.locales_for_coverage_levels([	×
71	CoverageLevel::Modern,	×
72	CoverageLevel::Moderate,	×
73	CoverageLevel::Basic,	×
74	])
75	.unwrap(),
76	)	×
77	.with_recommended_segmenter_models()
78	.with_fallback_mode(FallbackMode::Runtime);	×
79
80	let mut options = Options::default();	×
81	options.overwrite = true;	×
82	options.pretty = true;	×
83
84	for (component, keys, version) in &components {	×
85	let path = Path::new("provider/baked").join(component);	×
86
87	let _ = std::fs::remove_dir_all(&path);	×
88	for dir in ["", "src", "data"] {	×
89	std::fs::create_dir(&path.join(dir)).unwrap();	×
90	}
91	for (file, template) in [	×
92	("build.rs", include_str!("../template/build.rs.template")),	×
93	(	×
94	"Cargo.toml",
95	include_str!("../template/Cargo.toml.template"),
96	),
97	("LICENSE", include_str!("../LICENSE")),	×
98	("README.md", include_str!("../template/README.md.template")),	×
99	(	×
100	"src/lib.rs",
101	include_str!("../template/src/lib.rs.template"),
102	),
103	] {
104	std::fs::write(	×
105	path.join(file),	×
106	template	×
107	.replace("_component_", component)	×
108	.replace("_version_", version)	×
109	.replace("_cldr_tag_", DatagenProvider::LATEST_TESTED_CLDR_TAG)
110	.replace(
111	"_icuexport_tag_",
112	DatagenProvider::LATEST_TESTED_ICUEXPORT_TAG,
113	)
114	.replace(
115	"_segmenter_lstm_tag_",
116	DatagenProvider::LATEST_TESTED_SEGMENTER_LSTM_TAG,
117	),
118	)	×
119	.unwrap();	×
120	}
121
122	driver	×
123	.clone()	×
124	.with_keys(keys.iter().copied())	×
125	.export(
126	&source,
127	BakedExporter::new(path.join("data"), options).unwrap(),	×
128	)	×
129	.unwrap();
130
131	for file in ["data/any.rs", "data/mod.rs"] {	×
132	std::fs::remove_file(path.join(file)).unwrap();	×
133	}
134	}	×
135	}	×

zbraniecki / icu4x / 8219362155

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