From 986ad2f782cf944990e4eda8bf88ea1821233302 Mon Sep 17 00:00:00 2001 From: Robin Krahl Date: Tue, 11 Dec 2018 23:50:45 +0100 Subject: Add nitrokey as a dependency to nitrocli The nitrokey crate provides a simple interface to the Nitrokey Storage and the Nitrokey Pro based on the libnitrokey library developed by Nitrokey UG. The low-level bindings to this library are available in the nitrokey-sys crate. This patch adds version v0.2.1 of the nitrokey crate as a dependency for nitrocli. It includes the indirect dependencies nitrokey-sys (version 3.4.1) and rand (version 0.4.3). Import subrepo nitrokey/:nitrokey at 2eccc96ceec2282b868891befe9cda7f941fbe7b Import subrepo nitrokey-sys/:nitrokey-sys at f1a11ebf72610fb9cf80ac7f9f147b4ba1a5336f Import subrepo rand/:rand at d7d5da49daf7ceb3e5940072940d495cced3a1b3 --- rand/rand-derive/Cargo.toml | 23 +++++++ rand/rand-derive/README.md | 51 +++++++++++++++ rand/rand-derive/src/lib.rs | 116 ++++++++++++++++++++++++++++++++++ rand/rand-derive/tests/rand_macros.rs | 58 +++++++++++++++++ 4 files changed, 248 insertions(+) create mode 100644 rand/rand-derive/Cargo.toml create mode 100644 rand/rand-derive/README.md create mode 100644 rand/rand-derive/src/lib.rs create mode 100644 rand/rand-derive/tests/rand_macros.rs (limited to 'rand/rand-derive') diff --git a/rand/rand-derive/Cargo.toml b/rand/rand-derive/Cargo.toml new file mode 100644 index 0000000..1a2dbe1 --- /dev/null +++ b/rand/rand-derive/Cargo.toml @@ -0,0 +1,23 @@ +[package] + +name = "rand_derive" +version = "0.3.1" +authors = ["The Rust Project Developers"] +license = "MIT/Apache-2.0" +readme = "README.md" +repository = "https://github.com/rust-lang-nursery/rand" +documentation = "https://docs.rs/rand_derive" +homepage = "https://github.com/rust-lang-nursery/rand" +description = """ +`#[derive(Rand)]` functionality for the `rand::Rand` trait. +""" + +[lib] +proc-macro = true + +[dependencies] +quote = "0.3" +syn = "0.11" + +[dev-dependencies] +rand = { path = "..", version = "0.4" } diff --git a/rand/rand-derive/README.md b/rand/rand-derive/README.md new file mode 100644 index 0000000..3d1fedb --- /dev/null +++ b/rand/rand-derive/README.md @@ -0,0 +1,51 @@ + +rand_macros +==== + +`#[derive(Rand)]` functionality for the `rand::Rand` trait. + +## Usage +Add this to your `Cargo.toml`: + +```toml +[dependencies] +rand = "0.4" +rand_macros = "0.2" +``` + +and this to your crate root: + +```rust +extern crate rand; +#[macro_use] +extern crate rand_macros; +``` + +## Examples + +`#[derive(Rand)]` can be used on any `struct` or `enum` where all fields/variants implement `rand::Rand`. + +```rust +#[derive(Debug, Rand)] +struct Foo { + x: u16, + y: Option, +} + +#[derive(Debug, Rand)] +enum Bar { + X{x: u8, y: isize}, + Y([bool; 4]), + Z, +} +``` +Now you can call the `Rng::gen()` function on your custom types. + +```rust +use rand::Rng; + +let mut rng = rand::thread_rng(); + +println!("{:?}", rng.gen::()); +println!("{:?}", rng.gen::()); +``` diff --git a/rand/rand-derive/src/lib.rs b/rand/rand-derive/src/lib.rs new file mode 100644 index 0000000..80c803a --- /dev/null +++ b/rand/rand-derive/src/lib.rs @@ -0,0 +1,116 @@ +//! Support for `#[derive(Rand)]` +//! +//! # Examples +//! +//! ``` +//! extern crate rand; +//! #[macro_use] +//! extern crate rand_derive; +//! +//! #[derive(Rand, Debug)] +//! struct MyStruct { +//! a: i32, +//! b: u32, +//! } +//! +//! fn main() { +//! println!("{:?}", rand::random::()); +//! } +//! ``` + +extern crate proc_macro; +#[macro_use] +extern crate quote; +extern crate syn; + +use proc_macro::TokenStream; + +#[proc_macro_derive(Rand)] +pub fn rand_derive(input: TokenStream) -> TokenStream { + let s = input.to_string(); + let ast = syn::parse_derive_input(&s).unwrap(); + let gen = impl_rand_derive(&ast); + gen.parse().unwrap() +} + +fn impl_rand_derive(ast: &syn::MacroInput) -> quote::Tokens { + let name = &ast.ident; + let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); + + let rand = match ast.body { + syn::Body::Struct(syn::VariantData::Struct(ref body)) => { + let fields = body + .iter() + .filter_map(|field| field.ident.as_ref()) + .map(|ident| quote! { #ident: __rng.gen() }) + .collect::>(); + + quote! { #name { #(#fields,)* } } + }, + syn::Body::Struct(syn::VariantData::Tuple(ref body)) => { + let fields = (0..body.len()) + .map(|_| quote! { __rng.gen() }) + .collect::>(); + + quote! { #name (#(#fields),*) } + }, + syn::Body::Struct(syn::VariantData::Unit) => { + quote! { #name } + }, + syn::Body::Enum(ref body) => { + if body.is_empty() { + panic!("`Rand` cannot be derived for enums with no variants"); + } + + let len = body.len(); + let mut arms = body + .iter() + .map(|variant| { + let ident = &variant.ident; + match variant.data { + syn::VariantData::Struct(ref body) => { + let fields = body + .iter() + .filter_map(|field| field.ident.as_ref()) + .map(|ident| quote! { #ident: __rng.gen() }) + .collect::>(); + quote! { #name::#ident { #(#fields,)* } } + }, + syn::VariantData::Tuple(ref body) => { + let fields = (0..body.len()) + .map(|_| quote! { __rng.gen() }) + .collect::>(); + + quote! { #name::#ident (#(#fields),*) } + }, + syn::VariantData::Unit => quote! { #name::#ident } + } + }); + + match len { + 1 => quote! { #(#arms)* }, + 2 => { + let (a, b) = (arms.next(), arms.next()); + quote! { if __rng.gen() { #a } else { #b } } + }, + _ => { + let mut variants = arms + .enumerate() + .map(|(index, arm)| quote! { #index => #arm }) + .collect::>(); + variants.push(quote! { _ => unreachable!() }); + quote! { match __rng.gen_range(0, #len) { #(#variants,)* } } + }, + } + } + }; + + quote! { + impl #impl_generics ::rand::Rand for #name #ty_generics #where_clause { + #[inline] + fn rand<__R: ::rand::Rng>(__rng: &mut __R) -> Self { + #rand + } + } + } +} diff --git a/rand/rand-derive/tests/rand_macros.rs b/rand/rand-derive/tests/rand_macros.rs new file mode 100644 index 0000000..938f2b0 --- /dev/null +++ b/rand/rand-derive/tests/rand_macros.rs @@ -0,0 +1,58 @@ +#![allow(dead_code)] + +extern crate rand; +#[macro_use] +extern crate rand_derive; + +use rand::Rng; + +#[derive(Rand)] +struct Struct { + x: u16, + y: Option, +} + +#[derive(Rand)] +struct Tuple(i16, Option); + +#[derive(Rand)] +struct Unit; + +#[derive(Rand)] +enum EnumUnit { + X, +} + +#[derive(Rand)] +enum Enum1 { + X(u8, f32), +} + +#[derive(Rand)] +enum Enum2 { + X(bool), + Y, +} + +#[derive(Rand)] +enum Enum3 { + X { x: u8, y: isize }, + Y([bool; 4]), + Z, +} + +#[test] +fn smoke() { + let mut rng = rand::XorShiftRng::new_unseeded(); + + // check nothing horrible happens internally: + for _ in 0..100 { + let _ = rng.gen::(); + let _ = rng.gen::(); + let _ = rng.gen::(); + let _ = rng.gen::(); + let _ = rng.gen::(); + let _ = rng.gen::(); + let _ = rng.gen::(); + } +} -- cgit v1.2.1