Struct AppConfig 

pub struct AppConfig {

    pub import: Vec<String>,
    pub catalogs: Vec<CatalogRef>,
    pub read_catalogs: Vec<Catalog>,
    pub catalog_dir: Option<PathBuf>,
    pub broken_catalogs: Vec<Broken>,
    pub read: ReadConfig,
    pub csv: CsvConfig,
    pub display: DisplayConfig,
    pub performance: PerformanceConfig,
    pub analysis: AnalysisConfig,
    pub chart: ChartConfig,
    pub home: HomeConfig,
    pub cloud: CloudConfig,
    pub http: HttpConfig,
    pub query: QueryConfig,
    pub views: ViewsConfig,
    pub clipboard: ClipboardConfig,
    pub formats: FormatsConfig,
    pub log: LogConfig,
    pub theme: ThemeConfig,
    pub glyphs: GlyphsConfig,
}

Complete application configuration

Fields

import: Vec<String>

Additional config files merged in before this file’s own values.

catalogs: Vec<CatalogRef>

Catalog files elsewhere, listed on the home screen besides catalog.toml and catalogs/: a path, or { path, id, label }.

read_catalogs: Vec<Catalog>

The catalogs read: catalog.toml, then each of catalogs. Not a key: read by AppConfig::read_catalog_files once the layers are merged.

catalog_dir: Option<PathBuf>

The directory catalog.toml was looked for in: the config file’s.

broken_catalogs: Vec<Broken>

Catalog files left out for a mistake, each with what is wrong.

read: ReadConfig

csv: CsvConfig

display: DisplayConfig

performance: PerformanceConfig

analysis: AnalysisConfig

chart: ChartConfig

home: HomeConfig

cloud: CloudConfig

http: HttpConfig

query: QueryConfig

views: ViewsConfig

clipboard: ClipboardConfig

formats: FormatsConfig

log: LogConfig

theme: ThemeConfig

glyphs: GlyphsConfig

Implementations

impl AppConfig

pub fn load(app_name: &str) -> Result<Self>

Load configuration from all layers (default → imports → user config)

pub fn load_with(app_name: &str, overrides: &[Override]) -> Result<Self>

Self::load, with -c KEY=VALUE over the files.

pub fn load_from_file(config_path: &Path) -> Result<Self>

Load configuration rooted at config_path, resolving its import chain.

Layers apply lowest precedence first: datui’s defaults, then every file named by import in declaration order (depth-first, so an imported file’s own imports land before it), then config_path’s own values. Each layer changes only the keys it writes, so an imported theme restyles datui while anything the user writes, a default value included, still wins.

A missing root file means defaults. A root file that exists but cannot be read or parsed is an error naming it: running on defaults would quietly discard every setting in it. A missing import is skipped with a warning — the file is often generated by a theme system that may not have run yet — but an import that exists and cannot be read or parsed is an error too.

pub fn load_from_file_with( config_path: &Path, overrides: &[Override], ) -> Result<Self>

Self::load_from_file, with -c KEY=VALUE laid over every file.

pub fn read_layers( config_path: &Path, overrides: &[Override], ) -> Result<Vec<(LayerSource, ConfigLayer)>>

Every layer the configuration rooted at config_path is built from, lowest precedence first: each import, depth-first, then the file, then -c. Each is named by where it came from. A missing root file contributes nothing.

pub fn from_read_layers( config_path: &Path, overrides: &[Override], layers: &[(LayerSource, ConfigLayer)], ) -> Result<Self>

The configuration layers, read by Self::read_layers for config_path, describe: merged over the defaults and validated.

pub fn from_layers( layers: impl IntoIterator<Item = ConfigLayer>, ) -> Result<Self>

The configuration layers describe, lowest precedence first, over datui’s defaults. Defaults are resolved here, once: a layer holds only what it wrote.

The colors start from the theme theme.dark or theme.light names for the theme.mode the layers declare, built-ins only: from_read_layers adds the theme files. import is left empty; load_from_file follows imports and reports them. Not validated.

pub fn read_theme_files(&mut self, config_dir: Option<&Path>) -> Result<()>

Resolve theme.dark and theme.light with the theme files in config_dir’s themes/ as well as the built-ins. A file with a mistake, or a name that cannot be used, is said on stderr and the log, and its mode falls back to the built-in: as with catalogs, it never stops datui from starting.

pub fn catalogs(&self) -> Vec<Catalog>

Every catalog, hidden ones included: catalog.toml, the listed files in order, then the bundled examples catalog, unless a listed file named examples.toml replaces it.

pub fn shown_catalogs(&self) -> Vec<Catalog>

The catalogs the home screen shows: Self::catalogs less [home] hide, which names a whole catalog by its id or one entry as catalog/id.

pub fn hides_nothing(name: &str) -> String

The [home] hide names no catalog or entry has, each once. Why name in home.hide hides nothing, with the fix when the name is the bundled catalog’s old id: public is now examples.

pub fn unknown_hidden(&self) -> Vec<String>

pub fn read_catalog_files(&mut self, config_dir: Option<&Path>) -> Result<()>

Read catalog.toml from config_dir, when there is one, every *.toml in its catalogs/ directory, by name, and every file catalogs lists. A listed file that is not there is skipped with a warning, as a missing import is: it may be on a share that is not mounted.

pub fn sync_dataset_access(&mut self)

Derive [cloud]’s view of how catalog URLs are read. Called by from_layers, read_catalog_files and default; call it after changing the catalogs by hand.

pub fn validate(&self) -> Result<()>

Validate configuration values

Trait Implementations

impl Clone for AppConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AppConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AppConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AppConfig

where AppConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AppConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.