| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #![allow(deprecated)] |
| |
| use { |
| crate::{ |
| constants::{LOCAL_ASSET_DIRECTORY, PKG_URL_PREFIX}, |
| font_catalog as fc, |
| font_catalog::{AssetInFamilyIndex, FamilyIndex}, |
| product_config, FontCatalog, FontPackageListing, FontSet, FontSets, ProductConfig, |
| TypefaceInAssetIndex, |
| }, |
| anyhow::{format_err, Error}, |
| char_set::CharSet, |
| font_info::{FontAssetSource, FontInfo, FontInfoLoader}, |
| fuchsia_url::pkg_url::PkgUrl, |
| itertools::{Either, Itertools}, |
| manifest::v2, |
| std::{ |
| collections::{BTreeMap, BTreeSet}, |
| fmt, |
| path::{Path, PathBuf}, |
| }, |
| thiserror::Error, |
| }; |
| |
| type AssetKey = (FamilyIndex, AssetInFamilyIndex); |
| |
| /// Collection of font metadata used for generating a font manifest for a particular target. |
| /// |
| /// Contains indices by family and asset names, which all provide access only to those fonts that |
| /// are included in `font_sets`. (`font_catalog` may contain other fonts that are not included in |
| /// the target product.) |
| /// |
| /// For test coverage, please see the integration tests. |
| #[derive(Debug)] |
| pub struct FontDb { |
| font_catalog: FontCatalog, |
| font_sets: FontSets, |
| product_config: ProductConfig, |
| |
| family_name_to_family: BTreeMap<String, FamilyIndex>, |
| asset_name_to_assets: BTreeMap<String, BTreeSet<AssetKey>>, |
| asset_name_to_pkg_url: BTreeMap<String, PkgUrl>, |
| typeface_to_char_set: BTreeMap<(String, TypefaceInAssetIndex), CharSet>, |
| } |
| |
| impl FontDb { |
| /// Tries to create a new instance of `FontDb`. |
| pub fn new<P: AsRef<Path>>( |
| font_catalog: FontCatalog, |
| font_pkgs: FontPackageListing, |
| font_sets: FontSets, |
| product_config: ProductConfig, |
| font_info_loader: impl FontInfoLoader, |
| font_dir: P, |
| ) -> Result<FontDb, FontDbErrors> { |
| let mut family_name_to_family = BTreeMap::new(); |
| let mut asset_name_to_assets = BTreeMap::new(); |
| let mut asset_name_to_pkg_url = BTreeMap::new(); |
| let typeface_to_char_set = BTreeMap::new(); |
| |
| let mut errors: Vec<FontDbError> = vec![]; |
| |
| for (family_idx, family) in (&font_catalog.families).iter().enumerate() { |
| let family_idx = FamilyIndex(family_idx); |
| let mut asset_count = 0; |
| for (asset_idx, asset) in (&family.assets).iter().enumerate() { |
| let asset_idx = AssetInFamilyIndex(asset_idx); |
| let asset_name = asset.file_name.clone(); |
| if asset.typefaces.is_empty() { |
| errors.push(FontDbError::FontCatalogNoTypeFaces { asset_name }); |
| continue; |
| } |
| |
| if font_sets.get_font_set(&asset.file_name).is_some() { |
| let safe_name = font_pkgs.get_safe_name(&asset_name); |
| if safe_name.is_none() { |
| errors.push(FontDbError::FontPkgsMissingEntry { asset_name }); |
| continue; |
| } |
| |
| let pkg_url = Self::make_pkg_url(safe_name.unwrap()); |
| if let Err(error) = pkg_url { |
| errors.push(error); |
| continue; |
| } |
| let pkg_url = pkg_url.unwrap(); |
| |
| asset_name_to_assets |
| .entry(asset_name.clone()) |
| .or_insert_with(|| BTreeSet::new()) |
| .insert((family_idx, asset_idx)); |
| asset_name_to_pkg_url.insert(asset_name.clone(), pkg_url); |
| |
| asset_count += 1; |
| } |
| } |
| // Skip families where no assets are included in the target product |
| if asset_count > 0 { |
| family_name_to_family.insert(family.name.clone(), family_idx); |
| } |
| } |
| |
| // typeface_to_char_set is empty at this point. |
| let mut db = FontDb { |
| font_catalog, |
| font_sets, |
| product_config, |
| family_name_to_family, |
| asset_name_to_assets, |
| asset_name_to_pkg_url, |
| typeface_to_char_set, |
| }; |
| |
| let mut fallback_typeface_counts: BTreeMap<v2::TypefaceId, usize> = BTreeMap::new(); |
| // TODO(fxbug.dev/46156): Switch to iter_fallback_chain() when legacy fallbacks are removed. |
| for typeface_id in db.iter_explicit_fallback_chain() { |
| *fallback_typeface_counts.entry(typeface_id.clone()).or_insert(0) += 1; |
| // Confirm that the TypefaceId in the fallback chain actually exists in the database. |
| if !db |
| .get_assets_by_name(&typeface_id.file_name) |
| .iter() |
| .any(|asset| asset.typefaces.contains_key(&typeface_id.index.into())) |
| { |
| errors.push(FontDbError::UnknownFallbackChainEntry { |
| typeface_id: typeface_id.clone(), |
| }) |
| } |
| } |
| for (typeface_id, count) in fallback_typeface_counts.into_iter() { |
| if count > 1 { |
| errors.push(FontDbError::DuplicateFallbackChainEntry { typeface_id }) |
| } |
| } |
| |
| let font_infos = Self::load_font_infos(&db, &font_pkgs, font_info_loader, font_dir); |
| |
| match font_infos { |
| Ok(font_infos) => { |
| for (request, font_info) in font_infos { |
| db.typeface_to_char_set.insert( |
| (request.asset_name(), TypefaceInAssetIndex(request.index)), |
| font_info.char_set, |
| ); |
| } |
| } |
| Err(mut font_info_errors) => { |
| errors.append(&mut font_info_errors); |
| } |
| } |
| |
| if errors.is_empty() { |
| Ok(db) |
| } else { |
| Err(FontDbErrors(errors.into())) |
| } |
| } |
| |
| pub fn get_family_by_name(&self, family_name: impl AsRef<str>) -> Option<&fc::Family> { |
| let family_idx = self.family_name_to_family.get(family_name.as_ref())?; |
| self.font_catalog.families.get(family_idx.0) |
| } |
| |
| /// Get all [`Asset`]s with the given file name. There may be more than one instance if the |
| /// asset appears in multiple font families. |
| pub fn get_assets_by_name(&self, asset_name: impl AsRef<str>) -> Vec<&fc::Asset> { |
| self.asset_name_to_assets |
| .get(asset_name.as_ref()) |
| // Iterate over the 0 or 1 values inside Option |
| .iter() |
| .flat_map(|asset_keys| asset_keys.iter()) |
| .flat_map(move |(family_idx, asset_idx)| { |
| self.font_catalog |
| .families |
| .get(family_idx.0) |
| .and_then(|family| family.get_asset(*asset_idx)) |
| }) |
| .collect_vec() |
| } |
| |
| /// The asset must be in the `FontDb` or this method will panic. |
| pub fn get_code_points(&self, asset: &fc::Asset, index: TypefaceInAssetIndex) -> &CharSet { |
| // Alas, no sane way to transpose between `(&str, &x)` and `&(String, x)`. |
| let key = (asset.file_name.to_owned(), index); |
| self.typeface_to_char_set |
| .get(&key) |
| .ok_or_else(|| format_err!("No code points for {:?}", &key)) |
| .unwrap() |
| } |
| |
| /// The asset must be in the `FontDb` or this method will panic. |
| pub fn get_asset_location(&self, asset: &fc::Asset) -> v2::AssetLocation { |
| match self.font_sets.get_font_set(&*asset.file_name).unwrap() { |
| FontSet::Local => v2::AssetLocation::LocalFile(v2::LocalFileLocator { |
| directory: PathBuf::from(LOCAL_ASSET_DIRECTORY), |
| }), |
| FontSet::Download => v2::AssetLocation::Package(v2::PackageLocator { |
| url: self.asset_name_to_pkg_url.get(&*asset.file_name).unwrap().clone(), |
| }), |
| } |
| } |
| |
| /// Iterates over all the _included_ font families in the `FontDb`. |
| pub fn iter_families(&self) -> impl Iterator<Item = &'_ fc::Family> + '_ { |
| self.font_catalog |
| .families |
| .iter() |
| .filter(move |family| self.get_family_by_name(&*family.name).is_some()) |
| } |
| |
| /// Iterates over all the _included_ assets in the given font family. Note this is _not_ the |
| /// same as iterating over `Family::assets`. |
| pub fn iter_assets<'a>( |
| &'a self, |
| family: &'a fc::Family, |
| ) -> impl Iterator<Item = &'a fc::Asset> + 'a { |
| family |
| .assets |
| .iter() |
| .filter(move |asset| !self.get_assets_by_name(&*asset.file_name).is_empty()) |
| } |
| |
| /// Iterates over the `TypefaceId`s in the target product's fallback chain, plus those marked as |
| /// `"fallback": true` in font catalog files. |
| pub fn iter_fallback_chain<'a>(&'a self) -> impl Iterator<Item = v2::TypefaceId> + 'a { |
| // .unique() eliminates any duplicates from the legacy chain that are already in the |
| // explicit one. |
| itertools::chain(self.iter_explicit_fallback_chain(), self.iter_legacy_fallback_chain()) |
| .unique() |
| } |
| |
| /// Gets a list of `TypefaceId`s that are not used in the _explicit_ fallback chain, for debugging. |
| pub fn iter_non_fallback_typefaces<'a>(&'a self) -> impl Iterator<Item = v2::TypefaceId> + 'a { |
| let fallback_typefaces: BTreeSet<v2::TypefaceId> = |
| self.iter_explicit_fallback_chain().collect(); |
| self.iter_families() |
| .flat_map(move |family| self.family_to_typeface_ids(family)) |
| .filter(move |typeface_id| !fallback_typefaces.contains(typeface_id)) |
| } |
| |
| /// Iterates over the `TypefaceId`s in the target product's fallback chain. |
| fn iter_explicit_fallback_chain<'a>(&'a self) -> impl Iterator<Item = v2::TypefaceId> + 'a { |
| /// Converts a product config TypefaceId into one or more manifest typeface IDs |
| /// (an omitted font index expands to multiple indices). |
| fn get_manifest_typeface_ids<'b>( |
| font_db: &'b FontDb, |
| id: &product_config::TypefaceId, |
| ) -> impl Iterator<Item = v2::TypefaceId> + 'b { |
| // TODO: Dynamic type acrobatics instead of collecting into `Vec`s. |
| match id.index { |
| Some(index) => vec![v2::TypefaceId::new(&id.file_name, index.0)], |
| None => font_db |
| .get_assets_by_name(&id.file_name) |
| .iter() |
| .flat_map(|asset| FontDb::asset_to_typeface_ids(asset)) |
| .collect_vec(), |
| } |
| .into_iter() |
| } |
| |
| self.product_config |
| .iter_fallback_chain() |
| .flat_map(move |id| get_manifest_typeface_ids(self, id)) |
| .into_iter() |
| } |
| |
| /// Iterates over legacy fallbacks specified by `"fallback": true` in the font catalog. |
| // TODO(fxbug.dev/46156): Remove this code after all product font collections and font catalogs |
| // are updated. |
| fn iter_legacy_fallback_chain<'a>(&'a self) -> impl Iterator<Item = v2::TypefaceId> + 'a { |
| self.iter_families() |
| .filter(|family| family.fallback) |
| .flat_map(move |family| self.family_to_typeface_ids(family)) |
| .into_iter() |
| } |
| |
| fn family_to_typeface_ids<'a>( |
| &'a self, |
| family: &'a fc::Family, |
| ) -> impl Iterator<Item = v2::TypefaceId> + 'a { |
| self.iter_assets(family).flat_map(FontDb::asset_to_typeface_ids) |
| } |
| |
| fn asset_to_typeface_ids<'a>( |
| asset: &'a fc::Asset, |
| ) -> impl Iterator<Item = v2::TypefaceId> + 'a { |
| let file_name = asset.file_name.clone(); |
| asset |
| .typefaces |
| .keys() |
| .map(move |key| v2::TypefaceId { file_name: file_name.clone(), index: key.0 }) |
| } |
| |
| fn make_pkg_url(safe_name: impl AsRef<str>) -> Result<PkgUrl, FontDbError> { |
| let pkg_url = format!("{}{}", PKG_URL_PREFIX, safe_name.as_ref()); |
| Ok(PkgUrl::parse(&pkg_url).map_err(|error| FontDbError::PkgUrl { error: error.into() })?) |
| } |
| |
| fn load_font_infos( |
| db: &FontDb, |
| font_pkgs: &FontPackageListing, |
| font_info_loader: impl FontInfoLoader, |
| font_dir: impl AsRef<Path>, |
| ) -> Result<Vec<(FontInfoRequest, FontInfo)>, Vec<FontDbError>> { |
| let (requests, errors): (Vec<_>, Vec<_>) = db |
| .font_sets |
| .iter() |
| .map(|(asset_name, _)| { |
| Self::asset_to_font_info_requests(db, font_pkgs, font_dir.as_ref(), asset_name) |
| }) |
| .flatten() |
| .partition_map(|r| match r { |
| Ok(data) => Either::Left(data), |
| Err(err) => Either::Right(err), |
| }); |
| |
| if !errors.is_empty() { |
| return Err(errors); |
| } |
| |
| let (font_infos, errors): (Vec<_>, Vec<_>) = requests |
| .into_iter() |
| .map(|request| { |
| let source = FontAssetSource::FilePath(request.path.to_str().unwrap().to_owned()); |
| let font_info = font_info_loader.load_font_info(source, request.index); |
| match font_info { |
| Ok(font_info) => Ok((request, font_info)), |
| Err(error) => Err(FontDbError::FontInfo { request, error }), |
| } |
| }) |
| .partition_map(|r| match r { |
| Ok(data) => Either::Left(data), |
| Err(err) => Either::Right(err), |
| }); |
| |
| if !errors.is_empty() { |
| Err(errors) |
| } else { |
| Ok(font_infos) |
| } |
| } |
| |
| fn asset_to_font_info_requests( |
| db: &FontDb, |
| font_pkgs: &FontPackageListing, |
| font_dir: impl AsRef<Path>, |
| asset_name: &str, |
| ) -> Vec<Result<FontInfoRequest, FontDbError>> { |
| let mut path = font_dir.as_ref().to_path_buf(); |
| |
| let path_prefix = font_pkgs.get_path_prefix(asset_name); |
| if path_prefix.is_none() { |
| return vec![Err(FontDbError::FontPkgsMissingEntry { |
| asset_name: asset_name.to_owned(), |
| })]; |
| } |
| |
| let path_prefix = path_prefix.unwrap(); |
| path.push(path_prefix); |
| path.push(asset_name); |
| |
| // We have to collect into a vector here because otherwise there's no way to return a |
| // consistent `Iterator` type. |
| let requests = db |
| .get_assets_by_name(asset_name) |
| .iter() |
| .flat_map(|asset| asset.typefaces.keys()) |
| .map(move |index| Ok(FontInfoRequest { path: path.clone(), index: index.0 })) |
| .collect_vec(); |
| |
| if requests.is_empty() { |
| vec![Err(FontDbError::FontCatalogMissingEntry { asset_name: asset_name.to_owned() })] |
| } else { |
| requests |
| } |
| } |
| } |
| |
| /// Collection of errors from loading / building `FontDb`. |
| #[derive(Debug, Error)] |
| #[error("Errors occurred while building FontDb: {}", _0)] |
| pub struct FontDbErrors(FontDbErrorVec); |
| |
| #[derive(Debug)] |
| pub struct FontDbErrorVec(Vec<FontDbError>); |
| |
| impl From<Vec<FontDbError>> for FontDbErrorVec { |
| fn from(errors: Vec<FontDbError>) -> Self { |
| FontDbErrorVec(errors) |
| } |
| } |
| |
| impl From<FontDbErrors> for Vec<FontDbError> { |
| fn from(wrapper: FontDbErrors) -> Self { |
| (wrapper.0).0 |
| } |
| } |
| |
| impl fmt::Display for FontDbErrorVec { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| let descriptions = self.0.iter().map(|e| format!("{}", e)).collect_vec(); |
| write!(f, "{:#?}", descriptions) |
| } |
| } |
| |
| /// An error in a single `FontDb` operation. |
| #[derive(Debug, Error)] |
| pub enum FontDbError { |
| #[error("Asset {} has no typefaces", asset_name)] |
| FontCatalogNoTypeFaces { asset_name: String }, |
| |
| #[error("Asset {} is not listed in *.font_pkgs.json", asset_name)] |
| FontPkgsMissingEntry { asset_name: String }, |
| |
| #[error("Asset {} is not listed in *.font_catalog.json", asset_name)] |
| FontCatalogMissingEntry { asset_name: String }, |
| |
| #[error("Fallback asset {}, index {} is unknown", typeface_id.file_name, typeface_id.index)] |
| UnknownFallbackChainEntry { typeface_id: v2::TypefaceId }, |
| |
| #[error("Multiple entries in fallback chain for {}, index {}", typeface_id.file_name, typeface_id.index)] |
| DuplicateFallbackChainEntry { typeface_id: v2::TypefaceId }, |
| |
| #[error("PkgUrl error: {:?}", error)] |
| PkgUrl { error: Error }, |
| |
| #[error("Failed to load font info for {:?}: {:?}", request, error)] |
| FontInfo { request: FontInfoRequest, error: Error }, |
| } |
| |
| /// Metadata needed for [`FontInfoLoader::load_font_info`]. |
| #[derive(Debug, Clone)] |
| pub struct FontInfoRequest { |
| /// Path to the file |
| path: PathBuf, |
| /// Index of the font in the file |
| index: u32, |
| } |
| |
| impl FontInfoRequest { |
| fn asset_name(&self) -> String { |
| self.path.file_name().and_then(|os_str| os_str.to_str()).unwrap().to_owned() |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use { |
| super::*, |
| crate::{ |
| fake_font_info_loader::FakeFontInfoLoaderImpl, |
| font_catalog::{Asset, Family, Typeface, TypefaceInAssetIndex}, |
| font_pkgs::{FontPackageEntry, FontPackageListing}, |
| font_sets::{FontSet, FontSets}, |
| product_config::{ProductConfig, Settings, TypefaceId}, |
| }, |
| fidl_fuchsia_fonts::{GenericFontFamily, Slant, Width}, |
| manifest::v2::Style, |
| maplit::btreemap, |
| matches::assert_matches, |
| }; |
| |
| fn make_font_db_contents() -> (FontCatalog, FontPackageListing, FontSets) { |
| let font_catalog = FontCatalog { |
| families: vec![Family { |
| name: "Alpha Sans".to_string(), |
| aliases: vec![], |
| generic_family: Some(GenericFontFamily::SansSerif), |
| fallback: true, |
| assets: vec![Asset { |
| file_name: "AlphaSans-Regular.ttc".to_string(), |
| typefaces: btreemap! { |
| TypefaceInAssetIndex(0) => Typeface { |
| index: 0, |
| languages: vec!["en".to_string()], |
| style: Style { |
| slant: Slant::Upright, |
| weight: 400, |
| width: Width::Normal, |
| }, |
| }, |
| TypefaceInAssetIndex(2) => Typeface { |
| index: 2, |
| languages: vec!["ru".to_string()], |
| style: Style { |
| slant: Slant::Upright, |
| weight: 400, |
| width: Width::Normal, |
| }, |
| }, |
| }, |
| }], |
| }], |
| }; |
| |
| let font_pkgs = FontPackageListing::new(btreemap! { |
| "AlphaSans-Regular.ttc".to_string() => |
| FontPackageEntry::new( |
| "AlphaSans-Regular.ttc", |
| "alphasans-regular-ttc", |
| "alphasans/", |
| ), |
| }); |
| |
| let font_sets = FontSets::new(btreemap! { |
| "AlphaSans-Regular.ttc".to_string() => FontSet::Local, |
| }); |
| |
| (font_catalog, font_pkgs, font_sets) |
| } |
| |
| /// The fallback chain references an unknown asset. |
| #[test] |
| fn test_unknown_fallback_asset() -> Result<(), Error> { |
| let (font_catalog, font_pkgs, font_sets) = make_font_db_contents(); |
| |
| let product_config = ProductConfig { |
| fallback_chain: vec![TypefaceId::new("BetaSans-Regular.ttc", 0)], |
| settings: Settings { cache_size_bytes: None }, |
| }; |
| |
| let result = FontDb::new( |
| font_catalog, |
| font_pkgs, |
| font_sets, |
| product_config, |
| FakeFontInfoLoaderImpl::new(), |
| "foo/bar", |
| ); |
| |
| assert!(result.is_err()); |
| let errors: Vec<FontDbError> = result.unwrap_err().into(); |
| assert_matches!(errors[0], FontDbError::UnknownFallbackChainEntry{ typeface_id: _ }); |
| |
| Ok(()) |
| } |
| |
| /// The fallback chain references a known asset with an unknown typeface index. |
| #[test] |
| fn test_unknown_fallback_typeface_index() -> Result<(), Error> { |
| let (font_catalog, font_pkgs, font_sets) = make_font_db_contents(); |
| |
| let product_config = ProductConfig { |
| fallback_chain: vec![TypefaceId::new("AlphaSans-Regular.ttc", 1)], |
| settings: Settings { cache_size_bytes: None }, |
| }; |
| |
| let result = FontDb::new( |
| font_catalog, |
| font_pkgs, |
| font_sets, |
| product_config, |
| FakeFontInfoLoaderImpl::new(), |
| "foo/bar", |
| ); |
| |
| assert!(result.is_err()); |
| let errors: Vec<FontDbError> = result.unwrap_err().into(); |
| assert_matches!(errors[0], FontDbError::UnknownFallbackChainEntry{ typeface_id: _ }); |
| |
| Ok(()) |
| } |
| } |
