abbr - manage fish abbreviations — fish-shell 3.6.0-275-gf2f7d1d18 documentation

diff -Nru fish-3.6.0-275-gf2f7d1d18/debian/changelog fish-3.6.0-280-gd839fea74/debian/changelog --- fish-3.6.0-275-gf2f7d1d18/debian/changelog 2023-03-04 23:36:48.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/debian/changelog 2023-03-05 07:06:39.000000000 +0000 @@ -1,8 +1,8 @@ -fish (3.6.0-275-gf2f7d1d18-1~xenial) xenial; urgency=medium +fish (3.6.0-280-gd839fea74-1~xenial) xenial; urgency=medium - * Snapshot build from f2f7d1d18 + * Snapshot build from d839fea74 - -- David Adam Sun, 05 Mar 2023 07:36:48 +0800 + -- David Adam Sun, 05 Mar 2023 15:06:39 +0800 fish (2.7.1-1) testing; urgency=medium diff -Nru fish-3.6.0-275-gf2f7d1d18/fish-rust/src/common.rs fish-3.6.0-280-gd839fea74/fish-rust/src/common.rs --- fish-3.6.0-275-gf2f7d1d18/fish-rust/src/common.rs 2023-03-04 23:05:11.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/fish-rust/src/common.rs 2023-03-05 06:54:17.000000000 +0000 @@ -2,6 +2,7 @@ use crate::wchar_ext::WExt; use crate::wchar_ffi::c_str; use crate::wchar_ffi::{wstr, WCharFromFFI, WString}; +use std::os::fd::AsRawFd; use std::{ffi::c_uint, mem}; /// A scoped manager to save the current value of some variable, and optionally set it to a new @@ -116,6 +117,47 @@ pub const fn assert_sync() {} +/// A rusty port of the C++ `write_loop()` function from `common.cpp`. This should be deprecated in +/// favor of native rust read/write methods at some point. +/// +/// Returns the number of bytes written or an IO error. +pub fn write_loop(fd: &Fd, buf: &[u8]) -> std::io::Result { + let fd = fd.as_raw_fd(); + let mut total = 0; + while total < buf.len() { + let written = + unsafe { libc::write(fd, buf[total..].as_ptr() as *const _, buf.len() - total) }; + if written < 0 { + let errno = errno::errno().0; + if matches!(errno, libc::EAGAIN | libc::EINTR) { + continue; + } + return Err(std::io::Error::from_raw_os_error(errno)); + } + total += written as usize; + } + Ok(total) +} + +/// A rusty port of the C++ `read_loop()` function from `common.cpp`. This should be deprecated in +/// favor of native rust read/write methods at some point. +/// +/// Returns the number of bytes read or an IO error. +pub fn read_loop(fd: &Fd, buf: &mut [u8]) -> std::io::Result { + let fd = fd.as_raw_fd(); + loop { + let read = unsafe { libc::read(fd, buf.as_mut_ptr() as *mut _, buf.len()) }; + if read < 0 { + let errno = errno::errno().0; + if matches!(errno, libc::EAGAIN | libc::EINTR) { + continue; + } + return Err(std::io::Error::from_raw_os_error(errno)); + } + return Ok(read as usize); + } +} + /// Asserts that a slice is alphabetically sorted by a [`&wstr`] `name` field. /// /// Mainly useful for static asserts/const eval. diff -Nru fish-3.6.0-275-gf2f7d1d18/fish-rust/src/fd_monitor.rs fish-3.6.0-280-gd839fea74/fish-rust/src/fd_monitor.rs --- fish-3.6.0-275-gf2f7d1d18/fish-rust/src/fd_monitor.rs 2023-03-04 23:05:11.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/fish-rust/src/fd_monitor.rs 2023-03-05 06:54:17.000000000 +0000 @@ -3,7 +3,8 @@ use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; -use self::fd_monitor_ffi::{new_fd_event_signaller, FdEventSignaller, ItemWakeReason}; +pub use self::fd_monitor_ffi::ItemWakeReason; +use self::fd_monitor_ffi::{new_fd_event_signaller, FdEventSignaller}; use crate::fd_readable_set::FdReadableSet; use crate::fds::AutoCloseFd; use crate::ffi::void_ptr; @@ -93,7 +94,20 @@ #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] pub struct FdMonitorItemId(u64); +impl From for u64 { + fn from(value: FdMonitorItemId) -> Self { + value.0 + } +} + +impl From for FdMonitorItemId { + fn from(value: u64) -> Self { + FdMonitorItemId(value) + } +} + type FfiCallback = extern "C" fn(*mut AutoCloseFd, u8, void_ptr); +type NativeCallback = Box; /// The callback type used by [`FdMonitorItem`]. It is passed a mutable reference to the /// `FdMonitorItem`'s [`FdMonitorItem::fd`] and [the reason](ItemWakeupReason) for the wakeup. The @@ -107,7 +121,7 @@ enum FdMonitorCallback { None, #[allow(clippy::type_complexity)] - Native(Box), + Native(NativeCallback), Ffi(FfiCallback /* fn ptr */, void_ptr /* param */), } @@ -139,6 +153,11 @@ } impl FdMonitorItem { + /// Returns the id for this `FdMonitorItem` that is registered with the [`FdMonitor`]. + pub fn id(&self) -> FdMonitorItemId { + self.item_id + } + /// Return the duration until the timeout should trigger or `None`. A return of `0` means we are /// at or past the timeout. fn remaining_time(&self, now: &Instant) -> Option { @@ -208,16 +227,27 @@ } } - fn new() -> Self { - Self { - callback: FdMonitorCallback::None, - fd: AutoCloseFd::empty(), - timeout: None, - last_time: None, + pub fn new( + fd: AutoCloseFd, + timeout: Option, + callback: Option, + ) -> Self { + FdMonitorItem { + fd, + timeout, + callback: match callback { + Some(callback) => FdMonitorCallback::Native(callback), + None => FdMonitorCallback::None, + }, item_id: FdMonitorItemId(0), + last_time: None, } } + pub fn set_callback(&mut self, callback: NativeCallback) { + self.callback = FdMonitorCallback::Native(callback); + } + fn set_callback_ffi(&mut self, callback: *const u8, param: *const u8) { // Safety: we are just marshalling our function pointers with identical definitions on both // sides of the ffi bridge as void pointers to keep cxx bridge happy. Whether we invoke the @@ -228,6 +258,18 @@ } } +impl Default for FdMonitorItem { + fn default() -> Self { + Self { + callback: FdMonitorCallback::None, + fd: AutoCloseFd::empty(), + timeout: None, + last_time: None, + item_id: FdMonitorItemId(0), + } + } +} + // cxx bridge does not support "static member functions" in C++ or rust, so we need a top-level fn. fn new_fd_monitor_ffi() -> Box { Box::new(FdMonitor::new()) @@ -245,7 +287,7 @@ // raw function as a void pointer or as a typed fn that helps us keep track of what we're // doing is unsafe in all cases, so might as well make the best of it. let callback = unsafe { std::mem::transmute(callback) }; - let mut item = FdMonitorItem::new(); + let mut item = FdMonitorItem::default(); item.fd.reset(fd); item.callback = FdMonitorCallback::Ffi(callback, param.into()); if timeout_usecs != FdReadableSet::kNoTimeout { @@ -360,7 +402,7 @@ // raw function as a void pointer or as a typed fn that helps us keep track of what we're // doing is unsafe in all cases, so might as well make the best of it. let callback = unsafe { std::mem::transmute(callback) }; - let mut item = FdMonitorItem::new(); + let mut item = FdMonitorItem::default(); item.fd.reset(fd); item.callback = FdMonitorCallback::Ffi(callback, param.into()); if timeout_usecs != FdReadableSet::kNoTimeout { diff -Nru fish-3.6.0-275-gf2f7d1d18/fish-rust/src/fds.rs fish-3.6.0-280-gd839fea74/fish-rust/src/fds.rs --- fish-3.6.0-275-gf2f7d1d18/fish-rust/src/fds.rs 2023-03-04 23:05:11.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/fish-rust/src/fds.rs 2023-03-05 06:54:17.000000000 +0000 @@ -1,5 +1,6 @@ use crate::ffi; use nix::unistd; +use std::io::{Read, Write}; use std::os::unix::io::{AsRawFd, FromRawFd, RawFd}; /// A helper type for managing and automatically closing a file descriptor @@ -11,6 +12,33 @@ fd_: RawFd, } +impl Read for AutoCloseFd { + fn read(&mut self, buf: &mut [u8]) -> std::io::Result { + unsafe { + match libc::read(self.as_raw_fd(), buf.as_mut_ptr() as *mut _, buf.len()) { + -1 => Err(std::io::Error::from_raw_os_error(errno::errno().0)), + bytes => Ok(bytes as usize), + } + } + } +} + +impl Write for AutoCloseFd { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + unsafe { + match libc::write(self.as_raw_fd(), buf.as_ptr() as *const _, buf.len()) { + -1 => Err(std::io::Error::from_raw_os_error(errno::errno().0)), + bytes => Ok(bytes as usize), + } + } + } + + fn flush(&mut self) -> std::io::Result<()> { + // We don't buffer anything so this is a no-op. + Ok(()) + } +} + #[cxx::bridge] mod autoclose_fd_t { extern "Rust" { diff -Nru fish-3.6.0-275-gf2f7d1d18/fish-rust/src/lib.rs fish-3.6.0-280-gd839fea74/fish-rust/src/lib.rs --- fish-3.6.0-275-gf2f7d1d18/fish-rust/src/lib.rs 2023-03-04 23:05:11.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/fish-rust/src/lib.rs 2023-03-05 06:54:17.000000000 +0000 @@ -3,6 +3,9 @@ #![allow(non_upper_case_globals)] #![allow(clippy::needless_return)] #![allow(clippy::manual_is_ascii_check)] +#![allow(clippy::bool_assert_comparison)] +#![allow(clippy::uninlined_format_args)] +#![allow(clippy::derivable_impls)] #[macro_use] mod common; @@ -41,3 +44,6 @@ mod builtins; mod env; mod re; + +// Don't use `#[cfg(test)]` here to make sure ffi tests are built and tested +mod tests; diff -Nru fish-3.6.0-275-gf2f7d1d18/fish-rust/src/tests/fd_monitor.rs fish-3.6.0-280-gd839fea74/fish-rust/src/tests/fd_monitor.rs --- fish-3.6.0-275-gf2f7d1d18/fish-rust/src/tests/fd_monitor.rs 1970-01-01 00:00:00.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/fish-rust/src/tests/fd_monitor.rs 2023-03-05 06:54:17.000000000 +0000 @@ -0,0 +1,190 @@ +use std::io::Write; +use std::os::fd::AsRawFd; +use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}; +use std::sync::{Arc, Mutex}; +use std::time::Duration; + +use crate::fd_monitor::{FdMonitor, FdMonitorItem, FdMonitorItemId, ItemWakeReason}; +use crate::fds::{make_autoclose_pipes, AutoCloseFd}; +use crate::ffi_tests::add_test; + +/// Helper to make an item which counts how many times its callback was invoked. +/// +/// This could be structured differently to avoid the `Mutex` on `writer`, but it's not worth it +/// since this is just used for test purposes. +struct ItemMaker { + pub did_timeout: AtomicBool, + pub length_read: AtomicUsize, + pub pokes: AtomicUsize, + pub total_calls: AtomicUsize, + item_id: AtomicU64, + pub always_exit: bool, + pub writer: Mutex, +} + +impl ItemMaker { + pub fn insert_new_into(monitor: &FdMonitor, timeout: Option) -> Arc { + Self::insert_new_into2(monitor, timeout, |_| {}) + } + + pub fn insert_new_into2( + monitor: &FdMonitor, + timeout: Option, + config: F, + ) -> Arc { + let pipes = make_autoclose_pipes().expect("fds exhausted!"); + let mut item = FdMonitorItem::new(pipes.read, timeout, None); + + let mut result = ItemMaker { + did_timeout: false.into(), + length_read: 0.into(), + pokes: 0.into(), + total_calls: 0.into(), + item_id: 0.into(), + always_exit: false, + writer: Mutex::new(pipes.write), + }; + + config(&mut result); + + let result = Arc::new(result); + let callback = { + let result = Arc::clone(&result); + move |fd: &mut AutoCloseFd, reason: ItemWakeReason| { + result.callback(fd, reason); + } + }; + item.set_callback(Box::new(callback)); + let item_id = monitor.add(item); + result.item_id.store(u64::from(item_id), Ordering::Relaxed); + + result + } + + fn item_id(&self) -> FdMonitorItemId { + self.item_id.load(Ordering::Relaxed).into() + } + + fn callback(&self, fd: &mut AutoCloseFd, reason: ItemWakeReason) { + let mut was_closed = false; + + match reason { + ItemWakeReason::Timeout => { + self.did_timeout.store(true, Ordering::Relaxed); + } + ItemWakeReason::Poke => { + self.pokes.fetch_add(1, Ordering::Relaxed); + } + ItemWakeReason::Readable => { + let mut buf = [0u8; 1024]; + let amt = + unsafe { libc::read(fd.as_raw_fd(), buf.as_mut_ptr() as *mut _, buf.len()) }; + assert_ne!(amt, -1, "read error!"); + self.length_read.fetch_add(amt as usize, Ordering::Relaxed); + was_closed = amt == 0; + } + _ => unreachable!(), + } + + self.total_calls.fetch_add(1, Ordering::Relaxed); + if self.always_exit || was_closed { + fd.close(); + } + } + + /// Write 42 bytes to our write end. + fn write42(&self) { + let buf = [0u8; 42]; + let mut writer = self.writer.lock().expect("Mutex poisoned!"); + writer + .write_all(&buf) + .expect("Error writing 42 bytes to pipe!"); + } +} + +add_test!("fd_monitor_items", || { + let monitor = FdMonitor::new(); + + // Items which will never receive data or be called. + let item_never = ItemMaker::insert_new_into(&monitor, None); + let item_huge_timeout = + ItemMaker::insert_new_into(&monitor, Some(Duration::from_millis(100_000_000))); + + // Item which should get no data and time out. + let item0_timeout = ItemMaker::insert_new_into(&monitor, Some(Duration::from_millis(16))); + + // Item which should get exactly 42 bytes then time out. + let item42_timeout = ItemMaker::insert_new_into(&monitor, Some(Duration::from_millis(16))); + + // Item which should get exactly 42 bytes and not time out. + let item42_no_timeout = ItemMaker::insert_new_into(&monitor, None); + + // Item which should get 42 bytes then get notified it is closed. + let item42_then_close = ItemMaker::insert_new_into(&monitor, Some(Duration::from_millis(16))); + + // Item which gets one poke. + let item_pokee = ItemMaker::insert_new_into(&monitor, None); + + // Item which should get a callback exactly once. + let item_oneshot = + ItemMaker::insert_new_into2(&monitor, Some(Duration::from_millis(16)), |item| { + item.always_exit = true; + }); + + item42_timeout.write42(); + item42_no_timeout.write42(); + item42_then_close.write42(); + item42_then_close + .writer + .lock() + .expect("Mutex poisoned!") + .close(); + item_oneshot.write42(); + + monitor.poke_item(item_pokee.item_id()); + + // May need to loop here to ensure our fd_monitor gets scheduled. See #7699. + for _ in 0..100 { + std::thread::sleep(Duration::from_millis(84)); + if item0_timeout.did_timeout.load(Ordering::Relaxed) { + break; + } + } + + drop(monitor); + + assert_eq!(item_never.did_timeout.load(Ordering::Relaxed), false); + assert_eq!(item_never.length_read.load(Ordering::Relaxed), 0); + assert_eq!(item_never.pokes.load(Ordering::Relaxed), 0); + + assert_eq!(item_huge_timeout.did_timeout.load(Ordering::Relaxed), false); + assert_eq!(item_huge_timeout.length_read.load(Ordering::Relaxed), 0); + assert_eq!(item_huge_timeout.pokes.load(Ordering::Relaxed), 0); + + assert_eq!(item0_timeout.length_read.load(Ordering::Relaxed), 0); + assert_eq!(item0_timeout.did_timeout.load(Ordering::Relaxed), true); + assert_eq!(item0_timeout.pokes.load(Ordering::Relaxed), 0); + + assert_eq!(item42_timeout.length_read.load(Ordering::Relaxed), 42); + assert_eq!(item42_timeout.did_timeout.load(Ordering::Relaxed), true); + assert_eq!(item42_timeout.pokes.load(Ordering::Relaxed), 0); + + assert_eq!(item42_no_timeout.length_read.load(Ordering::Relaxed), 42); + assert_eq!(item42_no_timeout.did_timeout.load(Ordering::Relaxed), false); + assert_eq!(item42_no_timeout.pokes.load(Ordering::Relaxed), 0); + + assert_eq!(item42_then_close.did_timeout.load(Ordering::Relaxed), false); + assert_eq!(item42_then_close.length_read.load(Ordering::Relaxed), 42); + assert_eq!(item42_then_close.total_calls.load(Ordering::Relaxed), 2); + assert_eq!(item42_then_close.pokes.load(Ordering::Relaxed), 0); + + assert_eq!(item_oneshot.did_timeout.load(Ordering::Relaxed), false); + assert_eq!(item_oneshot.length_read.load(Ordering::Relaxed), 42); + assert_eq!(item_oneshot.total_calls.load(Ordering::Relaxed), 1); + assert_eq!(item_oneshot.pokes.load(Ordering::Relaxed), 0); + + assert_eq!(item_pokee.did_timeout.load(Ordering::Relaxed), false); + assert_eq!(item_pokee.length_read.load(Ordering::Relaxed), 0); + assert_eq!(item_pokee.total_calls.load(Ordering::Relaxed), 1); + assert_eq!(item_pokee.pokes.load(Ordering::Relaxed), 1); +}); diff -Nru fish-3.6.0-275-gf2f7d1d18/fish-rust/src/tests/mod.rs fish-3.6.0-280-gd839fea74/fish-rust/src/tests/mod.rs --- fish-3.6.0-275-gf2f7d1d18/fish-rust/src/tests/mod.rs 1970-01-01 00:00:00.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/fish-rust/src/tests/mod.rs 2023-03-05 06:54:17.000000000 +0000 @@ -0,0 +1 @@ +mod fd_monitor; diff -Nru fish-3.6.0-275-gf2f7d1d18/src/fish_tests.cpp fish-3.6.0-280-gd839fea74/src/fish_tests.cpp --- fish-3.6.0-275-gf2f7d1d18/src/fish_tests.cpp 2023-03-04 23:05:11.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/src/fish_tests.cpp 2023-03-05 06:54:17.000000000 +0000 @@ -800,146 +800,6 @@ err(L"redirection_type_for_string failed on line %ld", (long)__LINE__); } -static void test_fd_monitor() { - say(L"Testing fd_monitor"); - - // Helper to make an item which counts how many times its callback is invoked. - struct item_maker_t : public noncopyable_t { - std::atomic did_timeout{false}; - std::atomic length_read{0}; - std::atomic pokes{0}; - std::atomic total_calls{0}; - uint64_t item_id{0}; - bool always_exit{false}; - std::unique_ptr> item; - autoclose_fd_t writer; - - void callback(autoclose_fd_t2 &fd, item_wake_reason_t reason) { - bool was_closed = false; - switch (reason) { - case item_wake_reason_t::Timeout: - this->did_timeout = true; - break; - case item_wake_reason_t::Poke: - this->pokes += 1; - break; - case item_wake_reason_t::Readable: - char buff[4096]; - ssize_t amt = read(fd.fd(), buff, sizeof buff); - this->length_read += amt; - was_closed = (amt == 0); - break; - } - total_calls += 1; - if (always_exit || was_closed) { - fd.close(); - } - } - - static void trampoline(autoclose_fd_t2 &fd, item_wake_reason_t reason, uint8_t *param) { - auto &instance = *(item_maker_t *)(param); - instance.callback(fd, reason); - } - - explicit item_maker_t(uint64_t timeout_usec) { - auto pipes = make_autoclose_pipes().acquire(); - writer = std::move(pipes.write); - item = std::make_unique>( - make_fd_monitor_item_t(pipes.read.acquire(), timeout_usec, - (uint8_t *)item_maker_t::trampoline, (uint8_t *)this)); - } - - // Write 42 bytes to our write end. - void write42() const { - char buff[42] = {0}; - (void)write_loop(writer.fd(), buff, sizeof buff); - } - }; - - constexpr uint64_t usec_per_msec = 1000; - - // Items which will never receive data or be called back. - item_maker_t item_never(kNoTimeout); - item_maker_t item_hugetimeout(100000000LLU * usec_per_msec); - - // Item which should get no data, and time out. - item_maker_t item0_timeout(16 * usec_per_msec); - - // Item which should get exactly 42 bytes, then time out. - item_maker_t item42_timeout(16 * usec_per_msec); - - // Item which should get exactly 42 bytes, and not time out. - item_maker_t item42_nottimeout(kNoTimeout); - - // Item which should get 42 bytes, then get notified it is closed. - item_maker_t item42_thenclose(16 * usec_per_msec); - - // Item which gets one poke. - item_maker_t item_pokee(kNoTimeout); - - // Item which should be called back once. - item_maker_t item_oneshot(16 * usec_per_msec); - item_oneshot.always_exit = true; - - { - auto monitor = make_fd_monitor_t(); - for (item_maker_t *item : - {&item_never, &item_hugetimeout, &item0_timeout, &item42_timeout, &item42_nottimeout, - &item42_thenclose, &item_pokee, &item_oneshot}) { - item->item_id = monitor->add(std::move(*(std::move(item->item)))); - } - item42_timeout.write42(); - item42_nottimeout.write42(); - item42_thenclose.write42(); - item42_thenclose.writer.close(); - item_oneshot.write42(); - monitor->poke_item(item_pokee.item_id); - - // May need to loop here to ensure our fd_monitor gets scheduled - see #7699. - for (int i = 0; i < 100; i++) { - std::this_thread::sleep_for(std::chrono::milliseconds(84)); - if (item0_timeout.did_timeout) { - break; - } - } - } - - do_test(!item_never.did_timeout); - do_test(item_never.length_read == 0); - do_test(item_never.pokes == 0); - - do_test(!item_hugetimeout.did_timeout); - do_test(item_hugetimeout.length_read == 0); - do_test(item_hugetimeout.pokes == 0); - - do_test(item0_timeout.length_read == 0); - do_test(item0_timeout.did_timeout); - do_test(item0_timeout.pokes == 0); - - do_test(item42_timeout.length_read == 42); - do_test(item42_timeout.did_timeout); - do_test(item42_timeout.pokes == 0); - - do_test(item42_nottimeout.length_read == 42); - do_test(!item42_nottimeout.did_timeout); - do_test(item42_nottimeout.pokes == 0); - - do_test(item42_thenclose.did_timeout == false); - do_test(item42_thenclose.length_read == 42); - do_test(item42_thenclose.total_calls == 2); - do_test(item42_thenclose.pokes == 0); - - do_test(!item_oneshot.did_timeout); - do_test(item_oneshot.length_read == 42); - do_test(item_oneshot.total_calls == 1); - do_test(item_oneshot.pokes == 0); - - do_test(!item_pokee.did_timeout); - do_test(item_pokee.length_read == 0); - do_test(item_pokee.total_calls == 1); - do_test(item_pokee.pokes == 1); -} - static void test_iothread() { say(L"Testing iothreads"); std::atomic shared_int{0}; @@ -7054,7 +6914,6 @@ {TEST_GROUP("perf_convert_ascii"), perf_convert_ascii, true}, {TEST_GROUP("convert_nulls"), test_convert_nulls}, {TEST_GROUP("tokenizer"), test_tokenizer}, - {TEST_GROUP("fd_monitor"), test_fd_monitor}, {TEST_GROUP("iothread"), test_iothread}, {TEST_GROUP("pthread"), test_pthread}, {TEST_GROUP("debounce"), test_debounce}, diff -Nru fish-3.6.0-275-gf2f7d1d18/user_doc/html/.buildinfo fish-3.6.0-280-gd839fea74/user_doc/html/.buildinfo --- fish-3.6.0-275-gf2f7d1d18/user_doc/html/.buildinfo 2023-03-04 23:36:33.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/user_doc/html/.buildinfo 2023-03-05 07:06:23.000000000 +0000 @@ -1,4 +1,4 @@ # Sphinx build info version 1 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. -config: 34c693f46eac0eda318074e8b15b0f59 +config: 49bf9a480aee13b964776bd91b600cad tags: 645f666f9bcd5a90fca523b33c5a78b7 diff -Nru fish-3.6.0-275-gf2f7d1d18/user_doc/html/cmds/abbr.html fish-3.6.0-280-gd839fea74/user_doc/html/cmds/abbr.html --- fish-3.6.0-275-gf2f7d1d18/user_doc/html/cmds/abbr.html 2023-03-04 23:36:33.000000000 +0000 +++ fish-3.6.0-280-gd839fea74/user_doc/html/cmds/abbr.html 2023-03-05 07:06:23.000000000 +0000 @@ -6,7 +6,7 @@ - abbr - manage fish abbreviations — fish-shell 3.6.0-275-gf2f7d1d18 documentation + abbr - manage fish abbreviations — fish-shell 3.6.0-280-gd839fea74 documentation @@ -28,7 +28,7 @@ style="width: 80px; height: 80px; vertical-align: middle; margin-top: -1px"/>