From c32d7a79a2f1d1d09246289033825ea64520c915 Mon Sep 17 00:00:00 2001 From: Yuri Astrakhan Date: Tue, 16 Jul 2024 15:59:45 -0400 Subject: [PATCH] Applied some spellchecker suggestions --- Cargo.toml | 16 ++++++++-------- libsqlite3-sys/build.rs | 2 +- libsqlite3-sys/src/error.rs | 2 +- src/auto_extension.rs | 2 +- src/blob/mod.rs | 4 ++-- src/blob/pos_io.rs | 2 +- src/error.rs | 2 +- src/functions.rs | 6 +++--- src/inner_connection.rs | 2 +- src/lib.rs | 10 +++++----- src/params.rs | 8 ++++---- src/row.rs | 6 +++--- src/statement.rs | 6 +++--- src/transaction.rs | 6 +++--- src/types/value_ref.rs | 10 +++++----- src/util/sqlite_string.rs | 2 +- src/vtab/mod.rs | 2 +- 17 files changed, 44 insertions(+), 44 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 35d9016..a427232 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,12 +13,12 @@ license = "MIT" categories = ["database"] exclude = [ - "/.github/*", - "/.gitattributes", - "/appveyor.yml", - "/Changelog.md", - "/clippy.toml", - "/codecov.yml", + "/.github/*", + "/.gitattributes", + "/appveyor.yml", + "/Changelog.md", + "/clippy.toml", + "/codecov.yml", ] [badges] @@ -133,8 +133,8 @@ lazy_static = "1.4" regex = "1.5.5" uuid = { version = "1.0", features = ["v4"] } unicase = "2.6.0" -# Use `bencher` over criterion because it builds much faster and we don't have -# many benchmarks +# Use `bencher` over criterion because it builds much faster, +# and we don't have many benchmarks bencher = "0.1" [dependencies.libsqlite3-sys] diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 260a91f..96cf4c7 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -169,7 +169,7 @@ mod build_bundled { Some(openssl_dir) => { let lib_dir = lib_dir.map(|d| vec![d]).unwrap_or_else(|| { let mut lib_dirs = vec![]; - // OpenSSL 3.0 now puts it's libraries in lib64/ by default, + // OpenSSL 3.0 now puts its libraries in lib64/ by default, // check for both it and lib/. if openssl_dir.join("lib64").exists() { lib_dirs.push(openssl_dir.join("lib64")); diff --git a/libsqlite3-sys/src/error.rs b/libsqlite3-sys/src/error.rs index 9583d23..a7c8099 100644 --- a/libsqlite3-sys/src/error.rs +++ b/libsqlite3-sys/src/error.rs @@ -118,7 +118,7 @@ impl error::Error for Error { // Result codes. // Note: These are not public because our bindgen bindings export whichever -// constants are present in the current version of SQLite. We repeat them here +// constants are present in the current version of SQLite. We repeat them here, // so we don't have to worry about which version of SQLite added which // constants, and we only use them to implement code_to_str below. diff --git a/src/auto_extension.rs b/src/auto_extension.rs index 62f54aa..ec904a1 100644 --- a/src/auto_extension.rs +++ b/src/auto_extension.rs @@ -1,4 +1,4 @@ -//! Automatic axtension loading +//! Automatic extension loading use super::ffi; use crate::error::{check, to_sqlite_error}; use crate::{Connection, Error, Result}; diff --git a/src/blob/mod.rs b/src/blob/mod.rs index cf4e24e..cdd58fb 100644 --- a/src/blob/mod.rs +++ b/src/blob/mod.rs @@ -50,7 +50,7 @@ //! Using `MaybeUninit` here can be more efficient in some cases, but is //! often inconvenient, so both are provided. //! -//! 2. Exact/inexact refers to to whether or not the entire buffer must be +//! 2. Exact/inexact refers to whether or not the entire buffer must be //! filled in order for the call to be considered a success. //! //! The "exact" functions require the provided buffer be entirely filled, or @@ -287,7 +287,7 @@ impl Blob<'_> { /// Close a BLOB handle. /// /// Calling `close` explicitly is not required (the BLOB will be closed - /// when the `Blob` is dropped), but it is available so you can get any + /// when the `Blob` is dropped), but it is available, so you can get any /// errors that occur. /// /// # Failure diff --git a/src/blob/pos_io.rs b/src/blob/pos_io.rs index 96f728e..0698fab 100644 --- a/src/blob/pos_io.rs +++ b/src/blob/pos_io.rs @@ -116,7 +116,7 @@ impl<'conn> Blob<'conn> { if read_len == 0 { // We could return `Ok(&mut [])`, but it seems confusing that the - // pointers don't match, so fabricate a empty slice of u8 with the + // pointers don't match, so fabricate an empty slice of u8 with the // same base pointer as `buf`. let empty = unsafe { from_raw_parts_mut(buf.as_mut_ptr().cast::(), 0) }; return Ok(empty); diff --git a/src/error.rs b/src/error.rs index 2946382..ed43298 100644 --- a/src/error.rs +++ b/src/error.rs @@ -101,7 +101,7 @@ pub enum Error { #[allow(dead_code)] ModuleError(String), - /// An unwinding panic occurs in an UDF (user-defined function). + /// An unwinding panic occurs in a UDF (user-defined function). UnwindingPanic, /// An error returned when diff --git a/src/functions.rs b/src/functions.rs index 4e81f33..4252c7a 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -267,7 +267,7 @@ pub type SubType = Option; /// Result of an SQL function pub trait SqlFnOutput { - /// Converts Rust value to SQLite value with an optional sub-type + /// Converts Rust value to SQLite value with an optional subtype fn to_sql(&self) -> Result<(ToSqlOutput<'_>, SubType)>; } @@ -381,11 +381,11 @@ bitflags::bitflags! { const SQLITE_DETERMINISTIC = ffi::SQLITE_DETERMINISTIC; // 3.8.3 /// Means that the function may only be invoked from top-level SQL. const SQLITE_DIRECTONLY = 0x0000_0008_0000; // 3.30.0 - /// Indicates to SQLite that a function may call `sqlite3_value_subtype()` to inspect the sub-types of its arguments. + /// Indicates to SQLite that a function may call `sqlite3_value_subtype()` to inspect the subtypes of its arguments. const SQLITE_SUBTYPE = 0x0000_0010_0000; // 3.30.0 /// Means that the function is unlikely to cause problems even if misused. const SQLITE_INNOCUOUS = 0x0000_0020_0000; // 3.31.0 - /// Indicates to SQLite that a function might call `sqlite3_result_subtype()` to cause a sub-type to be associated with its result. + /// Indicates to SQLite that a function might call `sqlite3_result_subtype()` to cause a subtype to be associated with its result. const SQLITE_RESULT_SUBTYPE = 0x0000_0100_0000; // 3.45.0 } } diff --git a/src/inner_connection.rs b/src/inner_connection.rs index 282eb5e..6c4e6c0 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -20,7 +20,7 @@ pub struct InnerConnection { // a `sqlite3_interrupt`, and vice versa, so we take this mutex during // those functions. This protects a copy of the `db` pointer (which is // cleared on closing), however the main copy, `db`, is unprotected. - // Otherwise, a long running query would prevent calling interrupt, as + // Otherwise, a long-running query would prevent calling interrupt, as // interrupt would only acquire the lock after the query's completion. interrupt_lock: Arc>, #[cfg(feature = "hooks")] diff --git a/src/lib.rs b/src/lib.rs index 0f7eb16..cf59d1c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -954,7 +954,7 @@ impl Connection { /// Helper to register an SQLite extension written in Rust. /// For [persistent](https://sqlite.org/loadext.html#persistent_loadable_extensions) extension, - /// `init` should returns `Ok(true)`. + /// `init` should return `Ok(true)`. /// # Safety /// * Results are undefined if `init` does not just register features. #[cfg(feature = "loadable_extension")] @@ -1000,7 +1000,7 @@ impl Connection { }) } - /// Get access to a handle that can be used to interrupt long running + /// Get access to a handle that can be used to interrupt long-running /// queries from another thread. #[inline] pub fn get_interrupt_handle(&self) -> InterruptHandle { @@ -1074,7 +1074,7 @@ impl Connection { } } - /// Determine whether or not an interrupt is currently in effect + /// Determine whether an interrupt is currently in effect #[cfg(feature = "modern_sqlite")] // 3.41.0 #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))] pub fn is_interrupted(&self) -> bool { @@ -1165,7 +1165,7 @@ bitflags::bitflags! { /// If the database does not already exist, an error is returned. const SQLITE_OPEN_READ_ONLY = ffi::SQLITE_OPEN_READONLY; /// The database is opened for reading and writing if possible, - /// or reading only if the file is write protected by the operating system. + /// or reading only if the file is write-protected by the operating system. /// In either case the database must already exist, otherwise an error is returned. const SQLITE_OPEN_READ_WRITE = ffi::SQLITE_OPEN_READWRITE; /// The database is created if it does not already exist @@ -1870,7 +1870,7 @@ mod test { db.close().unwrap(); handle.interrupt(); - // Look at it's internals to see if we cleared it out properly. + // Look at its internals to see if we cleared it out properly. let db_guard = handle.db_lock.lock().unwrap(); assert!(db_guard.is_null()); // It would be nice to test that we properly handle close/interrupt diff --git a/src/params.rs b/src/params.rs index 6532f09..7b582de 100644 --- a/src/params.rs +++ b/src/params.rs @@ -53,7 +53,7 @@ use sealed::Sealed; /// /// (Note: in this case we don't implement this for slices for coherence /// reasons, so it really is only for the "reference to array" types — -/// hence why the number of parameters must be <= 32 or you need to +/// hence why the number of parameters must be <= 32, or you need to /// reach for `rusqlite::params!`) /// /// Unfortunately, in the current design it's not possible to allow this for @@ -108,7 +108,7 @@ use sealed::Sealed; /// parameters, or lists where the number of parameters exceeds 32. /// /// - As a slice of `&[(&str, &dyn ToSql)]`. This is what essentially all of -/// these boil down to in the end, conceptually at least. In theory you can +/// these boil down to in the end, conceptually at least. In theory, you can /// pass this as `stmt`. /// /// - As array references, similar to the positional params. This looks like @@ -264,7 +264,7 @@ macro_rules! single_tuple_impl { } } -// We use a the macro for the rest, but don't bother with trying to implement it +// We use a macro for the rest, but don't bother with trying to implement it // in a single invocation (it's possible to do, but my attempts were almost the // same amount of code as just writing it out this way, and much more dense -- // it is a more complicated case than the TryFrom macro we have for row->tuple). @@ -407,7 +407,7 @@ impl_for_array_ref!( /// production-ready: /// /// - production code should ensure `usernames` isn't so large that it will -/// surpass [`conn.limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER)`][limits]), +/// surpass [`conn.limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER)`][limits], /// chunking if too large. (Note that the limits api requires rusqlite to have /// the "limits" feature). /// diff --git a/src/row.rs b/src/row.rs index f2f6b1d..cba12eb 100644 --- a/src/row.rs +++ b/src/row.rs @@ -5,7 +5,7 @@ use std::convert; use super::{Error, Result, Statement}; use crate::types::{FromSql, FromSqlError, ValueRef}; -/// An handle for the resulting rows of a query. +/// A handle for the resulting rows of a query. #[must_use = "Rows is lazy and will do nothing unless consumed"] pub struct Rows<'stmt> { pub(crate) stmt: Option<&'stmt Statement<'stmt>>, @@ -305,7 +305,7 @@ impl<'stmt> Row<'stmt> { /// allowing data to be read out of a row without copying. /// /// This `ValueRef` is valid only as long as this Row, which is enforced by - /// it's lifetime. This means that while this method is completely safe, + /// its lifetime. This means that while this method is completely safe, /// it can be somewhat difficult to use, and most callers will be better /// served by [`get`](Row::get) or [`get_unwrap`](Row::get_unwrap). /// @@ -329,7 +329,7 @@ impl<'stmt> Row<'stmt> { /// allowing data to be read out of a row without copying. /// /// This `ValueRef` is valid only as long as this Row, which is enforced by - /// it's lifetime. This means that while this method is completely safe, + /// its lifetime. This means that while this method is completely safe, /// it can be difficult to use, and most callers will be better served by /// [`get`](Row::get) or [`get_unwrap`](Row::get_unwrap). /// diff --git a/src/statement.rs b/src/statement.rs index 84b7e26..add9253 100644 --- a/src/statement.rs +++ b/src/statement.rs @@ -561,7 +561,7 @@ impl Statement<'_> { /// /// Any unbound parameters will have `NULL` as their value. /// - /// This should not generally be used outside of special cases, and + /// This should not generally be used outside special cases, and /// functions in the [`Statement::execute`] family should be preferred. /// /// # Failure @@ -580,7 +580,7 @@ impl Statement<'_> { /// /// Any unbound parameters will have `NULL` as their value. /// - /// This should not generally be used outside of special cases, and + /// This should not generally be used outside special cases, and /// functions in the [`Statement::query`] family should be preferred. /// /// Note that if the SQL does not return results, [`Statement::raw_execute`] @@ -1019,7 +1019,7 @@ mod test { let doubled_id: i32 = rows.next().unwrap()?; assert_eq!(1, doubled_id); - // second row should be Err + // second row should be an `Err` #[allow(clippy::match_wild_err_arm)] match rows.next().unwrap() { Ok(_) => panic!("invalid Ok"), diff --git a/src/transaction.rs b/src/transaction.rs index 218d026..a8c8882 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -100,7 +100,7 @@ impl Transaction<'_> { /// transactions. /// /// Even though we don't mutate the connection, we take a `&mut Connection` - /// so as to prevent nested transactions on the same connection. For cases + /// to prevent nested transactions on the same connection. For cases /// where this is unacceptable, [`Transaction::new_unchecked`] is available. #[inline] pub fn new(conn: &mut Connection, behavior: TransactionBehavior) -> Result> { @@ -624,12 +624,12 @@ mod test { let mut sp1 = tx.savepoint()?; sp1.execute_batch("INSERT INTO foo VALUES(2)")?; assert_current_sum(3, &sp1)?; - // will rollback sp1 + // will roll back sp1 { let mut sp2 = sp1.savepoint()?; sp2.execute_batch("INSERT INTO foo VALUES(4)")?; assert_current_sum(7, &sp2)?; - // will rollback sp2 + // will roll back sp2 { let sp3 = sp2.savepoint()?; sp3.execute_batch("INSERT INTO foo VALUES(8)")?; diff --git a/src/types/value_ref.rs b/src/types/value_ref.rs index 64cb6c9..b418e80 100644 --- a/src/types/value_ref.rs +++ b/src/types/value_ref.rs @@ -1,7 +1,7 @@ use super::{Type, Value}; use crate::types::{FromSqlError, FromSqlResult}; -/// A non-owning [dynamic type value](http://sqlite.org/datatype3.html). Typically the +/// A non-owning [dynamic type value](http://sqlite.org/datatype3.html). Typically, the /// memory backing this value is owned by SQLite. /// /// See [`Value`](Value) for an owning dynamic type value. @@ -47,7 +47,7 @@ impl<'a> ValueRef<'a> { /// If `self` is case `Null` returns None. /// If `self` is case `Integer`, returns the integral value. - /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). + /// Otherwise, returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). #[inline] pub fn as_i64_or_null(&self) -> FromSqlResult> { match *self { @@ -69,7 +69,7 @@ impl<'a> ValueRef<'a> { /// If `self` is case `Null` returns None. /// If `self` is case `Real`, returns the floating point value. - /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). + /// Otherwise, returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). #[inline] pub fn as_f64_or_null(&self) -> FromSqlResult> { match *self { @@ -93,7 +93,7 @@ impl<'a> ValueRef<'a> { /// If `self` is case `Null` returns None. /// If `self` is case `Text`, returns the string value. - /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). + /// Otherwise, returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). #[inline] pub fn as_str_or_null(&self) -> FromSqlResult> { match *self { @@ -117,7 +117,7 @@ impl<'a> ValueRef<'a> { /// If `self` is case `Null` returns None. /// If `self` is case `Blob`, returns the byte slice. - /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). + /// Otherwise, returns [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType). #[inline] pub fn as_blob_or_null(&self) -> FromSqlResult> { match *self { diff --git a/src/util/sqlite_string.rs b/src/util/sqlite_string.rs index 1d69552..661826c 100644 --- a/src/util/sqlite_string.rs +++ b/src/util/sqlite_string.rs @@ -103,7 +103,7 @@ impl SqliteMallocString { /// fails, we call `handle_alloc_error` which aborts the program after /// calling a global hook. /// - /// This means it's safe to use in extern "C" functions even outside of + /// This means it's safe to use in extern "C" functions even outside /// `catch_unwind`. pub(crate) fn from_str(s: &str) -> Self { let s = if s.as_bytes().contains(&0) { diff --git a/src/vtab/mod.rs b/src/vtab/mod.rs index 4124296..1379bf2 100644 --- a/src/vtab/mod.rs +++ b/src/vtab/mod.rs @@ -137,7 +137,7 @@ macro_rules! module { }; } -/// Create an modifiable virtual table implementation. +/// Create a modifiable virtual table implementation. /// /// Step 2 of [Creating New Virtual Table Implementations](https://sqlite.org/vtab.html#creating_new_virtual_table_implementations). #[must_use]