Update documentation and names

Author: tylerreisinger

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "lru-cache-macros"
+name = "cache-macro"
 version = "0.3.0"
 authors = ["Tyler Reisinger <reisinger.tyler@gmail.com>"]
 edition = "2018"

README.md

@@ -1,4 +1,4 @@
-lru-cache-macros
+cache-macro
 ================
 [![Build Status](https://travis-ci.org/tylerreisinger/lru-cache-macro.svg?branch=master)](https://travis-ci.org/tylerreisinger/lru-cache-macro)
 [![lru-cache-macros on docs.rs][docsrs-image]][docsrs]
@@ -9,14 +9,15 @@ lru-cache-macros
 [crates-image]: https://img.shields.io/crates/v/lru-cache-macros.svg
 [crates]: https://crates.io/crates/lru-cache-macros/
 
-An attribute procedural macro to automatically cache the result of a function given a set of inputs.
+A procedural macro to automatically cache the result of a function given a set of inputs.
 
 # Example:
 
 ```rust
-use lru_cache_macros::lru_cache;
+use cache_macro::cache;
+use lru_cache::LruCache;
 
-#[lru_cache(20)]
+#[cache(LruCache : LruCache::new(20))]
 fn fib(x: u32) -> u64 {
     println!("{:?}", x);
     if x <= 1 {
@@ -34,89 +35,83 @@ results because of the recursion hit the cache.
 
 # Usage:
 
-Simply place `#[lru_cache([size])]` above your function. The function must obey a few properties
+Simply place `#[cache(CacheType : constructor)]` above your function. The function must obey a few properties
 to use lru_cache:
 
 * All arguments and return values must implement `Clone`.
 * The function may not take `self` in any form.
 
-The macro will use the LruCache at `::lru_cache::LruCache` by default. This can be changed by
-setting the `cache_type` config variable as shown in the configuration section.
-
 The `LruCache` type used must accept two generic parameters `<Args, Return>` and must support methods
-`get_mut(&K)` and `insert(K, V)`. The `lru-cache` crate meets these requirements.
+`get_mut(&K) -> Option<&mut V>` and `insert(K, V)`. The `lru-cache` (for LRU caching)
+and `expiring_map` (for time-to-live caching) crates currently meet these requirements.
 
 Currently, this crate only works on nightly rust. However, once the 2018 edition stabilizes as well as the
 procedural macro diagnostic interface, it should be able to run on stable.
 
 # Configuration:
 
-The lru_cache macro can be configured by adding additional attributes under `#[lru_cache(size)]`.
-
-All configuration attributes take the form `#[lru_config(...)]`. The available attributes are:
-
-* `#[lru_config(cache_type = ...)]`
-
-    This allows the cache type used internally to be changed. The default is equivalent to
-    
-    ```#[lru_config(cache_type = ::lru_cache::LruCache)]```
-    
-* `#[lru_config(ignore_args = ...)]`
-    
-    This allows certain arguments to be ignored for the purposes of caching. That means they are not part of the 
-    hash table key and thus should never influence the output of the function. It can be useful for diagnostic settings,
-    returning the number of times executed, or other introspection purposes.
-    
-    `ignore_args` takes a comma-separated list of variable identifiers to ignore.
-    
-    ### Example:
-    ```rust
-    use lru_cache_macros::lru_cache;
-    #[lru_cache(20)]
-    #[lru_config(ignore_args = call_count)]
-    fn fib(x: u64, call_count: &mut u32) -> u64 {
-        *call_count += 1;
-        if x <= 1 {
-            1
-        } else {
-            fib(x - 1, call_count) + fib(x - 2, call_count)
-        }
+The lru_cache macro can be configured by adding additional attributes under `#[cache(...)]`.
+
+All configuration attributes take the form `#[cache_cfg(...)]`. The available attributes are:
+
+* `#[cache_cfg(ignore_args = ...)]`
+
+This allows certain arguments to be ignored for the purposes of caching. That means they are not part of the
+hash table key and thus should never influence the output of the function. It can be useful for diagnostic settings,
+returning the number of times executed, or other introspection purposes.
+
+`ignore_args` takes a comma-separated list of variable identifiers to ignore.
+
+### Example:
+```rust
+use cache_macro::cache;
+use lru_cache::LruCache;
+#[cache(LruCache : LruCache::new(20))]
+#[cache_cfg(ignore_args = call_count)]
+fn fib(x: u64, call_count: &mut u32) -> u64 {
+    *call_count += 1;
+    if x <= 1 {
+        1
+    } else {
+        fib(x - 1, call_count) + fib(x - 2, call_count)
     }
+}
+
+let mut call_count = 0;
+assert_eq!(fib(39, &mut call_count), 102_334_155);
+assert_eq!(call_count, 40);
+```
+
+The `call_count` argument can vary, caching is only done based on `x`.
+
+* `#[cache_cfg(thread_local)]`
 
-    let mut call_count = 0;
-    assert_eq!(fib(39, &mut call_count), 102_334_155);
-    assert_eq!(call_count, 40);
-    ```
-    
-    The `call_count` argument can vary, caching is only done based on `x`.
-    
-* `#[lru_config(thread_local)]`
-
-    Store the cache in thread-local storage instead of global static storage. This avoids the overhead of Mutex locking,
-    but each thread will be given its own cache, and all caching will not affect any other thread.
-    
-    Expanding on the first example:
-    
-    ```rust
-    use lru_cache_macros::lru_cache;
-
-    #[lru_cache(20)]
-    #[lru_config(thread_local)]
-    fn fib(x: u32) -> u64 {
-        println!("{:?}", x);
-        if x <= 1 {
-            1
-        } else {
-            fib(x - 1) + fib(x - 2)
-        }
+Store the cache in thread-local storage instead of global static storage. This avoids the overhead of Mutex locking,
+but each thread will be given its own cache, and all caching will not affect any other thread.
+
+Expanding on the first example:
+
+```rust
+use cache_macro::cache;
+use lru_cache::LruCache;
+
+#[cache(LruCache : LruCache::new(20))]
+#[cache_cfg(thread_local)]
+fn fib(x: u32) -> u64 {
+    println!("{:?}", x);
+    if x <= 1 {
+        1
+    } else {
+        fib(x - 1) + fib(x - 2)
     }
+}
 
-    assert_eq!(fib(19), 6765);
-    ``` 
+assert_eq!(fib(19), 6765);
+```
 
 # Details
-The created cache is stored as a static variable protected by a mutex unless the `#[lru_config(thread_local)]` configuration
-is added.
+The created cache is stored as a static variable protected by a mutex unless the `#[cache_cfg(thread_local)]`
+configuration is added.
 
 With the default settings, the fibonacci example will generate the following code:
 
@@ -132,7 +127,7 @@ fn fib(x: u32) -> u64 {
         static ref cache: Mutex<::lru_cache::LruCache<(u32,), u64>> =
             Mutex::new(::lru_cache::LruCache::new(20usize));
     }
-    
+
     let cloned_args = (x.clone(),);
     let mut cache_unlocked = cache.lock().unwrap();
     let stored_result = cache_unlocked.get_mut(&cloned_args);

src/lib.rs

@@ -1,12 +1,12 @@
-//! lru-cache-macros
+//! cache-macro
 //! ================
 //!
-//! An attribute procedural macro to automatically cache the result of a function given a set of inputs.
+//! A procedural macro to automatically cache the result of a function given a set of inputs.
 //!
 //! # Example:
 //!
 //! ```rust
-//! use lru_cache_macros::cache;
+//! use cache_macro::cache;
 //! use lru_cache::LruCache;
 //!
 //! #[cache(LruCache : LruCache::new(20))]
@@ -27,34 +27,26 @@
 //!
 //! # Usage:
 //!
-//! Simply place `#[lru_cache([size])]` above your function. The function must obey a few properties
+//! Simply place `#[cache(CacheType : constructor)]` above your function. The function must obey a few properties
 //! to use lru_cache:
 //!
 //! * All arguments and return values must implement `Clone`.
 //! * The function may not take `self` in any form.
 //!
-//! The macro will use the LruCache at `::lru_cache::LruCache` by default. This can be changed by
-//! setting the `cache_type` config variable as shown in the configuration section.
-//!
 //! The `LruCache` type used must accept two generic parameters `<Args, Return>` and must support methods
-//! `get_mut(&K)` and `insert(K, V)`. The `lru-cache` crate meets these requirements.
+//! `get_mut(&K) -> Option<&mut V>` and `insert(K, V)`. The `lru-cache` (for LRU caching)
+//! and `expiring_map` (for time-to-live caching) crates currently meet these requirements.
 //!
 //! Currently, this crate only works on nightly rust. However, once the 2018 edition stabilizes as well as the
 //! procedural macro diagnostic interface, it should be able to run on stable.
 //!
 //! # Configuration:
 //!
-//! The lru_cache macro can be configured by adding additional attributes under `#[lru_cache(size)]`.
-//!
-//! All configuration attributes take the form `#[lru_config(...)]`. The available attributes are:
-//!
-//! * `#[lru_config(cache_type = ...)]`
-//!
-//! This allows the cache type used internally to be changed. The default is equivalent to
+//! The lru_cache macro can be configured by adding additional attributes under `#[cache(...)]`.
 //!
-//! ```#[lru_config(cache_type = ::lru_cache::LruCache)]```
+//! All configuration attributes take the form `#[cache_cfg(...)]`. The available attributes are:
 //!
-//! * `#[lru_config(ignore_args = ...)]`
+//! * `#[cache_cfg(ignore_args = ...)]`
 //!
 //! This allows certain arguments to be ignored for the purposes of caching. That means they are not part of the
 //! hash table key and thus should never influence the output of the function. It can be useful for diagnostic settings,
@@ -64,7 +56,7 @@
 //!
 //! ### Example:
 //! ```rust
-//! use lru_cache_macros::cache;
+//! use cache_macro::cache;
 //! use lru_cache::LruCache;
 //! #[cache(LruCache : LruCache::new(20))]
 //! #[cache_cfg(ignore_args = call_count)]
@@ -84,15 +76,15 @@
 //!
 //! The `call_count` argument can vary, caching is only done based on `x`.
 //!
-//! * `#[lru_config(thread_local)]`
+//! * `#[cache_cfg(thread_local)]`
 //!
 //! Store the cache in thread-local storage instead of global static storage. This avoids the overhead of Mutex locking,
 //! but each thread will be given its own cache, and all caching will not affect any other thread.
 //!
 //! Expanding on the first example:
 //!
 //! ```rust
-//! use lru_cache_macros::cache;
+//! use cache_macro::cache;
 //! use lru_cache::LruCache;
 //!
 //! #[cache(LruCache : LruCache::new(20))]
@@ -110,8 +102,8 @@
 //! ```
 //!
 //! # Details
-//! The created cache is stored as a static variable protected by a mutex unless the `#[lru_config(thread_local)]` configuration
-//! is added.
+//! The created cache is stored as a static variable protected by a mutex unless the `#[cache_cfg(thread_local)]`
+//! configuration is added.
 //!
 //! With the default settings, the fibonacci example will generate the following code:
 //!

tests/args_as_ref.rs

@@ -1,4 +1,4 @@
-use lru_cache_macros::cache;
+use cache_macro::cache;
 use lru_cache::LruCache;
 
 #[test]

tests/cache_type.rs

@@ -1,4 +1,4 @@
-use lru_cache_macros::cache;
+use cache_macro::cache;
 use std::time::Duration;
 use expiring_map::ExpiringMap;
 use std::hash::Hash;

tests/clone_only_type.rs

@@ -1,4 +1,4 @@
-use lru_cache_macros::cache;
+use cache_macro::cache;
 use lru_cache::LruCache;
 
 use std::ops;

tests/config.rs

@@ -1,4 +1,4 @@
-use lru_cache_macros::cache;
+use cache_macro::cache;
 use lru_cache::LruCache;
 
 use std::thread;

tests/multiple_args.rs

@@ -1,4 +1,4 @@
-use lru_cache_macros::cache;
+use cache_macro::cache;
 use lru_cache::LruCache;
 
 #[test]

tests/multiple_caches.rs

@@ -1,4 +1,4 @@
-use lru_cache_macros::cache;
+use cache_macro::cache;
 use lru_cache::LruCache;
 
 #[test]