config.rs 82.1%

170 of 207 lines run, 34 of 52 functions · run #251 on main · run missed

//! Layered configuration: defaults, the user file, the repository file.

use super::*;

/// Effective settings: defaults, then the user file (`~/.config/oxy/config.toml`,
/// spec §19), then the repository file (`.oxy/config`). Both files are
/// `key = "value"` lines. `save` writes only the repository layer.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Config {
    /// Keys set in the repository file (or via `set`), written by `save`.
    repo_layer: BTreeMap<String, String>,
    pub author_name: String,
    pub author_email: String,
    /// The KeyId of the author's identity, once `create_identity` has run.
    pub author_key: Option<KeyId>,
    /// `author.signer` (or `$OXY_SIGNER`): the key that signs and seals in
    /// place of `author.key`, whose identity lists it as a delegate. An
    /// agent sets it to its own key, so its changes carry the human as
    /// author and the agent's signature (spec §14.2, agent workflows §2).
    pub signer_key: Option<KeyId>,
    /// `core.sign`: sign every change at commit (`true`) or leave signing to
    /// push-time seals (`false`, the spec default).
    pub sign_changes: bool,
    pub bookmark: String,
    /// `remote.<name>.url`.
    pub remotes: BTreeMap<String, String>,
    /// `remote.<name>.token`: bearer token for HTTP pushes.
    pub remote_tokens: BTreeMap<String, String>,
    /// `remote.<name>.ca`: PEM file of extra roots to trust for that remote.
    pub remote_cas: BTreeMap<String, String>,
    /// `core.op-retention`: days for which operations keep their states reachable (spec §12.1, §21).
    pub op_retention_days: u64,
    /// `core.gc-grace`: days an unreachable object survives, protecting concurrent writers (spec §21).
    pub gc_grace_days: u64,
    /// `core.checkpoint-interval`: changes between automatic checkpoints (spec §11).
    pub checkpoint_interval: u64,
    /// `filter.max-blob`: blobs larger than this many bytes are fetched lazily (spec §17).
    pub max_blob: Option<u64>,
    /// `filter.paths`: only these subtrees are materialized (spec §17); empty means everything.
    pub sparse_paths: Vec<String>,
    /// `hooks.semantic-deps`: run the semantic-deps hook at commit (spec §20).
    pub semantic_deps: bool,
    /// `revset.<name>`: a saved revset, used as `name()`.
    pub revsets: BTreeMap<String, String>,
    /// `storage.url`: the store the repository's objects and operation
    /// head are kept on (`dir://`, `s3://`, …) instead of `.oxy/objects`
    /// (oxygen#68).
    pub storage_url: Option<String>,
    /// `storage.cache`: the most the local cache in front of that store
    /// holds, in bytes.
    pub storage_cache: u64,
}

impl Config {
    pub(super) fn default_for_user() -> Config {
        let user = std::env::var("USER").unwrap_or_else(|_| "unknown".into());
        Config {
            repo_layer: BTreeMap::new(),
            author_name: std::env::var("OXY_AUTHOR_NAME").unwrap_or_else(|_| user.clone()),
            author_email: std::env::var("OXY_AUTHOR_EMAIL")
                .unwrap_or_else(|_| format!("{user}@localhost")),
            author_key: None,
            signer_key: std::env::var("OXY_SIGNER")
                .ok()
                .and_then(|v| KeyId::from_hex(&v)),
            sign_changes: false,
            bookmark: "main".into(),
            remotes: BTreeMap::new(),
            remote_tokens: BTreeMap::new(),
            remote_cas: BTreeMap::new(),
            op_retention_days: 90,
            gc_grace_days: 14,
            checkpoint_interval: 256,
            max_blob: None,
            sparse_paths: Vec::new(),
            semantic_deps: false,
            revsets: BTreeMap::new(),
            storage_url: None,
            storage_cache: DEFAULT_STORAGE_CACHE,
        }
    }

    /// Set a key in the repository layer, as `oxy config` does.
    pub fn set(&mut self, key: &str, value: &str) -> Result<()> {
        self.apply(key, value)?;
        if value.is_empty() {
            self.repo_layer.remove(key);
        } else {
            self.repo_layer.insert(key.to_string(), value.to_string());
        }
        Ok(())
    }

    /// Set a key in the user file without touching any repository.
    pub fn set_user(user_path: &Path, key: &str, value: &str) -> Result<()> {
        Config::default_for_user().apply(key, value)?;
        let mut entries = read_config_file(user_path)?;
        if value.is_empty() {
            entries.remove(key);
        } else {
            entries.insert(key.to_string(), value.to_string());
        }
        if let Some(parent) = user_path.parent() {
            fs::create_dir_all(parent)?;
        }
        write_config_file(user_path, &entries)
    }

    /// Apply a key to the effective values.
    pub(super) fn apply(&mut self, key: &str, value: &str) -> Result<()> {
        match key {
            "author.name" => self.author_name = value.into(),
            "author.email" => self.author_email = value.into(),
            "author.key" => {
                self.author_key = if value.is_empty() {
                    None
                } else {
                    Some(KeyId::from_hex(value).ok_or_else(|| {
                        RepoError::Msg("author.key must be a 64-character hex KeyId".into())
                    })?)
                }
            }
            "author.signer" => {
                self.signer_key = if value.is_empty() {
                    None
                } else {
                    Some(KeyId::from_hex(value).ok_or_else(|| {
                        RepoError::Msg("author.signer must be a 64-character hex KeyId".into())
                    })?)
                }
            }
            "core.sign" => {
                self.sign_changes = match value {
                    "change" => true,
                    "seal" => false,
                    _ => return fail("core.sign must be \"change\" or \"seal\""),
                }
            }
            "workspace.bookmark" => self.bookmark = value.into(),
            // Read by the credential store from the user file.
            "auth.helper" => {}
            "core.op-retention" => self.op_retention_days = parse_days(value)?,
            "core.gc-grace" => self.gc_grace_days = parse_days(value)?,
            "filter.max-blob" => {
                self.max_blob = if value.is_empty() {
                    None
                } else {
                    Some(parse_size(value)?)
                }
            }
            "storage.url" => {
                self.storage_url = (!value.is_empty()).then(|| value.to_string());
            }
            "storage.cache" => {
                self.storage_cache = if value.is_empty() {
                    DEFAULT_STORAGE_CACHE
                } else {
                    parse_size(value)?
                }
            }
            "hooks.semantic-deps" => self.semantic_deps = matches!(value, "true" | "1" | "yes"),
            "filter.paths" => {
                self.sparse_paths = value
                    .split(',')
                    .map(|p| {
                        p.trim()
                            .trim_start_matches("./")
                            .trim_matches('/')
                            .to_string()
                    })
                    .filter(|p| !p.is_empty())
                    .collect();
            }
            "core.checkpoint-interval" => {
                self.checkpoint_interval = value
                    .parse()
                    .map_err(|_| RepoError::Msg(format!("expected a number, got {value:?}")))?;
            }
            k if k.starts_with("remote.") => {
                let rest = &k["remote.".len()..];
                let Some((name, field)) = rest.rsplit_once('.') else {
                    return fail(format!("unknown configuration key {key:?}"));
                };
                if name.is_empty() || name.contains('/') {
                    return fail(format!("invalid remote name in {key:?}"));
                }
                let map = match field {
                    "url" => &mut self.remotes,
                    "token" => &mut self.remote_tokens,
                    "ca" => &mut self.remote_cas,
                    _ => return fail(format!("unknown configuration key {key:?}")),
                };
                if value.is_empty() {
                    map.remove(name);
                    if field == "url" {
                        self.remote_tokens.remove(name);
                        self.remote_cas.remove(name);
                    }
                } else {
                    map.insert(name.to_string(), value.into());
                }
            }
            k if k.starts_with("revset.") => {
                let name = &k["revset.".len()..];
                if name.is_empty()
                    || !name
                        .chars()
                        .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
                {
                    return fail(format!(
                        "a revset's name is letters, digits, _ and -: {key:?}"
                    ));
                }
                if value.is_empty() {
                    self.revsets.remove(name);
                } else {
                    crate::revset::parse(value)
                        .map_err(|e| RepoError::Msg(format!("{key} = {value:?}: {e}")))?;
                    self.revsets.insert(name.to_string(), value.into());
                }
            }
            _ => return fail(format!("unknown configuration key {key:?}")),
        }
        Ok(())
    }

    /// Defaults, then the user file if it exists, then the repository file.
    pub(super) fn load(user_path: Option<&Path>, repo_path: &Path) -> Result<Config> {
        let mut c = Config::default_for_user();
        if let Some(u) = user_path {
            for (k, v) in read_config_file(u)? {
                let _ = c.apply(&k, &v);
            }
        }
        for (k, v) in read_config_file(repo_path)? {
            if c.apply(&k, &v).is_ok() {
                c.repo_layer.insert(k, v);
            }
        }
        Ok(c)
    }

    pub(super) fn save(&self, path: &Path) -> Result<()> {
        write_config_file(path, &self.repo_layer)
    }

    /// Keys explicitly set for this repository.
    pub fn repo_layer(&self) -> &BTreeMap<String, String> {
        &self.repo_layer
    }
}

/// A byte count with an optional `K`, `M`, or `G` suffix (binary units).
/// `storage.cache` when unset: 2 GiB.
pub const DEFAULT_STORAGE_CACHE: u64 = 2 << 30;

pub fn parse_size(v: &str) -> Result<u64> {
    let v = v.trim();
    let (num, mult) = match v.chars().last() {
        Some('K' | 'k') => (&v[..v.len() - 1], 1u64 << 10),
        Some('M' | 'm') => (&v[..v.len() - 1], 1u64 << 20),
        Some('G' | 'g') => (&v[..v.len() - 1], 1u64 << 30),
        _ => (v, 1),
    };
    let n: u64 = num
        .trim()
        .parse()
        .map_err(|_| RepoError::Msg(format!("expected a size like 1M, got {v:?}")))?;
    Ok(n * mult)
}

/// A count of days, optionally suffixed `d`.
fn parse_days(v: &str) -> Result<u64> {
    v.trim_end_matches('d')
        .parse()
        .map_err(|_| RepoError::Msg(format!("expected a number of days, got {v:?}")))
}

/// Read `key = "value"` lines; a missing file is empty.
pub fn read_config_file(path: &Path) -> Result<BTreeMap<String, String>> {
    let text = match fs::read_to_string(path) {
        Ok(t) => t,
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(BTreeMap::new()),
        Err(e) => return Err(e.into()),
    };
    let mut out = BTreeMap::new();
    for line in text.lines() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        let Some((k, v)) = line.split_once('=') else {
            continue;
        };
        out.insert(k.trim().to_string(), v.trim().trim_matches('"').to_string());
    }
    Ok(out)
}

fn write_config_file(path: &Path, entries: &BTreeMap<String, String>) -> Result<()> {
    let text: String = entries
        .iter()
        .map(|(k, v)| format!("{k} = \"{v}\"\n"))
        .collect();
    write_atomic(path, text.as_bytes())
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Layered configuration: defaults, the user file, the repository file.
2
3		use super::*;
4
5		/// Effective settings: defaults, then the user file (`~/.config/oxy/config.toml`,
6		/// spec §19), then the repository file (`.oxy/config`). Both files are
7		/// `key = "value"` lines. `save` writes only the repository layer.
8		#[derive(Clone, Debug, PartialEq, Eq)]
9		pub struct Config {
10		/// Keys set in the repository file (or via `set`), written by `save`.
11		repo_layer: BTreeMap<String, String>,
12		pub author_name: String,
13		pub author_email: String,
14		/// The KeyId of the author's identity, once `create_identity` has run.
15		pub author_key: Option<KeyId>,
16		/// `author.signer` (or `$OXY_SIGNER`): the key that signs and seals in
17		/// place of `author.key`, whose identity lists it as a delegate. An
18		/// agent sets it to its own key, so its changes carry the human as
19		/// author and the agent's signature (spec §14.2, agent workflows §2).
20		pub signer_key: Option<KeyId>,
21		/// `core.sign`: sign every change at commit (`true`) or leave signing to
22		/// push-time seals (`false`, the spec default).
23		pub sign_changes: bool,
24		pub bookmark: String,
25		/// `remote.<name>.url`.
26		pub remotes: BTreeMap<String, String>,
27		/// `remote.<name>.token`: bearer token for HTTP pushes.
28		pub remote_tokens: BTreeMap<String, String>,
29		/// `remote.<name>.ca`: PEM file of extra roots to trust for that remote.
30		pub remote_cas: BTreeMap<String, String>,
31		/// `core.op-retention`: days for which operations keep their states reachable (spec §12.1, §21).
32		pub op_retention_days: u64,
33		/// `core.gc-grace`: days an unreachable object survives, protecting concurrent writers (spec §21).
34		pub gc_grace_days: u64,
35		/// `core.checkpoint-interval`: changes between automatic checkpoints (spec §11).
36		pub checkpoint_interval: u64,
37		/// `filter.max-blob`: blobs larger than this many bytes are fetched lazily (spec §17).
38		pub max_blob: Option<u64>,
39		/// `filter.paths`: only these subtrees are materialized (spec §17); empty means everything.
40		pub sparse_paths: Vec<String>,
41		/// `hooks.semantic-deps`: run the semantic-deps hook at commit (spec §20).
42		pub semantic_deps: bool,
43		/// `revset.<name>`: a saved revset, used as `name()`.
44		pub revsets: BTreeMap<String, String>,
45		/// `storage.url`: the store the repository's objects and operation
46		/// head are kept on (`dir://`, `s3://`, …) instead of `.oxy/objects`
47		/// (oxygen#68).
48		pub storage_url: Option<String>,
49		/// `storage.cache`: the most the local cache in front of that store
50		/// holds, in bytes.
51		pub storage_cache: u64,
52		}
53
54		impl Config {
55	2494×	pub(super) fn default_for_user() -> Config {
56	2494×	let user = std::env::var("USER").unwrap_or_else(\|_\| "unknown".into());
57		Config {
58	2494×	repo_layer: BTreeMap::new(),
59	2494×	author_name: std::env::var("OXY_AUTHOR_NAME").unwrap_or_else(\|_\| user.clone()),
60	2494×	author_email: std::env::var("OXY_AUTHOR_EMAIL")
61	2494×	.unwrap_or_else(\|_\| format!("{user}@localhost")),
62	2494×	author_key: None,
63	2494×	signer_key: std::env::var("OXY_SIGNER")
64	2494×	.ok()
65	2494×	.and_then(\|v\| KeyId::from_hex(&v)),
66		sign_changes: false,
67	2494×	bookmark: "main".into(),
68	2494×	remotes: BTreeMap::new(),
69	2494×	remote_tokens: BTreeMap::new(),
70	2494×	remote_cas: BTreeMap::new(),
71		op_retention_days: 90,
72		gc_grace_days: 14,
73		checkpoint_interval: 256,
74	2494×	max_blob: None,
75	2494×	sparse_paths: Vec::new(),
76		semantic_deps: false,
77	2494×	revsets: BTreeMap::new(),
78	2494×	storage_url: None,
79		storage_cache: DEFAULT_STORAGE_CACHE,
80		}
81	2494×	}
82
83		/// Set a key in the repository layer, as `oxy config` does.
84	428×	pub fn set(&mut self, key: &str, value: &str) -> Result<()> {
85	428×	self.apply(key, value)?;
86	428×	if value.is_empty() {
87	1×	self.repo_layer.remove(key);
88	427×	} else {
89	427×	self.repo_layer.insert(key.to_string(), value.to_string());
90	427×	}
91	428×	Ok(())
92	428×	}
93
94		/// Set a key in the user file without touching any repository.
95	91×	pub fn set_user(user_path: &Path, key: &str, value: &str) -> Result<()> {
96	91×	Config::default_for_user().apply(key, value)?;
97	90×	let mut entries = read_config_file(user_path)?;
98	90×	if value.is_empty() {
99	0×	entries.remove(key);
100	90×	} else {
101	90×	entries.insert(key.to_string(), value.to_string());
102	90×	}
103	90×	if let Some(parent) = user_path.parent() {
104	90×	fs::create_dir_all(parent)?;
105	0×	}
106	90×	write_config_file(user_path, &entries)
107	91×	}
108
109		/// Apply a key to the effective values.
110	1433×	pub(super) fn apply(&mut self, key: &str, value: &str) -> Result<()> {
111	3×	match key {
112	1433×	"author.name" => self.author_name = value.into(),
113	1189×	"author.email" => self.author_email = value.into(),
114	945×	"author.key" => {
115	245×	self.author_key = if value.is_empty() {
116	0×	None
117		} else {
118	245×	Some(KeyId::from_hex(value).ok_or_else(\|\| {
119	0×	RepoError::Msg("author.key must be a 64-character hex KeyId".into())
120	0×	})?)
121		}
122		}
123	700×	"author.signer" => {
124	3×	self.signer_key = if value.is_empty() {
125	0×	None
126		} else {
127	3×	Some(KeyId::from_hex(value).ok_or_else(\|\| {
128	0×	RepoError::Msg("author.signer must be a 64-character hex KeyId".into())
129	0×	})?)
130		}
131		}
132	697×	"core.sign" => {
133	83×	self.sign_changes = match value {
134	83×	"change" => true,
135	7×	"seal" => false,
136	0×	_ => return fail("core.sign must be \"change\" or \"seal\""),
137		}
138		}
139	614×	"workspace.bookmark" => self.bookmark = value.into(),
140		// Read by the credential store from the user file.
141	610×	"auth.helper" => {}
142	610×	"core.op-retention" => self.op_retention_days = parse_days(value)?,
143	598×	"core.gc-grace" => self.gc_grace_days = parse_days(value)?,
144	598×	"filter.max-blob" => {
145	5×	self.max_blob = if value.is_empty() {
146	0×	None
147		} else {
148	5×	Some(parse_size(value)?)
149		}
150		}
151	593×	"storage.url" => {
152	5×	self.storage_url = (!value.is_empty()).then(\|\| value.to_string());
153		}
154	588×	"storage.cache" => {
155	0×	self.storage_cache = if value.is_empty() {
156	0×	DEFAULT_STORAGE_CACHE
157		} else {
158	0×	parse_size(value)?
159		}
160		}
161	588×	"hooks.semantic-deps" => self.semantic_deps = matches!(value, "true" \| "1" \| "yes"),
162	587×	"filter.paths" => {
163	3×	self.sparse_paths = value
164	3×	.split(',')
165	4×	.map(\|p\| {
166	4×	p.trim()
167	4×	.trim_start_matches("./")
168	4×	.trim_matches('/')
169	4×	.to_string()
170	4×	})
171	4×	.filter(\|p\| !p.is_empty())
172	3×	.collect();
173		}
174	584×	"core.checkpoint-interval" => {
175	3×	self.checkpoint_interval = value
176	3×	.parse()
177	3×	.map_err(\|_\| RepoError::Msg(format!("expected a number, got {value:?}")))?;
178		}
179	581×	k if k.starts_with("remote.") => {
180	578×	let rest = &k["remote.".len()..];
181	578×	let Some((name, field)) = rest.rsplit_once('.') else {
182	0×	return fail(format!("unknown configuration key {key:?}"));
183		};
184	578×	if name.is_empty() \|\| name.contains('/') {
185	0×	return fail(format!("invalid remote name in {key:?}"));
186	578×	}
187	578×	let map = match field {
188	578×	"url" => &mut self.remotes,
189	10×	"token" => &mut self.remote_tokens,
190	4×	"ca" => &mut self.remote_cas,
191	0×	_ => return fail(format!("unknown configuration key {key:?}")),
192		};
193	578×	if value.is_empty() {
194	1×	map.remove(name);
195	1×	if field == "url" {
196	1×	self.remote_tokens.remove(name);
197	1×	self.remote_cas.remove(name);
198	1×	}
199	577×	} else {
200	577×	map.insert(name.to_string(), value.into());
201	577×	}
202		}
203	3×	k if k.starts_with("revset.") => {
204	3×	let name = &k["revset.".len()..];
205	3×	if name.is_empty()
206	3×	\|\| !name
207	3×	.chars()
208	11×	.all(\|c\| c.is_ascii_alphanumeric() \|\| c == '_' \|\| c == '-')
209		{
210	0×	return fail(format!(
211		"a revset's name is letters, digits, _ and -: {key:?}"
212		));
213	3×	}
214	3×	if value.is_empty() {
215	0×	self.revsets.remove(name);
216	0×	} else {
217	3×	crate::revset::parse(value)
218	3×	.map_err(\|e\| RepoError::Msg(format!("{key} = {value:?}: {e}")))?;
219	2×	self.revsets.insert(name.to_string(), value.into());
220		}
221		}
222	0×	_ => return fail(format!("unknown configuration key {key:?}")),
223		}
224	1432×	Ok(())
225	1433×	}
226
227		/// Defaults, then the user file if it exists, then the repository file.
228	2403×	pub(super) fn load(user_path: Option<&Path>, repo_path: &Path) -> Result<Config> {
229	2403×	let mut c = Config::default_for_user();
230	2403×	if let Some(u) = user_path {
231	2403×	for (k, v) in read_config_file(u)? {
232	294×	let _ = c.apply(&k, &v);
233	294×	}
234	0×	}
235	2403×	for (k, v) in read_config_file(repo_path)? {
236	620×	if c.apply(&k, &v).is_ok() {
237	620×	c.repo_layer.insert(k, v);
238	620×	}
239		}
240	2403×	Ok(c)
241	2403×	}
242
243	804×	pub(super) fn save(&self, path: &Path) -> Result<()> {
244	804×	write_config_file(path, &self.repo_layer)
245	804×	}
246
247		/// Keys explicitly set for this repository.
248	15×	pub fn repo_layer(&self) -> &BTreeMap<String, String> {
249	15×	&self.repo_layer
250	15×	}
251		}
252
253		/// A byte count with an optional `K`, `M`, or `G` suffix (binary units).
254		/// `storage.cache` when unset: 2 GiB.
255		pub const DEFAULT_STORAGE_CACHE: u64 = 2 << 30;
256
257	7×	pub fn parse_size(v: &str) -> Result<u64> {
258	7×	let v = v.trim();
259	7×	let (num, mult) = match v.chars().last() {
260	1×	Some('K' \| 'k') => (&v[..v.len() - 1], 1u64 << 10),
261	1×	Some('M' \| 'm') => (&v[..v.len() - 1], 1u64 << 20),
262	0×	Some('G' \| 'g') => (&v[..v.len() - 1], 1u64 << 30),
263	5×	_ => (v, 1),
264		};
265	7×	let n: u64 = num
266	7×	.trim()
267	7×	.parse()
268	7×	.map_err(\|_\| RepoError::Msg(format!("expected a size like 1M, got {v:?}")))?;
269	6×	Ok(n * mult)
270	7×	}
271
272		/// A count of days, optionally suffixed `d`.
273	12×	fn parse_days(v: &str) -> Result<u64> {
274	12×	v.trim_end_matches('d')
275	12×	.parse()
276	12×	.map_err(\|_\| RepoError::Msg(format!("expected a number of days, got {v:?}")))
277	12×	}
278
279		/// Read `key = "value"` lines; a missing file is empty.
280	5339×	pub fn read_config_file(path: &Path) -> Result<BTreeMap<String, String>> {
281	5339×	let text = match fs::read_to_string(path) {
282	2104×	Ok(t) => t,
283	3235×	Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(BTreeMap::new()),
284	0×	Err(e) => return Err(e.into()),
285		};
286	2104×	let mut out = BTreeMap::new();
287	2104×	for line in text.lines() {
288	1118×	let line = line.trim();
289	1118×	if line.is_empty() \|\| line.starts_with('#') {
290	0×	continue;
291	1118×	}
292	1118×	let Some((k, v)) = line.split_once('=') else {
293	0×	continue;
294		};
295	1118×	out.insert(k.trim().to_string(), v.trim().trim_matches('"').to_string());
296		}
297	2104×	Ok(out)
298	5339×	}
299
300	894×	fn write_config_file(path: &Path, entries: &BTreeMap<String, String>) -> Result<()> {
301	894×	let text: String = entries
302	894×	.iter()
303	894×	.map(\|(k, v)\| format!("{k} = \"{v}\"\n"))
304	894×	.collect();
305	894×	write_atomic(path, text.as_bytes())
306	894×	}

Coverage / crates/oxy-core/src/repo/config.rs 82.1%

Keyboard