opendal 0.1.9 → 0.1.11

data/core/tests/behavior/async_stat.rs

@@ -39,6 +39,7 @@ pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
             test_stat_not_exist,
             test_stat_with_if_match,
             test_stat_with_if_none_match,
+            test_stat_with_version_conditions,
             test_stat_with_if_modified_since,
             test_stat_with_if_unmodified_since,
             test_stat_with_override_cache_control,
@@ -200,6 +201,14 @@ pub async fn test_stat_with_if_match(op: Operator) -> Result<()> {
         .await;
     assert!(result.is_ok());
 
+    let missing = TEST_FIXTURE.new_file_path();
+    let err = op
+        .stat_with(&missing)
+        .if_match(meta.etag().expect("etag must exist"))
+        .await
+        .expect_err("missing target must fail");
+    assert_eq!(err.kind(), ErrorKind::NotFound);
+
     Ok(())
 }
 
@@ -233,6 +242,71 @@ pub async fn test_stat_with_if_none_match(op: Operator) -> Result<()> {
     assert_eq!(res.mode(), meta.mode());
     assert_eq!(res.content_length(), meta.content_length());
 
+    let missing = TEST_FIXTURE.new_file_path();
+    let err = op
+        .stat_with(&missing)
+        .if_none_match(meta.etag().expect("etag must exist"))
+        .await
+        .expect_err("missing target must fail");
+    assert_eq!(err.kind(), ErrorKind::NotFound);
+
+    Ok(())
+}
+
+/// Version preconditions should compare against the current live object version.
+pub async fn test_stat_with_version_conditions(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    if !cap.stat_with_if_version_match || !cap.stat_with_if_version_not_match {
+        return Ok(());
+    }
+
+    let path = TEST_FIXTURE.new_file_path();
+    let (first, _) = gen_bytes(cap);
+    let (second, _) = gen_bytes(cap);
+    assert_ne!(first, second);
+
+    op.write(&path, first).await?;
+    let stale = op
+        .stat(&path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+    op.write(&path, second).await?;
+    let current = op
+        .stat(&path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+
+    op.stat_with(&path).if_version_match(&current).await?;
+    let err = op
+        .stat_with(&path)
+        .if_version_match(&stale)
+        .await
+        .expect_err("stale version match must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    op.stat_with(&path).if_version_not_match(&stale).await?;
+    let err = op
+        .stat_with(&path)
+        .if_version_not_match(&current)
+        .await
+        .expect_err("equal version non-match must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    let missing = TEST_FIXTURE.new_file_path();
+    for result in [
+        op.stat_with(&missing).if_version_match(&current).await,
+        op.stat_with(&missing).if_version_not_match(&current).await,
+    ] {
+        assert_eq!(
+            result.expect_err("missing target must fail").kind(),
+            ErrorKind::NotFound
+        );
+    }
+
     Ok(())
 }
 
@@ -263,6 +337,14 @@ pub async fn test_stat_with_if_modified_since(op: Operator) -> Result<()> {
     assert!(res.is_err());
     assert_eq!(res.err().unwrap().kind(), ErrorKind::ConditionNotMatch);
 
+    let missing = TEST_FIXTURE.new_file_path();
+    let err = op
+        .stat_with(&missing)
+        .if_modified_since(since)
+        .await
+        .expect_err("missing target must fail");
+    assert_eq!(err.kind(), ErrorKind::NotFound);
+
     Ok(())
 }
 
@@ -293,6 +375,14 @@ pub async fn test_stat_with_if_unmodified_since(op: Operator) -> Result<()> {
     let res = op.stat_with(&path).if_unmodified_since(since).await?;
     assert_eq!(res.last_modified(), meta.last_modified());
 
+    let missing = TEST_FIXTURE.new_file_path();
+    let err = op
+        .stat_with(&missing)
+        .if_unmodified_since(since)
+        .await
+        .expect_err("missing target must fail");
+    assert_eq!(err.kind(), ErrorKind::NotFound);
+
     Ok(())
 }
 

data/core/tests/behavior/async_write.rs

@@ -45,6 +45,8 @@ pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
             test_write_with_if_none_match,
             test_write_with_if_not_exists,
             test_write_with_if_match,
+            test_write_with_version_conditions,
+            test_write_if_not_changed,
             test_write_with_user_metadata,
             test_write_returns_metadata,
             test_writer_write,
@@ -57,7 +59,12 @@ pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
             test_writer_futures_copy,
             test_writer_futures_copy_with_concurrent,
             test_writer_return_metadata,
-            test_writer_write_non_contiguous_data
+            test_writer_copy_from_interleaved,
+            test_writer_write_non_contiguous_data,
+            test_writer_write_with_if_not_exists,
+            test_writer_write_with_if_none_match,
+            test_writer_write_with_if_match,
+            test_writer_write_with_version_conditions
         ))
     }
 
@@ -242,7 +249,10 @@ pub async fn test_write_with_user_metadata(op: Operator) -> Result<()> {
     let resp_meta = meta.user_metadata().expect("meta data must exist");
 
     assert_eq!(
-        *resp_meta,
+        resp_meta
+            .into_iter()
+            .map(|(key, value)| (key.to_owned(), value.to_owned()))
+            .collect::<HashMap<_, _>>(),
         target_user_metadata.into_iter().collect::<HashMap<_, _>>()
     );
 
@@ -349,6 +359,59 @@ pub async fn test_writer_write(op: Operator) -> Result<()> {
     Ok(())
 }
 
+/// Assemble a destination from local bytes and source ranges in call order.
+pub async fn test_writer_copy_from_interleaved(op: Operator) -> Result<()> {
+    if !op.info().capability().write_can_multi {
+        return Ok(());
+    }
+
+    let source_path = TEST_FIXTURE.new_file_path();
+    let target_path = TEST_FIXTURE.new_file_path();
+    let source = gen_fixed_bytes(18 * 1024 * 1024);
+    op.write(&source_path, source.clone()).await?;
+    let source_meta = op.stat(&source_path).await?;
+    let source_if_match =
+        if op.info().capability().read_with_if_match && op.info().capability().stat_with_if_match {
+            source_meta.etag().map(str::to_string)
+        } else {
+            None
+        };
+
+    let mut writer = op.writer(&target_path).await?;
+    writer.write("header").await?;
+    writer.copy_from(&source_path, 1024_u64..2048).await?;
+    writer
+        .copy_from_options(
+            &source_path,
+            options::ReadOptions {
+                range: (2048_u64..14 * 1024 * 1024).into(),
+                if_match: source_if_match.clone(),
+                ..Default::default()
+            },
+        )
+        .await?;
+    writer.write("footer").await?;
+    writer
+        .copy_from_options(
+            &source_path,
+            options::ReadOptions {
+                range: (15 * 1024 * 1024_u64..).into(),
+                if_match: source_if_match,
+                ..Default::default()
+            },
+        )
+        .await?;
+    writer.close().await?;
+
+    let mut expected = Vec::new();
+    expected.extend_from_slice(b"header");
+    expected.extend_from_slice(&source[1024..14 * 1024 * 1024]);
+    expected.extend_from_slice(b"footer");
+    expected.extend_from_slice(&source[15 * 1024 * 1024..]);
+    assert_eq!(op.read(&target_path).await?.to_bytes(), expected);
+    Ok(())
+}
+
 /// Append data into writer
 pub async fn test_writer_write_with_concurrent(op: Operator) -> Result<()> {
     if !(op.info().capability().write_can_multi) {
@@ -810,6 +873,271 @@ pub async fn test_write_with_if_match(op: Operator) -> Result<()> {
     Ok(())
 }
 
+/// Version preconditions should compare against the current live object version.
+pub async fn test_write_with_version_conditions(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    if !cap.write_with_if_version_match || !cap.write_with_if_version_not_match {
+        return Ok(());
+    }
+
+    let path = TEST_FIXTURE.new_file_path();
+    let (initial, _) = gen_bytes(cap);
+    let (replacement, _) = gen_bytes(cap);
+    assert_ne!(initial, replacement);
+
+    op.write(&path, initial).await?;
+    let first_version = op
+        .stat(&path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+
+    op.write_with(&path, replacement.clone())
+        .if_version_match(&first_version)
+        .await?;
+
+    let current_version = op
+        .stat(&path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+    let err = op
+        .write_with(&path, replacement.clone())
+        .if_version_match(&first_version)
+        .await
+        .expect_err("stale version match must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    let err = op
+        .write_with(&path, replacement.clone())
+        .if_version_not_match(&current_version)
+        .await
+        .expect_err("equal version non-match must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+    op.write_with(&path, replacement)
+        .if_version_not_match(&first_version)
+        .await?;
+
+    let missing = TEST_FIXTURE.new_file_path();
+    for result in [
+        op.write_with(&missing, Vec::<u8>::new())
+            .if_version_match(&current_version)
+            .await,
+        op.write_with(&missing, Vec::<u8>::new())
+            .if_version_not_match(&current_version)
+            .await,
+    ] {
+        assert_eq!(
+            result.expect_err("missing target must fail").kind(),
+            ErrorKind::ConditionNotMatch
+        );
+    }
+
+    Ok(())
+}
+
+/// `if_not_changed` should accept the observed state once and reject it after replacement.
+pub async fn test_write_if_not_changed(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    if !cap.write_with_if_version_match && !cap.write_with_if_match {
+        return Ok(());
+    }
+
+    let path = TEST_FIXTURE.new_file_path();
+    let (initial, _) = gen_bytes(cap);
+    let (replacement, _) = gen_bytes(cap);
+    assert_ne!(initial, replacement);
+
+    op.write(&path, initial).await?;
+    let expected = op.stat(&path).await?;
+
+    let mut conflicting = options::WriteOptions {
+        if_not_changed: Some(expected.clone()),
+        ..Default::default()
+    };
+    let mut matching = conflicting.clone();
+    if cap.write_with_if_version_match {
+        let version = expected.version().expect("version must exist");
+        conflicting.if_version_match = Some(format!("different-{version}"));
+        matching.if_version_match = Some(version.to_string());
+    } else {
+        let etag = expected.etag().expect("etag must exist");
+        conflicting.if_match = Some(format!("different-{etag}"));
+        matching.if_match = Some(etag.to_string());
+    }
+
+    let err = op
+        .write_options(&path, replacement.clone(), conflicting)
+        .await
+        .expect_err("conflicting explicit condition must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    op.write_options(&path, replacement.clone(), matching)
+        .await?;
+    let err = op
+        .write_with(&path, replacement)
+        .if_not_changed(&expected)
+        .await
+        .expect_err("stale metadata must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    Ok(())
+}
+
+/// Write an existing file through a chunked writer with if_not_exists should get a
+/// ConditionNotMatch error.
+pub async fn test_writer_write_with_if_not_exists(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    if !cap.write_with_if_not_exists || !cap.write_can_multi {
+        return Ok(());
+    }
+
+    let path = TEST_FIXTURE.new_file_path();
+    let content = gen_fixed_bytes(cap.write_multi_min_size.unwrap_or(1));
+
+    op.write(&path, content.clone())
+        .await
+        .expect("write must succeed");
+
+    // Some services reject the precondition when the writer is created or on an early
+    // write rather than at commit time
+    let res: opendal::Result<()> = async {
+        let mut w = op.writer_with(&path).if_not_exists(true).await?;
+        w.write(content.clone()).await?;
+        w.write(content.clone()).await?;
+        w.close().await?;
+        Ok(())
+    }
+    .await;
+    assert_eq!(res.unwrap_err().kind(), ErrorKind::ConditionNotMatch);
+
+    Ok(())
+}
+
+/// Write an existing file through a chunked writer with its own etag as if_none_match
+/// should get a ConditionNotMatch error.
+pub async fn test_writer_write_with_if_none_match(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    if !cap.write_with_if_none_match || !cap.write_can_multi {
+        return Ok(());
+    }
+
+    let path = TEST_FIXTURE.new_file_path();
+    let content = gen_fixed_bytes(cap.write_multi_min_size.unwrap_or(1));
+
+    op.write(&path, content.clone())
+        .await
+        .expect("write must succeed");
+
+    let meta = op.stat(&path).await?;
+    let etag = meta.etag().expect("etag must exist");
+
+    let res: opendal::Result<()> = async {
+        let mut w = op.writer_with(&path).if_none_match(etag).await?;
+        w.write(content.clone()).await?;
+        w.write(content.clone()).await?;
+        w.close().await?;
+        Ok(())
+    }
+    .await;
+    assert_eq!(res.unwrap_err().kind(), ErrorKind::ConditionNotMatch);
+
+    Ok(())
+}
+
+/// Write a file through a chunked writer with if_match should succeed with the file's own
+/// etag and get a ConditionNotMatch error with a stale one.
+pub async fn test_writer_write_with_if_match(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    if !cap.write_with_if_match || !cap.write_can_multi {
+        return Ok(());
+    }
+
+    let path_a = TEST_FIXTURE.new_file_path();
+    let content_a = gen_fixed_bytes(cap.write_multi_min_size.unwrap_or(1));
+    let (path_b, content_b, _) = TEST_FIXTURE.new_file(op.clone());
+
+    op.write(&path_a, content_a.clone()).await?;
+    op.write(&path_b, content_b.clone()).await?;
+
+    let etag_a = op
+        .stat(&path_a)
+        .await?
+        .etag()
+        .expect("etag must exist")
+        .to_string();
+    let etag_b = op
+        .stat(&path_b)
+        .await?
+        .etag()
+        .expect("etag must exist")
+        .to_string();
+
+    let mut w = op.writer_with(&path_a).if_match(&etag_a).await?;
+    w.write(content_a.clone()).await?;
+    w.write(content_a.clone()).await?;
+    w.close().await.expect("close with own etag must succeed");
+
+    // Should fail: writing to path_a with path_b's etag.
+    let res: opendal::Result<()> = async {
+        let mut w = op.writer_with(&path_a).if_match(&etag_b).await?;
+        w.write(content_a.clone()).await?;
+        w.write(content_a.clone()).await?;
+        w.close().await?;
+        Ok(())
+    }
+    .await;
+    assert_eq!(res.unwrap_err().kind(), ErrorKind::ConditionNotMatch);
+
+    Ok(())
+}
+
+/// Chunked writers should preserve version preconditions through final commit.
+pub async fn test_writer_write_with_version_conditions(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    if !cap.write_can_multi
+        || !cap.write_with_if_version_match
+        || !cap.write_with_if_version_not_match
+    {
+        return Ok(());
+    }
+
+    let path = TEST_FIXTURE.new_file_path();
+    let body = gen_fixed_bytes(cap.write_multi_min_size.unwrap_or(1));
+    op.write(&path, body.clone()).await?;
+    let expected = op
+        .stat(&path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+
+    let mut writer = op.writer_with(&path).if_version_match(&expected).await?;
+    writer.write(body.clone()).await?;
+    writer.write(body.clone()).await?;
+    writer.close().await?;
+
+    let current = op
+        .stat(&path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+    let result: opendal::Result<()> = async {
+        let mut writer = op.writer_with(&path).if_version_not_match(&current).await?;
+        writer.write(body.clone()).await?;
+        writer.write(body).await?;
+        writer.close().await?;
+        Ok(())
+    }
+    .await;
+    assert_eq!(result.unwrap_err().kind(), ErrorKind::ConditionNotMatch);
+
+    Ok(())
+}
+
 pub async fn test_writer_write_non_contiguous_data(op: Operator) -> Result<()> {
     let path = TEST_FIXTURE.new_file_path();
     let size = 1024 * 1024; // write file with 1 MiB

data/core/tests/behavior/main.rs

@@ -21,6 +21,7 @@ mod utils;
 
 pub use utils::*;
 
+mod async_compose;
 mod async_copy;
 mod async_create_dir;
 mod async_delete;
@@ -28,6 +29,7 @@ mod async_list;
 mod async_presign;
 mod async_read;
 mod async_rename;
+mod async_restore;
 mod async_stat;
 mod async_write;
 
@@ -55,12 +57,14 @@ fn main() -> anyhow::Result<()> {
     let mut tests = Vec::new();
 
     async_copy::tests(&op, &mut tests);
+    async_compose::tests(&op, &mut tests);
     async_create_dir::tests(&op, &mut tests);
     async_delete::tests(&op, &mut tests);
     async_list::tests(&op, &mut tests);
     async_presign::tests(&op, &mut tests);
     async_read::tests(&op, &mut tests);
     async_rename::tests(&op, &mut tests);
+    async_restore::tests(&op, &mut tests);
     async_stat::tests(&op, &mut tests);
     async_write::tests(&op, &mut tests);
 

data/core/upgrade.md

@@ -1,3 +1,116 @@
+# Upgrade to v0.59
+
+## Public API
+
+### Construct `Metadata` with `MetadataBuilder`
+
+`Metadata::new`, `Default`, direct metadata setters, and `with_*` methods have been removed. Construct metadata with `MetadataBuilder::file(content_length)`, `MetadataBuilder::dir()`, or `MetadataBuilder::unknown()`, set optional fields on the builder, then call `build()`:
+
+```diff
+-let mut metadata = Metadata::new(EntryMode::FILE);
+-metadata.set_content_length(size);
+-metadata.set_content_type("text/plain");
++let mut builder = MetadataBuilder::file(size);
++builder.content_type("text/plain");
++let metadata = builder.build();
+```
+
+Consume existing metadata with `into_builder()` when creating a modified value. Use `set_file(content_length)`, `set_dir()`, or `set_unknown()` on the builder to change its mode.
+
+`Metadata::user_metadata()` now returns a borrowed `UserMetadata` view instead of `&HashMap<String, String>`. The view supports `get`, `len`, `is_empty`, and `IntoIterator`; collect owned string pairs at boundaries that require a map.
+
+Every file `Metadata` contains an explicit full-object content length by construction. Raw services use `Unknown` for incomplete metadata and promote it with `set_file(content_length)` only when the full length is authoritative.
+
+Compact metadata and finalized raw-operation value blocks are limited to `u16::MAX` encoded bytes, including indexes. `MetadataBuilder::build`, raw option freezing, and raw listed-entry construction panic when a block exceeds this bound.
+
+### Delete inputs use `DeleteOptions`
+
+`DeleteInput` has been removed. Pass `(String, DeleteOptions)` to `Deleter`, delete iterators, streams, and sinks when an entry needs options. Plain paths and `Entry` values remain supported through `IntoDeleteInput`. Custom `IntoDeleteInput` implementations must now return `(String, DeleteOptions)` from `into_delete_input`. `(String, OpDelete)` is no longer accepted by the public delete APIs because raw arguments are already capability-resolved.
+
+```diff
+-deleter.delete(DeleteInput {
+-    path,
+-    version,
+-    recursive: false,
+-});
++deleter.delete((
++    path,
++    DeleteOptions {
++        version,
++        ..Default::default()
++    },
++));
+```
+
+### Existing option and capability literals require defaults
+
+OpenDAL added fields to `Capability`, `ReadOptions`, `ReaderOptions`, `StatOptions`, `WriteOptions`, `DeleteOptions`, and `CopyOptions`. Code that constructs any of these types with an exhaustive struct literal must initialize the new fields. Prefer update syntax so later additions remain source-compatible:
+
+```rust
+use opendal_core::Capability;
+use opendal_core::options::DeleteOptions;
+
+let options = DeleteOptions {
+    recursive: true,
+    ..Default::default()
+};
+
+let capability = Capability {
+    read: true,
+    ..Default::default()
+};
+```
+
+### Conditional errors distinguish conflicts
+
+Failed conditions supplied through operation options return `ErrorKind::ConditionNotMatch`. Conflicts reported independently by a service return the new `ErrorKind::Conflict`; inspect `Error::is_temporary()` to decide whether the receiving OpenDAL layer can replay the same operation. Unsupported conditions return `ErrorKind::Unsupported`, and a missing target observed by `stat` or `read` remains `ErrorKind::NotFound` even when the request was conditional. Update error recovery code that previously treated every service conflict as `ConditionNotMatch` or `Unexpected`.
+
+## Raw API
+
+### `OpCopier` merged into `OpCopy`
+
+`OpCopier` has been removed. `Service::copy` and `ServiceDyn::copy_dyn` now receive a single `OpCopy` argument, and raw services read `chunk`, `concurrent`, and `source_content_length_hint` from `OpCopy`.
+
+### Raw operation arguments are frozen from public options
+
+Public `with_*` mutation methods have been removed from `OpRead`, `OpStat`, `OpWrite`, `OpDelete`, `OpCopy`, and `OpList`. Construct non-empty read, stat, list, and restore arguments by converting the corresponding public `*Options`. Use the capability-aware `from_options(&capability, options)` constructors for `OpWrite`, `OpDelete`, `OpCopy`, and `OpCompose`; `new` and `Default` remain available for empty arguments.
+
+The direct `From<WriteOptions>`, `From<DeleteOptions>`, and `From<CopyOptions>` conversions have been removed. The capability-aware constructors lower `if_not_changed` before freezing, so raw arguments contain only service-ready primitive conditions. `OpWrite::from_options` still returns `(OpWrite, OpWriter)`, while copy execution settings now live directly in `OpCopy`. `OpWrite::user_metadata()` returns the same borrowed `UserMetadata` view as `Metadata`.
+
+### Listed entries contain finalized metadata
+
+`raw::oio::Entry::set_mode` and `metadata_mut` have been removed. Build the final `Metadata` first and pass it to `raw::oio::Entry::new` or `with`. To modify an existing raw entry, consume it with `into_parts`, rebuild its metadata, and construct a replacement entry:
+
+```rust
+use opendal_core::MetadataBuilder;
+use opendal_core::raw;
+
+let entry = raw::oio::Entry::new("path", MetadataBuilder::file(0).build());
+let (path, metadata) = entry.into_parts();
+let mut builder = metadata.into_builder();
+builder.content_type("text/plain");
+let entry = raw::oio::Entry::new(&path, builder.build());
+```
+
+The metadata mode must continue to match the path: directory paths end in `/`, while file paths do not.
+
+### Do not use numeric `Operation` discriminants
+
+The new `Compose` and `Restore` variants changed the implicit numeric discriminants of later `Operation` variants. Code that casts `Operation` with `as usize` must migrate to `Operation::into_static()` or `Display` for stable operation names. `Operation` has no numeric representation contract.
+
+## Services
+
+### Duration config fields use `SignedDuration`
+
+The public `default_ttl` fields on `CloudflareKvConfig`, `MemcachedConfig`, and `RedisConfig` now use `Option<raw::SignedDuration>` instead of `Option<std::time::Duration>`. This allows configuration maps and serialized configuration to parse duration strings. Direct config construction can use the re-exported duration type:
+
+```diff
+-default_ttl: Some(std::time::Duration::from_secs(30)),
++default_ttl: Some(opendal::raw::SignedDuration::from_secs(30)),
+```
+
+The corresponding builder methods continue to accept `std::time::Duration`.
+
 # Upgrade to v0.58
 
 ## Public API
@@ -388,7 +501,7 @@ The following new APIs have been added:
 - [`Deleter::flush`]
 - [`Deleter::close`]
 - [`Deleter::into_sink`]
-- [`DeleteInput`]
+- `DeleteInput`
 - [`IntoDeleteInput`]
 - [`FuturesDeleteSink`]
 

data/src/capability.rs

@@ -18,7 +18,6 @@
 use magnus::Error;
 use magnus::RModule;
 use magnus::method;
-use magnus::prelude::*;
 
 use crate::*;
 

data/src/io.rs

@@ -36,7 +36,6 @@ use magnus::RString;
 use magnus::Value;
 use magnus::io::FMode;
 use magnus::method;
-use magnus::prelude::*;
 use magnus::scan_args::scan_args;
 
 use crate::*;

data/src/lister.rs

@@ -31,7 +31,6 @@ use magnus::Error;
 use magnus::RModule;
 use magnus::Ruby;
 use magnus::method;
-use magnus::prelude::*;
 
 use crate::metadata::Metadata;
 use crate::*;

data/src/metadata.rs

@@ -25,7 +25,6 @@
 use magnus::Error;
 use magnus::RModule;
 use magnus::method;
-use magnus::prelude::*;
 
 use crate::*;
 

data/src/operator_info.rs

@@ -23,7 +23,6 @@
 use magnus::Error;
 use magnus::RModule;
 use magnus::method;
-use magnus::prelude::*;
 
 use crate::capability::Capability;
 use crate::*;