8611306223

Committed 09 Apr 2024 06:09AM UTC coverage: 76.234% (+0.2%) from 75.985%

Build # 8611306223

Build Type

push

github

Committed by

web-flow

Commit Message

Updating tutorial lock files (#4784)

Needed for https://github.com/unicode-org/icu4x/pull/4776

Run Details

51696 of 67812 relevant lines covered (76.23%)

512021.21 hits per line

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

1.75

/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_and_fallback(
            source
                .locales_for_coverage_levels([
                    CoverageLevel::Modern,
                    CoverageLevel::Moderate,
                    CoverageLevel::Basic,
                ])
                .unwrap()
                .into_iter()
                .map(LocaleFamily::with_descendants),
            Default::default(),
        )
        .with_recommended_segmenter_models();

    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_and_fallback(
69	source	×
70	.locales_for_coverage_levels([	×
71	CoverageLevel::Modern,	×
72	CoverageLevel::Moderate,	×
73	CoverageLevel::Basic,	×
74	])
75	.unwrap()
76	.into_iter()
77	.map(LocaleFamily::with_descendants),	×
78	Default::default(),	×
79	)	×
80	.with_recommended_segmenter_models();
81
82	let mut options = Options::default();	×
83	options.overwrite = true;	×
84	options.pretty = true;	×
85
86	for (component, keys, version) in &components {	×
87	let path = Path::new("provider/baked").join(component);	×
88
89	let _ = std::fs::remove_dir_all(&path);	×
90	for dir in ["", "src", "data"] {	×
91	std::fs::create_dir(&path.join(dir)).unwrap();	×
92	}
93	for (file, template) in [	×
94	("build.rs", include_str!("../template/build.rs.template")),	×
95	(	×
96	"Cargo.toml",
97	include_str!("../template/Cargo.toml.template"),
98	),
99	("LICENSE", include_str!("../LICENSE")),	×
100	("README.md", include_str!("../template/README.md.template")),	×
101	(	×
102	"src/lib.rs",
103	include_str!("../template/src/lib.rs.template"),
104	),
105	] {
106	std::fs::write(	×
107	path.join(file),	×
108	template	×
109	.replace("_component_", component)	×
110	.replace("_version_", version)	×
111	.replace("_cldr_tag_", DatagenProvider::LATEST_TESTED_CLDR_TAG)
112	.replace(
113	"_icuexport_tag_",
114	DatagenProvider::LATEST_TESTED_ICUEXPORT_TAG,
115	)
116	.replace(
117	"_segmenter_lstm_tag_",
118	DatagenProvider::LATEST_TESTED_SEGMENTER_LSTM_TAG,
119	),
120	)	×
121	.unwrap();	×
122	}
123
124	driver	×
125	.clone()	×
126	.with_keys(keys.iter().copied())	×
127	.export(
128	&source,
129	BakedExporter::new(path.join("data"), options).unwrap(),	×
130	)	×
131	.unwrap();
132
133	for file in ["data/any.rs", "data/mod.rs"] {	×
134	std::fs::remove_file(path.join(file)).unwrap();	×
135	}
136	}	×
137	}	×

zbraniecki / icu4x / 8611306223

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