Release 0.2.0

Author: DraftedDev

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "bytebox"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2021"
-description = "Easy and performant data storage inspired by Flutter's shared_preferences."
-keywords = ["storage", "msgpack", "serde"]
+description = "High performance and secure data storage solution."
+keywords = ["storage", "config", "serde"]
 categories = ["config", "encoding"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
@@ -12,21 +12,22 @@ homepage = "https://github.com/drafteddev/bytebox"
 documentation = "https://docs.rs/bytebox"
 
 [dependencies]
-dirs = { version = "5.0.1", optional = true }
-serde = { version = "1", features = ["derive"] }
-rmp-serde = "1.1.2"
-bevy = { version = "0.12.1", optional = true, default-features = false }
+bitcode = { version = "0.6.9", features = ["serde"] }
+serde = { version = "1.0", features = ["derive"] }
+chacha20poly1305 = "0.10.1"
 
-[dev-dependencies]
-bevy = { version = "0.12.1", default-features = false }
+[target.'cfg(target_os = "linux")'.dependencies]
+keyring = { version = "3.6.3", features = ["linux-native"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+keyring = { version = "3.6.3", features = ["apple-native"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+keyring = { version = "3.6.3", features = ["windows-native"] }
 
 [features]
-default = ["path"]
-# Contains common functionality for building app data paths.
-path = ["dep:dirs"]
-bevy = ["dep:bevy"]
+default = []
 
 [[example]]
 name = "hello_world"
 path = "examples/hello_world.rs"
-required-features = ["path"]

README.md

@@ -1,22 +1,16 @@
 # ByteBox 📦
 
-ByteBox is an easy and performant data storage solution based on MessagePack. It provides a simple interface for storing
-and retrieving data in a compact format, making it efficient for various applications.
+**ByteBox is an easy and performant data storage solution. It provides a way to read and write data, optionally in a secure format.**
 
 ## Features ✨
 
-- **Compact Storage:** ByteBox uses the MessagePack format, ensuring a compact representation of your data.
-- **Easy Integration:** Simple API for storing and retrieving data with just a few method calls.
-- **Efficient Serialization:** Optimized serialization and deserialization using the rmp_serde library.
+- **Fast** - Serialization uses [bitcode](https://crates.io/crates/bitcode) for maximum decoding and encoding performance.
+- **Ease-of-use** - Use [serde](https://crates.io/crates/serde) and a super-easy API to store and retrieve your data.
+- **Secure** - Secure your data using the XChaCha20Poly1305 algorithm without the hassle of storing and retrieving encryption keys manually.
 
 ## Getting Started 🚀
 
 To use ByteBox in your Rust project, run: ``cargo add bytebox`` or just add the latest version to your `Cargo.toml`.
 
 ## Examples 📝
 - [Hello World](examples/hello_world.rs)
-
-## Bevy Integration
-You can easily use ByteBox in your Bevy app by adding the `bevy` feature and registering the `ByteboxPlugin` plugin.
-
-Add your boxes by calling `ByteboxPlugin::new().with(my_box)` and access your boxes via the `Res<ByteBox>` type in your systems.

examples/hello_world.rs

@@ -1,7 +1,7 @@
-use bytebox::{byte_box::ByteBox, Deserialize, Serialize};
+use std::path::PathBuf;
 
-static APP_NAME: &str = "hello_world";
-static BOX_NAME: &str = "my awesome box";
+use bytebox::ByteBox;
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
 struct MyBox {
@@ -11,34 +11,37 @@ struct MyBox {
     age: i32,
 }
 
-#[cfg(feature = "default")]
+impl ByteBox<true> for MyBox {
+    fn path(&self) -> PathBuf {
+        PathBuf::from("my_box.bin")
+    }
+}
+
 fn main() {
-    let bytebox = ByteBox::default(APP_NAME).expect("Could not create ByteBox");
-
-    // write data container to file
-    bytebox
-        .set(
-            BOX_NAME,
-            &MyBox {
-                special_number: 12,
-                greet: true,
-                name: "John".to_string(),
-                age: 19,
-            },
-        )
-        .expect("Could not write to ByteBox");
-
-    // retrieve data container
-    let my_box = bytebox
-        .get::<MyBox>(BOX_NAME)
-        .expect("Could not read from ByteBox");
-
-    // cleanup bytebox
-    bytebox.delete();
-
-    if my_box.greet {
-        println!("Hello, {}! You are {} years old.", my_box.name, my_box.age);
+    let my_box = MyBox {
+        special_number: 12,
+        greet: true,
+        name: "John".to_string(),
+        age: 19,
+    };
+
+    my_box.save().expect("Could not save ByteBox");
+
+    let mut loaded_box = MyBox {
+        special_number: 0,
+        greet: false,
+        name: String::new(),
+        age: 0,
+    };
+
+    loaded_box.load().expect("Could not load ByteBox");
+
+    if loaded_box.greet {
+        println!(
+            "Hello, {}! You are {} years old.",
+            loaded_box.name, loaded_box.age
+        );
     }
 
-    println!("The special number is {}", my_box.special_number);
+    println!("The special number is {}", loaded_box.special_number);
 }

my_box.bin

@@ -0,0 +1 @@
+�A"��眇e,�s�LxRZ��mŦ�ϭ(y7�&-��0�%O{���y�7W

src/bevy.rs

@@ -0,0 +1,54 @@
+use std::fmt::{Display, Formatter};
+
+/// An error that can occur while operating on a bytebox.
+#[derive(Debug)]
+pub enum Error {
+    /// An I/O error.
+    Io(std::io::Error),
+    /// A Serde error.
+    Serde(bitcode::Error),
+    /// A cipher error.
+    Cipher(chacha20poly1305::Error),
+    /// A keyring error.
+    #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+    KeyRing(keyring::Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Io(e) => write!(f, "IO error: {}", e),
+            Error::Serde(e) => write!(f, "Serde error: {}", e),
+            Error::Cipher(e) => write!(f, "Cipher error: {}", e),
+            #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+            Error::KeyRing(e) => write!(f, "KeyRing error: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl From<std::io::Error> for Error {
+    fn from(e: std::io::Error) -> Self {
+        Error::Io(e)
+    }
+}
+
+impl From<bitcode::Error> for Error {
+    fn from(e: bitcode::Error) -> Self {
+        Error::Serde(e)
+    }
+}
+
+impl From<chacha20poly1305::Error> for Error {
+    fn from(e: chacha20poly1305::Error) -> Self {
+        Error::Cipher(e)
+    }
+}
+
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+impl From<keyring::Error> for Error {
+    fn from(e: keyring::Error) -> Self {
+        Error::KeyRing(e)
+    }
+}