diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 32e9eea3025..3576d66ac59 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -177,7 +177,7 @@ jobs: name: run callgrind benchmarks # DON'T run on benchmarks-runner, using docker on a self-hosted runner has # been broken for 4 years: https://github.com/actions/runner/issues/434 . - # Fortunately, we can run on standard Github Actions infra because we don't care + # Fortunately, we can run on standard GitHub Actions infra because we don't care # about other stuff running on the machine! # runs-on: benchmarks-runner runs-on: ubuntu-latest @@ -236,7 +236,7 @@ jobs: # summary PR" step). otherwise, we can use a fully shallow checkout fetch-depth: ${{ env.PR_NUMBER && 1 || 2 }} - - name: Unbork Github Actions state + - name: Unbork GitHub Actions state shell: bash run: | echo "Letting anybody touch our git repo, in order to avoid breaking other jobs" diff --git a/README.md b/README.md index fbe344c93d3..e9b9d75e71e 100644 --- a/README.md +++ b/README.md @@ -50,7 +50,7 @@   Twitter   - Github + GitHub   Twitch   diff --git a/crates/bench/README.md b/crates/bench/README.md index f011bd70178..292793535bb 100644 --- a/crates/bench/README.md +++ b/crates/bench/README.md @@ -28,7 +28,7 @@ Which will build the docker image and run the callgrind benchmarks inside of it. You can also comment "benchmarks please" or "callgrind please" on a pull request in the SpacetimeDB repository to run the criterion/callgrind benchmarks on that PR. The results will be posted in a comment on the PR. -This is coordinated using the benchmarks Github Actions: see [`../../.github/workflows/benchmarks.yml`](../../.github/workflows/benchmarks.yml), and +This is coordinated using the benchmarks GitHub Actions: see [`../../.github/workflows/benchmarks.yml`](../../.github/workflows/benchmarks.yml), and [`../../.github/workflows/callgrind_benchmarks.yml`](../../.github/workflows/callgrind_benchmarks.yml). These also rely on the benchmarks-viewer application (https://github.com/clockworklabs/benchmarks-viewer). diff --git a/crates/bindings-csharp/BSATN.Codegen/Utils.cs b/crates/bindings-csharp/BSATN.Codegen/Utils.cs index 9097640c04f..71c1c5aea83 100644 --- a/crates/bindings-csharp/BSATN.Codegen/Utils.cs +++ b/crates/bindings-csharp/BSATN.Codegen/Utils.cs @@ -318,7 +318,7 @@ public override string ToString() .AppendLine(" {"); } - // Loop through the full parent type hiearchy, starting with the outermost. + // Loop through the full parent type hierarchy, starting with the outermost. foreach ( var (i, typeScope) in Scope.typeScopes.Select((ts, i) => (i, ts)).Reverse() ) diff --git a/crates/bindings-csharp/Runtime/bindings.c b/crates/bindings-csharp/Runtime/bindings.c index fc839d7b746..ed59d5435b3 100644 --- a/crates/bindings-csharp/Runtime/bindings.c +++ b/crates/bindings-csharp/Runtime/bindings.c @@ -165,7 +165,7 @@ EXPORT(int16_t, __call_reducer__, #define WASI_NAME(name) __imported_wasi_snapshot_preview1_##name -// Shim for WASI calls that always unconditionaly succeeds. +// Shim for WASI calls that always unconditionally succeeds. // This is suitable for most (but not all) WASI functions used by .NET. #define WASI_SHIM(name, params) \ int32_t WASI_NAME(name) params { return 0; } diff --git a/crates/bindings-sys/src/lib.rs b/crates/bindings-sys/src/lib.rs index 2ff32345211..a9cc8c968e5 100644 --- a/crates/bindings-sys/src/lib.rs +++ b/crates/bindings-sys/src/lib.rs @@ -519,7 +519,7 @@ pub mod raw { /// ``` pub fn bytes_source_read(source: BytesSource, buffer_ptr: *mut u8, buffer_len_ptr: *mut usize) -> i16; - /// Logs at `level` a `message` message occuring in `filename:line_number` + /// Logs at `level` a `message` message occurring in `filename:line_number` /// with `target` being the module path at the `log!` invocation site. /// /// These various pointers are interpreted lossily as UTF-8 strings with a corresponding `_len`. @@ -1039,7 +1039,7 @@ pub enum LogLevel { Panic = raw::LOG_LEVEL_PANIC, } -/// Log at `level` a `text` message occuring in `filename:line_number` +/// Log at `level` a `text` message occurring in `filename:line_number` /// with [`target`] being the module path at the `log!` invocation site. /// /// [`target`]: https://docs.rs/log/latest/log/struct.Record.html#method.target diff --git a/crates/bindings/README.md b/crates/bindings/README.md index e27878ec747..1e73873b65f 100644 --- a/crates/bindings/README.md +++ b/crates/bindings/README.md @@ -561,7 +561,7 @@ The following changes are allowed, but may break clients: - ⚠️ **Changing or removing reducers**. Clients that attempt to call the old version of a changed reducer will receive runtime errors. - ⚠️ **Changing tables from public to private**. Clients that are subscribed to a newly-private table will receive runtime errors. - ⚠️ **Removing `#[primary_key]` annotations**. Non-updated clients will still use the old `#[primary_key]` as a unique key in their local cache, which can result in non-deterministic behavior when updates are received. -- ⚠️ **Removing indexes**. This is only breaking in some situtations. +- ⚠️ **Removing indexes**. This is only breaking in some situations. The specific problem is subscription queries involving semijoins, such as: ```sql SELECT Employee.* diff --git a/crates/bindings/src/lib.rs b/crates/bindings/src/lib.rs index aae00e141a7..7729985acb1 100644 --- a/crates/bindings/src/lib.rs +++ b/crates/bindings/src/lib.rs @@ -201,7 +201,7 @@ pub use spacetimedb_bindings_macro::client_visibility_filter; /// Tables are private by default. This means that clients cannot read their contents /// or see that they exist. /// -/// If you'd like to make your table publically accessible by clients, +/// If you'd like to make your table publicly accessible by clients, /// put `public` in the macro arguments (e.g. /// `#[spacetimedb::table(public)]`). You can also specify `private` if /// you'd like to be specific. diff --git a/crates/bindings/src/rng.rs b/crates/bindings/src/rng.rs index a9250781c4f..07415e14354 100644 --- a/crates/bindings/src/rng.rs +++ b/crates/bindings/src/rng.rs @@ -61,7 +61,7 @@ impl ReducerContext { /// [`rand::Rng`] in order to access many useful random algorithms. /// /// `StdbRng` uses the same PRNG as `rand`'s [`StdRng`]. Note, however, that -/// because it is seeded from a publically-known timestamp, it is not +/// because it is seeded from a publicly-known timestamp, it is not /// cryptographically secure. /// /// You may be looking for a level of reproducibility that's finer-grained diff --git a/crates/bindings/tests/deps.rs b/crates/bindings/tests/deps.rs index cc59095da94..b070f3ba372 100644 --- a/crates/bindings/tests/deps.rs +++ b/crates/bindings/tests/deps.rs @@ -1,5 +1,5 @@ //! Snapshot testing for the dependency tree of the `bindings` crate - we want -//! to make sure we don't unknowningly add a bunch of dependencies here, +//! to make sure we don't unknowingly add a bunch of dependencies here, //! slowing down compilation for every spacetime module. // We need to remove the `cpufeatures` and `libc` dependencies from the output, it added on `arm` architecture: diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index 147e1eeee34..4221cb9f009 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -26,7 +26,7 @@ static GLOBAL: MiMalloc = MiMalloc; async fn main() -> anyhow::Result { // Compute matches before loading the config, because `Config` has an observable `drop` method // (which deletes a lockfile), - // and Clap calls `exit` on parse failure rather than panicing, so destructors never run. + // and Clap calls `exit` on parse failure rather than panicking, so destructors never run. let matches = get_command().get_matches(); let (cmd, subcommand_args) = matches.subcommand().unwrap(); diff --git a/crates/cli/src/subcommands/logs.rs b/crates/cli/src/subcommands/logs.rs index c92a6f01cda..cdfa2651b2a 100644 --- a/crates/cli/src/subcommands/logs.rs +++ b/crates/cli/src/subcommands/logs.rs @@ -126,13 +126,13 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), anyhow::E // We typically don't want logs from the very beginning if we're also following. num_lines = Some(10); } - let query_parms = LogsParams { num_lines, follow }; + let query_params = LogsParams { num_lines, follow }; let host_url = config.get_host_url(server)?; let builder = reqwest::Client::new().get(format!("{}/v1/database/{}/logs", host_url, database_identity)); let builder = add_auth_header_opt(builder, &auth_header); - let mut res = builder.query(&query_parms).send().await?; + let mut res = builder.query(&query_params).send().await?; let status = res.status(); if status.is_client_error() || status.is_server_error() { diff --git a/crates/client-api-messages/src/websocket.rs b/crates/client-api-messages/src/websocket.rs index 629eb14b372..e6f6d97ea28 100644 --- a/crates/client-api-messages/src/websocket.rs +++ b/crates/client-api-messages/src/websocket.rs @@ -727,7 +727,7 @@ pub struct OneOffTable { /// The set of rows which matched the query, encoded as BSATN or JSON according to the table's schema /// and the client's requested protocol. /// - /// TODO(centril, 1.0): Evalutate whether we want to conditionally compress these. + /// TODO(centril, 1.0): Evaluate whether we want to conditionally compress these. pub rows: F::List, } diff --git a/crates/client-api/src/routes/database.rs b/crates/client-api/src/routes/database.rs index 13d200e3801..e6e8091f27f 100644 --- a/crates/client-api/src/routes/database.rs +++ b/crates/client-api/src/routes/database.rs @@ -124,7 +124,7 @@ pub async fn call( StatusCode::NOT_FOUND } ReducerCallError::LifecycleReducer(lifecycle) => { - log::debug!("Attempt to call {lifecycle:?} lifeycle reducer {}", reducer); + log::debug!("Attempt to call {lifecycle:?} lifecycle reducer {}", reducer); StatusCode::BAD_REQUEST } }; diff --git a/crates/client-api/src/routes/subscribe.rs b/crates/client-api/src/routes/subscribe.rs index 64ffc4e3e3d..52103b34aeb 100644 --- a/crates/client-api/src/routes/subscribe.rs +++ b/crates/client-api/src/routes/subscribe.rs @@ -49,7 +49,7 @@ pub struct SubscribeQueryParams { #[serde(default)] pub compression: Compression, /// Whether we want "light" responses, tailored to network bandwidth constrained clients. - /// This knob works by setting other, more specifc, knobs to the value. + /// This knob works by setting other, more specific, knobs to the value. #[serde(default)] pub light: bool, } diff --git a/crates/codegen/src/rust.rs b/crates/codegen/src/rust.rs index af5b7ccbaab..14554141e0d 100644 --- a/crates/codegen/src/rust.rs +++ b/crates/codegen/src/rust.rs @@ -1462,7 +1462,7 @@ impl impl Iterator impl Iterator { module.tables().sorted_by_key(|table| &table.name) } @@ -124,7 +124,7 @@ pub(super) fn iter_indexes(table: &TableDef) -> impl Iterator /// Iterate over all the [`TypeDef`]s defined by the module, in alphabetical order by name. /// -/// Sorting is necessary to have deterministic reproducable codegen. +/// Sorting is necessary to have deterministic reproducible codegen. pub fn iter_types(module: &ModuleDef) -> impl Iterator { module.types().sorted_by_key(|table| &table.name) } diff --git a/crates/commitlog/src/index/indexfile.rs b/crates/commitlog/src/index/indexfile.rs index 2d0702de274..984318bce48 100644 --- a/crates/commitlog/src/index/indexfile.rs +++ b/crates/commitlog/src/index/indexfile.rs @@ -17,7 +17,7 @@ const ENTRY_SIZE: usize = KEY_SIZE + mem::size_of::(); /// /// `IndexFileMut` provides efficient read and write access to an index file, which stores /// key-value pairs -/// Succesive key written should be sorted in ascending order, 0 is invalid-key value +/// Successive key written should be sorted in ascending order, 0 is invalid-key value #[derive(Debug)] pub struct IndexFileMut { // A mutable memory-mapped buffer that represents the file contents. @@ -185,7 +185,7 @@ impl + From> IndexFileMut { /// Asynchronously flushes any pending changes to the index file /// /// Due to Async nature, `Ok(())` does not guarantee that the changes are flushed. - /// an `Err` value indicates it definately did not succeed + /// an `Err` value indicates it definitely did not succeed pub fn async_flush(&self) -> io::Result<()> { self.inner.flush_async() } diff --git a/crates/core/src/db/datastore/locking_tx_datastore/datastore.rs b/crates/core/src/db/datastore/locking_tx_datastore/datastore.rs index 129ea879e15..b13461158b5 100644 --- a/crates/core/src/db/datastore/locking_tx_datastore/datastore.rs +++ b/crates/core/src/db/datastore/locking_tx_datastore/datastore.rs @@ -1024,7 +1024,7 @@ impl spacetimedb_commitlog::payload::txdata::Visitor for ReplayVi type Error = ReplayError; // NOTE: Technically, this could be `()` if and when we can extract the // row data without going through `ProductValue` (PV). - // To accomodate auxiliary traversals (e.g. for analytics), we may want to + // To accommodate auxiliary traversals (e.g. for analytics), we may want to // provide a separate visitor yielding PVs. type Row = ProductValue; diff --git a/crates/core/src/db/datastore/locking_tx_datastore/mut_tx.rs b/crates/core/src/db/datastore/locking_tx_datastore/mut_tx.rs index 05c706f3783..52eee235d98 100644 --- a/crates/core/src/db/datastore/locking_tx_datastore/mut_tx.rs +++ b/crates/core/src/db/datastore/locking_tx_datastore/mut_tx.rs @@ -104,7 +104,7 @@ impl DeltaStore for MutTxId { None } - /// Subscriptions are currently evaluated using read-only transcations. + /// Subscriptions are currently evaluated using read-only transactions. /// Hence this will never be called on a mutable transaction. fn index_scan_range_for_delta( &self, @@ -116,7 +116,7 @@ impl DeltaStore for MutTxId { std::iter::empty() } - /// Subscriptions are currently evaluated using read-only transcations. + /// Subscriptions are currently evaluated using read-only transactions. /// Hence this will never be called on a mutable transaction. fn index_scan_point_for_delta( &self, diff --git a/crates/core/src/db/relational_db.rs b/crates/core/src/db/relational_db.rs index fae39a7e095..0c16db7fb82 100644 --- a/crates/core/src/db/relational_db.rs +++ b/crates/core/src/db/relational_db.rs @@ -401,7 +401,7 @@ impl RelationalDB { /// Records the database's identity, owner and module parameters in the /// system tables. The transactional context is supplied by the caller. /// - /// It is an error to call this method on an alread-initialized database. + /// It is an error to call this method on an already-initialized database. /// /// See [`Self::open`] for further information. pub fn set_initialized(&self, tx: &mut MutTx, host_type: HostType, program: Program) -> Result<(), DBError> { @@ -990,8 +990,8 @@ impl RelationalDB { { let mut tx = self.begin_tx(workload); let res = f(&mut tx); - let (tx_metics, reducer) = self.release_tx(tx); - self.report_tx_metricses(&reducer, None, None, &tx_metics); + let (tx_metrics, reducer) = self.release_tx(tx); + self.report_tx_metricses(&reducer, None, None, &tx_metrics); res } diff --git a/crates/core/src/host/module_host.rs b/crates/core/src/host/module_host.rs index d88c3b4b5a2..fa5dad0be41 100644 --- a/crates/core/src/host/module_host.rs +++ b/crates/core/src/host/module_host.rs @@ -846,7 +846,7 @@ impl ModuleHost { .. }) => fallback().await, - // If it succeeded, as mentioend above, `st_client` is already updated. + // If it succeeded, as mentioned above, `st_client` is already updated. Ok(ReducerCallResult { outcome: ReducerOutcome::Committed, .. diff --git a/crates/core/src/host/scheduler.rs b/crates/core/src/host/scheduler.rs index c3ca8cd9191..ae46ca36a73 100644 --- a/crates/core/src/host/scheduler.rs +++ b/crates/core/src/host/scheduler.rs @@ -324,14 +324,14 @@ impl SchedulerActor { let Ok(schedule_row) = get_schedule_row_mut(tx, &db, id) else { // if the row is not found, it means the schedule is cancelled by the user log::debug!( - "table row corresponding to yeild scheduler id not found: tableid {}, schedulerId {}", + "table row corresponding to yield scheduler id not found: tableid {}, schedulerId {}", id.table_id, id.schedule_id ); return Ok(None); }; - let ScheduledReducer { reducer, bsatn_args } = proccess_schedule(tx, &db, id.table_id, &schedule_row)?; + let ScheduledReducer { reducer, bsatn_args } = process_schedule(tx, &db, id.table_id, &schedule_row)?; let (reducer_id, reducer_seed) = module_info .module_def @@ -480,7 +480,7 @@ fn commit_and_broadcast_deletion_event(tx: MutTxId, module_host: ModuleHost) { } /// Generate `ScheduledReducer` for given `ScheduledReducerId` -fn proccess_schedule( +fn process_schedule( tx: &MutTxId, db: &RelationalDB, table_id: TableId, diff --git a/crates/core/src/host/wasm_common/module_host_actor.rs b/crates/core/src/host/wasm_common/module_host_actor.rs index 1b1c61ef07d..204a10c7c52 100644 --- a/crates/core/src/host/wasm_common/module_host_actor.rs +++ b/crates/core/src/host/wasm_common/module_host_actor.rs @@ -324,7 +324,7 @@ impl WasmModuleInstance { // case. // /// The method also performs various measurements and records energy usage, - /// as well as broadcasting a [`ModuleEvent`] containg information about + /// as well as broadcasting a [`ModuleEvent`] containing information about /// the outcome of the call. #[tracing::instrument(level = "trace", skip_all)] fn call_reducer_with_tx(&mut self, tx: Option, params: CallReducerParams) -> ReducerCallResult { @@ -472,7 +472,7 @@ impl WasmModuleInstance { ); EventStatus::Failed(errmsg.into()) } - // We haven't actually comitted yet - `commit_and_broadcast_event` will commit + // We haven't actually committed yet - `commit_and_broadcast_event` will commit // for us and replace this with the actual database update. // // Detecting a new client, and inserting it in `st_clients` diff --git a/crates/core/src/host/wasmtime/wasm_instance_env.rs b/crates/core/src/host/wasmtime/wasm_instance_env.rs index 47f3452f856..cd45950f6e9 100644 --- a/crates/core/src/host/wasmtime/wasm_instance_env.rs +++ b/crates/core/src/host/wasmtime/wasm_instance_env.rs @@ -1100,7 +1100,7 @@ impl WasmInstanceEnv { }) } - /// Logs at `level` a `message` message occuring in `filename:line_number` + /// Logs at `level` a `message` message occurring in `filename:line_number` /// with [`target`](target) being the module path at the `log!` invocation site. /// /// These various pointers are interpreted lossily as UTF-8 strings with a corresponding `_len`. diff --git a/crates/core/src/messages/control_worker_api.rs b/crates/core/src/messages/control_worker_api.rs index 17c5d8bc339..dbb31dc5139 100644 --- a/crates/core/src/messages/control_worker_api.rs +++ b/crates/core/src/messages/control_worker_api.rs @@ -53,7 +53,7 @@ pub struct EnergyBalanceUpdate { pub identity: Identity, pub energy_balance: i128, } -// A message to syncronize energy balances from control node to worker node. +// A message to synchronize energy balances from control node to worker node. #[derive(Clone, PartialEq, Serialize, Deserialize)] pub struct EnergyBalanceState { pub balances: Vec, diff --git a/crates/core/src/sql/compiler.rs b/crates/core/src/sql/compiler.rs index d5d6a453b5c..b94853cbce7 100644 --- a/crates/core/src/sql/compiler.rs +++ b/crates/core/src/sql/compiler.rs @@ -431,7 +431,7 @@ mod tests { let tx = begin_tx(&db); // Note, order does not matter. - // The sargable predicate occurs first adn we can generate an index scan. + // The sargable predicate occurs first and we can generate an index scan. let sql = "select * from test where b = 2 and a = 1"; let CrudExpr::Query(QueryExpr { source: _, query }) = compile_sql(&db, &tx, sql)?.remove(0) else { panic!("Expected QueryExpr"); diff --git a/crates/core/src/sql/execute.rs b/crates/core/src/sql/execute.rs index de20b387301..9a64f4f1d2c 100644 --- a/crates/core/src/sql/execute.rs +++ b/crates/core/src/sql/execute.rs @@ -185,7 +185,7 @@ pub fn run( subs: Option<&ModuleSubscriptions>, head: &mut Vec<(Box, AlgebraicType)>, ) -> Result { - // We parse the sql statement in a mutable transation. + // We parse the sql statement in a mutable transaction. // If it turns out to be a query, we downgrade the tx. let (tx, stmt) = db.with_auto_rollback(db.begin_mut_tx(IsolationLevel::Serializable, Workload::Sql), |tx| { compile_sql_stmt(sql_text, &SchemaViewer::new(tx, &auth), &auth) diff --git a/crates/core/src/subscription/execution_unit.rs b/crates/core/src/subscription/execution_unit.rs index 61938f95da0..bf63150bbbc 100644 --- a/crates/core/src/subscription/execution_unit.rs +++ b/crates/core/src/subscription/execution_unit.rs @@ -132,7 +132,7 @@ impl PartialEq for ExecutionUnit { impl From for ExecutionUnit { // Used in tests and benches. // TODO(bikeshedding): Remove this impl, - // in favor of more explcit calls to `ExecutionUnit::new` with `QueryHash::NONE`. + // in favor of more explicit calls to `ExecutionUnit::new` with `QueryHash::NONE`. fn from(plan: SupportedQuery) -> Self { Self::new(plan, QueryHash::NONE).unwrap() } diff --git a/crates/core/src/subscription/module_subscription_actor.rs b/crates/core/src/subscription/module_subscription_actor.rs index 8ffa483dafd..2bec47b049f 100644 --- a/crates/core/src/subscription/module_subscription_actor.rs +++ b/crates/core/src/subscription/module_subscription_actor.rs @@ -1262,7 +1262,7 @@ mod tests { Ok(()) } - /// Test that clients receieve error messages on tx updates + /// Test that clients receive error messages on tx updates #[tokio::test] async fn tx_update_error() -> anyhow::Result<()> { let client_id = client_id_from_u8(1); diff --git a/crates/core/src/subscription/query.rs b/crates/core/src/subscription/query.rs index e5cb83dacb6..7ba111592c3 100644 --- a/crates/core/src/subscription/query.rs +++ b/crates/core/src/subscription/query.rs @@ -762,7 +762,7 @@ mod tests { } #[test] - /// TODO: This test is a slight modifaction of [test_eval_incr_for_index_join]. + /// TODO: This test is a slight modification of [test_eval_incr_for_index_join]. /// Essentially the WHERE condition is on different tables. /// Should refactor to reduce duplicate logic between the two tests. fn test_eval_incr_for_left_semijoin() -> ResultTest<()> { diff --git a/crates/core/src/subscription/subscription.rs b/crates/core/src/subscription/subscription.rs index 38a89c4cd07..c1cd1be0adc 100644 --- a/crates/core/src/subscription/subscription.rs +++ b/crates/core/src/subscription/subscription.rs @@ -299,7 +299,7 @@ impl IncrementalJoin { /// B(t) refers to the state of table B as of transaction t. /// In particular, B(t) includes all of the changes from t. /// B(s) refers to the state of table B as of transaction s, - /// where s is the transaction immediately preceeding t. + /// where s is the transaction immediately preceding t. /// /// Now we may ask, /// given a set of updates to tables A and/or B, @@ -316,7 +316,7 @@ impl IncrementalJoin { /// Because they have no bearing on newly inserted rows of A. /// /// Now consider rows that were deleted from A. - /// Similary we want to know if they join with any deleted rows of B, + /// Similarly we want to know if they join with any deleted rows of B, /// or if they join with any previously existing rows of B. /// That is: /// diff --git a/crates/data-structures/src/error_stream.rs b/crates/data-structures/src/error_stream.rs index 2416290bdaf..537c1919dea 100644 --- a/crates/data-structures/src/error_stream.rs +++ b/crates/data-structures/src/error_stream.rs @@ -1,4 +1,4 @@ -//! Types, traits, and macros for working with non-empty streams of errorrs. +//! Types, traits, and macros for working with non-empty streams of errors. //! //! The `ErrorStream<_>` type provides a collection that stores a non-empty, unordered stream of errors. //! This is valuable for collecting as many errors as possible before returning them to the user, diff --git a/crates/data-structures/src/slim_slice.rs b/crates/data-structures/src/slim_slice.rs index aa732a7e98e..38c86952b79 100644 --- a/crates/data-structures/src/slim_slice.rs +++ b/crates/data-structures/src/slim_slice.rs @@ -14,7 +14,7 @@ //! //! Because hitting `u32::MAX` is substantially more likely than `u64::MAX`, //! the risk of overflow is greater. -//! To mitigate this issue, rather than default to panicing, +//! To mitigate this issue, rather than default to panicking, //! this module tries, for the most part, //! to force its user to handle any overflow //! when converting to the slimmer types. @@ -25,18 +25,18 @@ //! - [`SlimSmallSliceBox`], a slimmer version of `SmallVec<[T; N]>` //! but without the growing functionality. //! - [`SlimStrBox`], a slimmer version of `Box` -//! - [`SlimSlice<'a, T>`], a slimmer verion of `&'a [T]` +//! - [`SlimSlice<'a, T>`], a slimmer version of `&'a [T]` //! - [`SlimSliceMut<'a, T>`], a slimmer version of `&'a mut [T]` //! - [`SlimStr<'a>`], a slimmer version of `&'a str` //! - [`SlimStrMut<'a>`], a slimmer version of `&'a mut str` //! //! The following convenience conversion functions are provided: //! -//! - [`from_slice`] converts `&[T] -> SlimSlice`, panicing on overflow -//! - [`from_slice_mut`] converts `&mut [T] -> SlimSliceMut`, panicing on overflow -//! - [`from_str`] converts `&str -> SlimStr`, panicing on overflow -//! - [`from_str_mut`] converts `&mut str -> SlimStrMut`, panicing on overflow -//! - [`from_string`] converts `&str -> SlimStrBox`, panicing on overflow +//! - [`from_slice`] converts `&[T] -> SlimSlice`, panicking on overflow +//! - [`from_slice_mut`] converts `&mut [T] -> SlimSliceMut`, panicking on overflow +//! - [`from_str`] converts `&str -> SlimStr`, panicking on overflow +//! - [`from_str_mut`] converts `&mut str -> SlimStrMut`, panicking on overflow +//! - [`from_string`] converts `&str -> SlimStrBox`, panicking on overflow //! //! These conversions should be reserved for cases where it is known //! that the length `<= u32::MAX` and should be used sparingly. diff --git a/crates/expr/src/check.rs b/crates/expr/src/check.rs index e6102f39cf8..14aaa34a9ed 100644 --- a/crates/expr/src/check.rs +++ b/crates/expr/src/check.rs @@ -362,7 +362,7 @@ mod tests { ] { let sql = format!("select * from t where {ty} = 127"); let result = parse_and_type_sub(&sql, &tx); - assert!(result.is_ok(), "Faild to parse {ty}: {}", result.unwrap_err()); + assert!(result.is_ok(), "Failed to parse {ty}: {}", result.unwrap_err()); } } diff --git a/crates/lib/src/metrics.rs b/crates/lib/src/metrics.rs index 398f00809c1..78da4d3d1d6 100644 --- a/crates/lib/src/metrics.rs +++ b/crates/lib/src/metrics.rs @@ -22,7 +22,7 @@ pub struct ExecutionMetrics { /// /// In addition to the same BSATN serialization of the output rows, /// queries will dereference a `RowPointer` for column projections. - /// Such is the case for fiters as well as index and hash joins. + /// Such is the case for filters as well as index and hash joins. /// /// One place where this metric is not tracked is index scans. /// Specifically the key comparisons that occur during the scan. diff --git a/crates/lib/src/relation.rs b/crates/lib/src/relation.rs index 7e6bfeed6a4..d11285bf8f0 100644 --- a/crates/lib/src/relation.rs +++ b/crates/lib/src/relation.rs @@ -130,7 +130,7 @@ impl Header { ) } - /// Finds the index of the column wth a matching `FieldName`. + /// Finds the index of the column with a matching `FieldName`. pub fn column_pos(&self, col: FieldName) -> Option { self.fields.iter().position(|f| f.field == col).map(Into::into) } diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs index 0e74fffde89..6baafb408d7 100644 --- a/crates/paths/src/lib.rs +++ b/crates/paths/src/lib.rs @@ -217,7 +217,7 @@ pub struct SpacetimePaths { } impl SpacetimePaths { - /// Get the default directories for the currrent platform. + /// Get the default directories for the current platform. /// /// Returns an error if the platform director(y/ies) cannot be found. pub fn platform_defaults() -> anyhow::Result { diff --git a/crates/sats/src/array_type.rs b/crates/sats/src/array_type.rs index 2a193c8091b..fdf452d4d9e 100644 --- a/crates/sats/src/array_type.rs +++ b/crates/sats/src/array_type.rs @@ -3,7 +3,7 @@ use crate::de::Deserialize; use crate::meta_type::MetaType; use crate::{impl_deserialize, impl_serialize, impl_st}; -/// An array type is a homegeneous product type of dynamic length. +/// An array type is a homogeneous product type of dynamic length. /// /// That is, it is a product type /// where every element / factor / field is of the same type diff --git a/crates/sats/src/de/serde.rs b/crates/sats/src/de/serde.rs index ecbc344dc58..bf56fb57c41 100644 --- a/crates/sats/src/de/serde.rs +++ b/crates/sats/src/de/serde.rs @@ -529,10 +529,10 @@ impl<'de, T: super::DeserializeSeed<'de> + Clone, V: super::ArrayVisitor<'de, T: } } -/// Translates `serde::SeqAcess<'de>` (the trait) to `ArrayAccess<'de>` +/// Translates `serde::SeqAccess<'de>` (the trait) to `ArrayAccess<'de>` /// for implementing deserialization of array elements. struct ArrayAccess { - /// The `serde::SeqAcess<'de>` implementation. + /// The `serde::SeqAccess<'de>` implementation. seq: A, /// The seed to pass onto `DeserializeSeed`. seed: T, diff --git a/crates/sats/src/lib.rs b/crates/sats/src/lib.rs index a2c7184a5e7..9c3bffa65ca 100644 --- a/crates/sats/src/lib.rs +++ b/crates/sats/src/lib.rs @@ -34,7 +34,7 @@ pub mod serde { pub use crate::de::serde::{deserialize_from as deserialize, SerdeDeserializer}; pub use crate::ser::serde::{serialize_to as serialize, SerdeSerializer}; - /// A wrapper around a `serde` error which occured while translating SATS <-> serde. + /// A wrapper around a `serde` error which occurred while translating SATS <-> serde. #[repr(transparent)] pub struct SerdeError(pub E); diff --git a/crates/sats/src/proptest.rs b/crates/sats/src/proptest.rs index 0ede86ed136..bc1405c1001 100644 --- a/crates/sats/src/proptest.rs +++ b/crates/sats/src/proptest.rs @@ -67,7 +67,7 @@ fn generate_algebraic_type_from_leaves( .collect()) .prop_map(Vec::into_boxed_slice) .prop_map(AlgebraicType::product), - // Do not generate nevers here; we can't store never in a page. + // Do not generate never here; we can't store never in a page. vec(gen_element.clone().prop_map_into(), 1..=SIZE) .prop_map(|vec| vec .into_iter() diff --git a/crates/sats/src/satn.rs b/crates/sats/src/satn.rs index dca8b1fb44e..47be6fef4dd 100644 --- a/crates/sats/src/satn.rs +++ b/crates/sats/src/satn.rs @@ -232,7 +232,7 @@ struct SatnFormatter<'a, 'f> { f: Writer<'a, 'f>, } -/// An error occured during serialization to the SATS data format. +/// An error occurred during serialization to the SATS data format. #[derive(From, Into)] struct SatnError(fmt::Error); diff --git a/crates/sats/src/sum_value.rs b/crates/sats/src/sum_value.rs index c0fe84e1b54..dbb0644e650 100644 --- a/crates/sats/src/sum_value.rs +++ b/crates/sats/src/sum_value.rs @@ -1,7 +1,7 @@ use crate::algebraic_value::AlgebraicValue; use crate::sum_type::SumType; -/// A value of a sum type chosing a specific variant of the type. +/// A value of a sum type choosing a specific variant of the type. #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)] pub struct SumValue { /// A tag representing the choice of one variant of the sum type's variants. diff --git a/crates/sats/src/timestamp.rs b/crates/sats/src/timestamp.rs index f908eca033e..5da2e73964a 100644 --- a/crates/sats/src/timestamp.rs +++ b/crates/sats/src/timestamp.rs @@ -131,7 +131,7 @@ impl Timestamp { Some(TimeDuration::from_micros(delta)) } - /// Parses an RFC 3339 formated timestamp string + /// Parses an RFC 3339 formatted timestamp string pub fn parse_from_rfc3339(str: &str) -> anyhow::Result { DateTime::parse_from_rfc3339(str) .map_err(|err| anyhow::anyhow!(err)) diff --git a/crates/sats/src/typespace.rs b/crates/sats/src/typespace.rs index d36ee23a446..072b8b6b26d 100644 --- a/crates/sats/src/typespace.rs +++ b/crates/sats/src/typespace.rs @@ -21,7 +21,7 @@ pub enum TypeRefError { /// A `Typespace` represents the typing context in SATS. /// -/// That is, this is the `Δ` or `Γ` you'll see in type theory litterature. +/// That is, this is the `Δ` or `Γ` you'll see in type theory literature. /// /// We use (sort of) [deBrujin indices](https://en.wikipedia.org/wiki/De_Bruijn_index) /// to represent our type variables. diff --git a/crates/sdk/src/client_cache.rs b/crates/sdk/src/client_cache.rs index 46fc31ce013..4fca1b0ca66 100644 --- a/crates/sdk/src/client_cache.rs +++ b/crates/sdk/src/client_cache.rs @@ -106,7 +106,7 @@ impl Default for TableAppliedDiff<'_, Row> { impl<'r, Row> TableAppliedDiff<'r, Row> { /// Returns the applied diff restructured - /// with row updates where deletes and inserts are found accoring to `derive_pk`. + /// with row updates where deletes and inserts are found according to `derive_pk`. pub fn with_updates_by_pk(mut self, derive_pk: impl Fn(&Row) -> &Pk) -> Self { self.derive_updates(derive_pk); self diff --git a/crates/sdk/tests/test-client/src/main.rs b/crates/sdk/tests/test-client/src/main.rs index 0c91af3b059..6f9297b6b69 100644 --- a/crates/sdk/tests/test-client/src/main.rs +++ b/crates/sdk/tests/test-client/src/main.rs @@ -1391,7 +1391,7 @@ fn exec_insert_delete_large_table() { .. }) ) { - anyhow::bail!("Unexpected event: expeced InsertLargeTable but found {:?}", ctx.event,); + anyhow::bail!("Unexpected event: expected InsertLargeTable but found {:?}", ctx.event,); } // Now we'll delete the row we just inserted and check that the delete callback is called. @@ -1437,7 +1437,7 @@ fn exec_insert_delete_large_table() { .. }) ) { - anyhow::bail!("Unexpected event: expeced DeleteLargeTable but found {:?}", ctx.event,); + anyhow::bail!("Unexpected event: expected DeleteLargeTable but found {:?}", ctx.event,); } Ok(()) }; @@ -1527,7 +1527,7 @@ fn exec_insert_primitives_as_strings() { }) ) { anyhow::bail!( - "Unexpected Event: expeced reducer InsertPrimitivesAsStrings but found {:?}", + "Unexpected Event: expected reducer InsertPrimitivesAsStrings but found {:?}", ctx.event, ); } diff --git a/crates/snapshot/src/lib.rs b/crates/snapshot/src/lib.rs index f22a04c0de1..4300565c1d0 100644 --- a/crates/snapshot/src/lib.rs +++ b/crates/snapshot/src/lib.rs @@ -139,7 +139,7 @@ pub const CURRENT_MODULE_ABI_VERSION: [u16; 2] = [7, 0]; /// File extension of snapshot directories. pub const SNAPSHOT_DIR_EXT: &str = "snapshot_dir"; -/// File extension of snapshot files, which contain BSATN-encoded [`Snapshot`]s preceeded by [`blake3::Hash`]es. +/// File extension of snapshot files, which contain BSATN-encoded [`Snapshot`]s preceded by [`blake3::Hash`]es. pub const SNAPSHOT_FILE_EXT: &str = "snapshot_bsatn"; /// File extension of snapshots which have been marked invalid by [`SnapshotRepository::invalidate_newer_snapshots`]. @@ -874,7 +874,7 @@ impl SnapshotRepository { .filter(|path| path.extension() == Some(OsStr::new(SNAPSHOT_DIR_EXT))) // Ignore entries whose lockfile still exists. .filter(|path| !Lockfile::lock_path(path).exists()) - // Parse each entry's TxOffset from the file name; ignore unparseable. + // Parse each entry's TxOffset from the file name; ignore unparsable. // Also ignore if the snapshot file doesn't exists. // This can happen on incomplete transfers, or if something went // wrong during creation. diff --git a/crates/sqltest/standards/2016/features.yml b/crates/sqltest/standards/2016/features.yml index 3ca6e7e079f..171ff47ab39 100644 --- a/crates/sqltest/standards/2016/features.yml +++ b/crates/sqltest/standards/2016/features.yml @@ -1,10 +1,10 @@ -# These have been dervived from: +# These have been derived from: # Annex F: SQL feature taxonomy # Page 1635 mandatory: E011: Numeric data types E011-01: INTEGER and SMALLINT data types (including all spellings) - E011-02: REAL, DOUBLE PRECISON, and FLOAT data types + E011-02: REAL, DOUBLE PRECISION, and FLOAT data types E011-03: DECIMAL and NUMERIC data types E011-04: Arithmetic operators E011-05: Numeric comparison diff --git a/crates/sqltest/test/basic/insert.slt b/crates/sqltest/test/basic/insert.slt index 86a8696483d..756b4174991 100644 --- a/crates/sqltest/test/basic/insert.slt +++ b/crates/sqltest/test/basic/insert.slt @@ -9,4 +9,4 @@ select * from inventory ---- 1 'health1' -#TODO: It fails with many sperate inserts +#TODO: It fails with many separate inserts diff --git a/crates/sqltest/test/basic/select.slt b/crates/sqltest/test/basic/select.slt index 38bdbf287d8..b293f6fd6b2 100644 --- a/crates/sqltest/test/basic/select.slt +++ b/crates/sqltest/test/basic/select.slt @@ -27,7 +27,7 @@ select * from inventory WHERE inventory_id = 1 ---- 1 'health1' -#Cheking using table identifiers +#Checking using table identifiers query TI select name, inventory.inventory_id from inventory WHERE inventory_id = 1 ---- diff --git a/crates/sqltest/test/sql_2016/E011_02.slt b/crates/sqltest/test/sql_2016/E011_02.slt index 073988e0e5e..f0ca3a4778f 100644 --- a/crates/sqltest/test/sql_2016/E011_02.slt +++ b/crates/sqltest/test/sql_2016/E011_02.slt @@ -1,4 +1,4 @@ -# E011-02: REAL, DOUBLE PRECISON, and FLOAT data types +# E011-02: REAL, DOUBLE PRECISION, and FLOAT data types statement ok CREATE TABLE TABLE_E011_02_01_01 ( A DOUBLE PRECISION ) diff --git a/crates/sqltest/test/tutorial.slt b/crates/sqltest/test/tutorial.slt index 7e71807b041..b13a0068f7a 100644 --- a/crates/sqltest/test/tutorial.slt +++ b/crates/sqltest/test/tutorial.slt @@ -4,7 +4,7 @@ # not the ability to handle extreme values, check performance, etc. # Use a small range of values: small integers, short strings, and floating point numbers that use only the most significant bits of an a 32-bit IEEE float. -# Tipically you start creating the schemas. +# Typically you start creating the schemas. # A statetment that must execute end in `ok`. statement ok diff --git a/crates/table/src/layout.rs b/crates/table/src/layout.rs index b7d3a948662..8ffd74df26c 100644 --- a/crates/table/src/layout.rs +++ b/crates/table/src/layout.rs @@ -105,7 +105,7 @@ pub trait HasLayout { /// Supporting recursive types remains a TODO(future-work). /// Note that the previous Spacetime datastore did not support recursive types in tables. /// -/// - Scalar types (`ty.is_scalar()`) are separated into [`PrimitveType`] (atomically-sized types like integers). +/// - Scalar types (`ty.is_scalar()`) are separated into [`PrimitiveType`] (atomically-sized types like integers). /// - Variable length types are separated into [`VarLenType`] (strings, arrays, and maps). /// This separation allows cleaner pattern-matching, e.g. in `HasLayout::layout`, /// where `VarLenType` returns a static ref to [`VAR_LEN_REF_LAYOUT`], diff --git a/crates/table/src/page.rs b/crates/table/src/page.rs index eaae19f4c6e..c6eeb2e6859 100644 --- a/crates/table/src/page.rs +++ b/crates/table/src/page.rs @@ -857,7 +857,7 @@ impl<'page> VarView<'page> { // TODO(perf,future-work): if `chunk` is at the HWM, return it to the gap. // Returning a single chunk to the gap is easy, // but we want to return a whole "run" of sequential freed chunks, - // which requries some bookkeeping (or an O(> n) linked list traversal). + // which requires some bookkeeping (or an O(> n) linked list traversal). self.header.freelist_len += 1; self.header.num_granules -= 1; let adjuster = self.adjuster(); @@ -1398,7 +1398,7 @@ impl Page { // Store all var-len refs into their appropriate slots in the fixed-len row. // SAFETY: - // - The `fixed_len_offset` given by `alloc_fixed_len` resuls in `row` + // - The `fixed_len_offset` given by `alloc_fixed_len` results in `row` // being properly aligned for the row type. // - Caller promised that `fixed_row.len()` matches the row type size exactly. // - `var_len_visitor` is suitable for `fixed_row`. diff --git a/crates/table/src/row_type_visitor.rs b/crates/table/src/row_type_visitor.rs index d7f37f1cc48..0e12274e662 100644 --- a/crates/table/src/row_type_visitor.rs +++ b/crates/table/src/row_type_visitor.rs @@ -368,8 +368,8 @@ impl MemoryUsage for VarLenVisitorProgram { } } -/// Evalutes the `program`, -/// provided the `instr_ptr` as its program counter / intruction pointer, +/// Evaluates the `program`, +/// provided the `instr_ptr` as its program counter / instruction pointer, /// and a callback `read_tag` to extract a tag at the given offset, /// until `Some(offset)` is reached, /// or the program halts. diff --git a/modules/module-test-cs/Lib.cs b/modules/module-test-cs/Lib.cs index 67593315a1f..6e0975f48f1 100644 --- a/modules/module-test-cs/Lib.cs +++ b/modules/module-test-cs/Lib.cs @@ -298,7 +298,7 @@ public static void test(ReducerContext ctx, TestAlias arg, TestB arg2, TestC arg // Delete rows using the "foo" index (from 5 up to, but not including, 10). for (uint row = 5; row < 10; row++) { - // FIXME: Apprently in Rust you can delete by index, but in C# you can't. + // FIXME: Apparently in Rust you can delete by index, but in C# you can't. // numDeleted += ctx.Db.test_a.foo.Delete(row); } diff --git a/modules/sdk-test/src/lib.rs b/modules/sdk-test/src/lib.rs index 7398288bdae..c4dda5aeae3 100644 --- a/modules/sdk-test/src/lib.rs +++ b/modules/sdk-test/src/lib.rs @@ -132,7 +132,7 @@ pub struct EveryVecStruct { /// to delete a row. /// e.g. delete_by delete_my_table = delete_by_name(name: String) /// -/// - fields is a comma-separated list of field specifiers, which are optional attribues, +/// - fields is a comma-separated list of field specifiers, which are optional attributes, /// followed by a field name identifier and a type. /// e.g. #[unique] name String /// diff --git a/smoketests/__init__.py b/smoketests/__init__.py index eb7226b9d3d..82f7bf426d6 100644 --- a/smoketests/__init__.py +++ b/smoketests/__init__.py @@ -37,7 +37,7 @@ # and a dotnet installation is detected HAVE_DOTNET = False -# default value can be overriden by `--compose-file` flag +# default value can be overridden by `--compose-file` flag COMPOSE_FILE = "./docker-compose.yml" # we need to late-bind the output stream to allow unittests to capture stdout/stderr. @@ -237,7 +237,7 @@ def stderr_task(): code = proc.wait() if code: raise subprocess.CalledProcessError(code, fake_args) - print("no inital update, but no error code either") + print("no initial update, but no error code either") except subprocess.TimeoutExpired: print("no initial update, but process is still running") diff --git a/smoketests/tests/schedule_reducer.py b/smoketests/tests/schedule_reducer.py index c5f805bed95..59db98bcb47 100644 --- a/smoketests/tests/schedule_reducer.py +++ b/smoketests/tests/schedule_reducer.py @@ -86,7 +86,7 @@ class SubscribeScheduledTable(Smoketest): def test_scheduled_table_subscription(self): """This test deploys a module with a scheduled reducer and check if client receives subscription update for scheduled table entry and deletion of reducer once it ran""" - # subscribe to empy scheduled_table + # subscribe to empty scheduled_table sub = self.subscribe("SELECT * FROM scheduled_table", n=2) # call a reducer to schedule a reducer self.call("schedule_reducer") @@ -112,7 +112,7 @@ def test_scheduled_table_subscription(self): def test_scheduled_table_subscription_repeated_reducer(self): """This test deploys a module with a repeated reducer and check if client receives subscription update for scheduled table entry and no delete entry""" - # subscribe to emptry scheduled_table + # subscribe to empty scheduled_table sub = self.subscribe("SELECT * FROM scheduled_table", n=2) # call a reducer to schedule a reducer self.call("schedule_repeated_reducer")