add some initial docs

Author: jbr

.github/workflows/ci.yaml

@@ -69,4 +69,4 @@ jobs:
       run: cargo fmt --all -- --check
 
     - name: Docs
-      run: cargo doc --no-deps --features unstable
+      run: cargo doc --no-deps

Cargo.toml

@@ -8,5 +8,8 @@ edition = "2018"
 redis = { version = "0.16.0", features = ["aio"] }
 async-session = "1.0.2"
 
+[dev-dependencies]
+async-std = { version = "1.6.2", features = ["attributes"] }
+
 [patch.crates-io]
 async-session = { git = "https://github.com/jbr/async-session", branch = "tide" }

README.md

@@ -1,9 +1,40 @@
-# Async-Redis-Session
+# async-redis-session
+## redis-backed session store for [async-session](https://github.com/http-rs/async-session)
 
-This is a redis session store for [async-session](https://github.com/http-rs/async-session/)!
+## ⚠️ Note: This crate is not yet published, so nothing in this readme will actually work yet ⚠️
+check out the status of https://github.com/http-rs/async-session/pull/2 for the latest
 
-Here's what needs to be done next:
+* [API Docs][docs] [![docs.rs docs][docs-badge]][docs]
+* [Releases][releases] [![crates.io version][version-badge]][lib-rs]
+* [Contributing][contributing]
 
-- [ ] write rustdocs
-- [ ] write tests
-- [ ] publish crate
+[releases] https://github.com/jbr/async-redis-session/releases
+[docs] https://docs.rs/async-redis-session
+[contributing] https://github.com/jbr/async-redis-session/blob/master/.github/CONTRIBUTING.md
+[lib-rs] https://lib.rs/async-redis-session
+[docs-badge] https://img.shields.io/badge/docs-latest-blue.svg?style=flat-square
+[version-badge] https://img.shields.io/crates/v/async-redis-session.svg?style=flat-square
+
+## Installation
+```sh
+$ cargo add async-redis-session
+```
+
+## Safety
+This crate uses ``#![deny(unsafe_code)]`` to ensure everything is implemented in
+100% Safe Rust.
+
+## License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br/>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>

src/lib.rs

@@ -1,26 +1,79 @@
+//! # async-redis-session
+//! ```rust
+//! use async_redis_session::RedisSessionStore;
+//! use async_session::{Session, SessionStore};
+//!
+//! # fn main() -> async_session::Result { async_std::task::block_on(async {
+//! let store = RedisSessionStore::new("redis://127.0.0.1/")?;
+//!
+//! let session = Session::new();
+//! session.insert("key".into(), "value".into());
+//!
+//! let cookie_value = store.store_session(session).await.unwrap();
+//! let session = store.load_session(cookie_value).await.unwrap();
+//! assert_eq!(session.get("key").unwrap(), "value");
+//! # Ok(()) }) }
+//! ```
+
+#![forbid(unsafe_code, future_incompatible)]
+#![deny(
+    missing_debug_implementations,
+    nonstandard_style,
+    missing_docs,
+    unreachable_pub,
+    missing_copy_implementations,
+    unused_qualifications
+)]
+
 use async_session::{async_trait, serde_json, Result, Session, SessionStore};
 use redis::{aio::Connection, AsyncCommands, Client, IntoConnectionInfo, RedisResult};
 
+/// # RedisSessionStore
 #[derive(Clone, Debug)]
 pub struct RedisSessionStore {
     client: Client,
     prefix: Option<String>,
 }
 
 impl RedisSessionStore {
+    /// creates a redis store from an existing [`redis::Client`]
+    /// ```rust
+    /// # use async_redis_session::RedisSessionStore;
+    /// let client = redis::Client::open("redis://127.0.0.1").unwrap();
+    /// let store = RedisSessionStore::from_client(client);
+    /// ```
     pub fn from_client(client: Client) -> Self {
         Self {
             client,
             prefix: None,
         }
     }
 
+    /// creates a redis store from a [`redis::IntoConnectionInfo`]
+    /// such as a [`String`], [`&str`](str), or [`Url`](../url/struct.Url.html)
+    /// ```rust
+    /// # use async_redis_session::RedisSessionStore;
+    /// let store = RedisSessionStore::new("redis://127.0.0.1").unwrap();
+    /// ```
     pub fn new(connection_info: impl IntoConnectionInfo) -> RedisResult<Self> {
         Ok(Self::from_client(Client::open(connection_info)?))
     }
 
-    pub fn with_prefix(mut self, prefix: String) -> Self {
-        self.prefix = Some(prefix);
+    /// sets a key prefix for this session store
+    ///
+    /// ```rust
+    /// # use async_redis_session::RedisSessionStore;
+    /// let store = RedisSessionStore::new("redis://127.0.0.1").unwrap()
+    ///     .with_prefix("async-sessions/");
+    /// ```
+    /// ```rust
+    /// # use async_redis_session::RedisSessionStore;
+    /// let client = redis::Client::open("redis://127.0.0.1").unwrap();
+    /// let store = RedisSessionStore::from_client(client)
+    ///     .with_prefix("async-sessions/");
+    /// ```
+    pub fn with_prefix(mut self, prefix: impl AsRef<str>) -> Self {
+        self.prefix = Some(prefix.as_ref().to_owned());
         self
     }