Grcov report - lib.rs

1

//! Macros BonsaiDb.

2

3

#![forbid(unsafe_code)]

4

#![warn(

5

    clippy::cargo,

6

    missing_docs,

7

    // clippy::missing_docs_in_private_items,

8

    clippy::nursery,

9

    clippy::pedantic,

10

    future_incompatible,

11

    rust_2018_idioms,

12

)]

13

#![cfg_attr(doc, deny(rustdoc::all))]

14

15

use attribute_derive::Attribute;

16

use proc_macro2::{Span, TokenStream};

17

use proc_macro_crate::{crate_name, FoundCrate};

18

use proc_macro_error::{abort_call_site, proc_macro_error, ResultExt};

19

use quote::{quote, ToTokens};

20

use syn::{

21

    parse_macro_input, parse_quote, punctuated::Punctuated, token::Paren, DeriveInput, Expr, Ident,

22

    LitStr, Path, Type, TypeTuple,

23

};

24

25

fn core_path() -> Path {

26

36

    match crate_name("bonsaidb")

27

36

        .or_else(|_| crate_name("bonsaidb_server"))

28

36

        .or_else(|_| crate_name("bonsaidb_local"))

29

36

        .or_else(|_| crate_name("bonsaidb_client"))

30

31

36

        Ok(FoundCrate::Name(name)) => {

32

36

            let ident = Ident::new(&name, Span::call_site());

33

36

            parse_quote!(::#ident::core)

34

35

        Ok(FoundCrate::Itself) => parse_quote!(crate::core),

36

        Err(_) => match crate_name("bonsaidb_core") {

37

            Ok(FoundCrate::Name(name)) => {

38

                let ident = Ident::new(&name, Span::call_site());

39

                parse_quote!(::#ident)

40

41

            Ok(FoundCrate::Itself) => parse_quote!(crate),

42

            Err(_) => match () {

43

                () if cfg!(feature = "omnibus-path") => parse_quote!(::bonsaidb::core),

44

                () if cfg!(feature = "server-path") => parse_quote!(::bonsaidb_server::core),

45

                () if cfg!(feature = "local-path") => parse_quote!(::bonsaidb_local::core),

46

                () if cfg!(feature = "client-path") => parse_quote!(::bonsaidb_client::core),

47

                _ => parse_quote!(::bonsaidb_core),

48

},

49

},

50

51

36

52

53

442

#[derive(Attribute)]

54

#[attribute(ident = "collection")]

55

#[attribute(

56

    invalid_field = r#"Only `authority = "some-authority"`, `name = "some-name"`, `views = [SomeView, AnotherView]`, `serialization = SerializationFormat` and `core = bonsaidb::core` are supported attributes"#

57

)]

58

struct CollectionAttribute {

59

    authority: Option<String>,

60

    #[attribute(

61

        missing = r#"You need to specify the collection name via `#[collection(name = "name")]`"#

62

)]

63

    name: String,

64

    #[attribute(default)]

65

    #[attribute(expected = r#"Specify the `views` like so: `view = [SomeView, AnotherView]`"#)]

66

    views: Vec<Type>,

67

    #[attribute(

68

        expected = r#"Specify the `serialization` like so: `serialization = Format` or `serialization = None` to disable deriving it"#

69

)]

70

    serialization: Option<Path>,

71

    // TODO add some explanaition when it is possble to integrate the parse error in the printed

72

    // error message, for now the default error is probably more helpful

73

    encryption_key: Option<Expr>,

74

    encryption_required: bool,

75

    encryption_optional: bool,

76

    #[attribute(expected = r#"Specify the the path to `core` like so: `core = bosaidb::core`"#)]

77

    core: Option<Path>,

78

79

80

/// Derives the `bonsaidb::core::schema::Collection` trait.

81

#[proc_macro_error]

82

/// `#[collection(authority = "Authority", name = "Name", views = [a, b, c])]`

83

#[proc_macro_derive(Collection, attributes(collection))]

84

41

pub fn collection_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {

85

    let DeriveInput {

86

41

        attrs,

87

41

        ident,

88

41

        generics,

89

..

90

41

    } = parse_macro_input!(input as DeriveInput);

91

92

    let CollectionAttribute {

93

41

        authority,

94

41

        name,

95

41

        views,

96

41

        serialization,

97

41

        core,

98

41

        encryption_key,

99

41

        encryption_required,

100

41

        encryption_optional,

101

41

    } = CollectionAttribute::from_attributes(attrs).unwrap_or_abort();

102

41

103

41

    if encryption_required && encryption_key.is_none() {

104

        abort_call_site!("If `collection(encryption_required)` is set you need to provide an encryption key via `collection(encryption_key = EncryptionKey)`")

105

41

106

41

107

41

    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

108

41

109

41

    let core = core.unwrap_or_else(core_path);

110

111

41

    let serialization = match serialization {

112

2

        Some(serialization) if serialization.is_ident("None") => TokenStream::new(),

113

1

        Some(serialization) => quote! {

114

1

            impl #impl_generics #core::schema::SerializedCollection for #ident #ty_generics #where_clause {

115

1

                type Contents = #ident #ty_generics;

116

1

                type Format = #serialization;

117

1

118

1

                fn format() -> Self::Format {

119

1

                    #serialization::default()

120

1

121

1

122

1

},

123

39

        None => quote! {

124

39

            impl #impl_generics #core::schema::DefaultSerialization for #ident #ty_generics #where_clause {}

125

39

},

126

};

127

128

41

    let name = authority.map_or_else(

129

41

        || quote!(#core::schema::CollectionName::private(#name)),

130

41

        |authority| quote!(#core::schema::CollectionName::new(#authority, #name)),

131

41

);

132

41

133

41

    let encryption = encryption_key.map(|encryption_key| {

134

11

        let encryption = if encryption_required || !encryption_optional {

135

2

            encryption_key.into_token_stream()

136

        } else {

137

9

            quote! {

138

9

                if #core::ENCRYPTION_ENABLED {

139

9

                    #encryption_key

140

9

                } else {

141

9

                    ::core::option::Option::None

142

9

143

9

144

};

145

11

        quote! {

146

11

            fn encryption_key() -> ::core::option::Option<#core::document::KeyId> {

147

11

                #encryption

148

11

149

11

150

41

});

151

41

152

41

    quote! {

153

41

        impl #impl_generics #core::schema::Collection for #ident #ty_generics #where_clause {

154

41

            fn collection_name() -> #core::schema::CollectionName {

155

41

                #name

156

41

157

41

            fn define_views(schema: &mut #core::schema::Schematic) -> ::core::result::Result<(), #core::Error> {

158

41

                #( schema.define_view(#views)?; )*

159

41

                ::core::result::Result::Ok(())

160

41

161

41

            #encryption

162

41

163

41

        #serialization

164

41

165

41

    .into()

166

167

168

403

#[derive(Attribute)]

169

#[attribute(ident = "view")]

170

#[attribute(

171

    invalid_field = r#"Only `collection = CollectionType`, `key = KeyType`, `name = "by-name"`, `value = ValueType` and `serialization = SerializationFormat` and `core = bonsaidb::core` are supported attributes"#

172

)]

173

struct ViewAttribute {

174

    #[attribute(

175

        missing = r#"You need to specify the collection type via `#[view(collection = CollectionType)]`"#

176

)]

177

    #[attribute(

178

        expected = r#"Specify the collection type like so: `collection = CollectionType`"#

179

)]

180

    collection: Type,

181

    #[attribute(missing = r#"You need to specify the key type via `#[view(key = KeyType)]`"#)]

182

    #[attribute(expected = r#"Specify the key type like so: `key = KeyType`"#)]

183

    key: Type,

184

    name: Option<LitStr>,

185

    #[attribute(expected = r#"Specify the value type like so: `value = ValueType`"#)]

186

    value: Option<Type>,

187

    #[attribute(expected = r#"Specify the the path to `core` like so: `core = bosaidb::core`"#)]

188

    core: Option<Path>,

189

    #[attribute(

190

        expected = r#"Specify the `serialization` like so: `serialization = Format` or `serialization = None` to disable deriving it"#

191

)]

192

    serialization: Option<Path>,

193

194

195

/// Derives the `bonsaidb::core::schema::View` trait.

196

#[proc_macro_error]

197

/// `#[view(collection=CollectionType, key=KeyType, value=ValueType, name = "by-name")]`

198

/// `name` and `value` are optional

199

#[proc_macro_derive(View, attributes(view))]

200

30

pub fn view_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {

201

    let DeriveInput {

202

30

        attrs,

203

30

        ident,

204

30

        generics,

205

..

206

30

    } = parse_macro_input!(input as DeriveInput);

207

208

    let ViewAttribute {

209

30

        collection,

210

30

        key,

211

30

        name,

212

30

        value,

213

30

        core,

214

30

        serialization,

215

30

    } = ViewAttribute::from_attributes(attrs).unwrap_or_abort();

216

30

217

30

    let core = core.unwrap_or_else(core_path);

218

30

219

30

    let value = value.unwrap_or_else(|| {

220

3

        Type::Tuple(TypeTuple {

221

3

            paren_token: Paren::default(),

222

3

            elems: Punctuated::new(),

223

3

})

224

30

});

225

30

226

30

    let name = name

227

30

        .as_ref()

228

30

        .map_or_else(|| ident.to_string(), LitStr::value);

229

30

230

30

    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

231

232

30

    let serialization = match serialization {

233

3

        Some(serialization) if serialization.is_ident("None") => TokenStream::new(),

234

1

        Some(serialization) => quote! {

235

1

            impl #impl_generics #core::schema::SerializedView for #ident #ty_generics #where_clause {

236

1

                type Format = #serialization;

237

1

238

1

                fn format() -> Self::Format {

239

1

                    #serialization::default()

240

1

241

1

242

1

},

243

27

        None => quote! {

244

27

            impl #impl_generics #core::schema::DefaultViewSerialization for #ident #ty_generics #where_clause {}

245

27

},

246

};

247

248

30

    quote! {

249

30

        impl #impl_generics #core::schema::View for #ident #ty_generics #where_clause {

250

30

            type Collection = #collection;

251

30

            type Key = #key;

252

30

            type Value = #value;

253

30

254

30

            fn name(&self) -> #core::schema::Name {

255

30

                #core::schema::Name::new(#name)

256

30

257

30

258

30

        #serialization

259

30

260

30

    .into()

261

262

263

142

#[derive(Attribute)]

264

#[attribute(ident = "schema")]

265

#[attribute(

266

    invalid_field = r#"Only `name = "name""`, `authority = "authority"`, `collections = [SomeCollection, AnotherCollection]` and `core = bonsaidb::core` are supported attributes"#

267

)]

268

struct SchemaAttribute {

269

    #[attribute(missing = r#"You need to specify the schema name via `#[schema(name = "name")]`"#)]

270

    name: String,

271

    authority: Option<String>,

272

    #[attribute(default)]

273

    #[attribute(

274

        expected = r#"Specify the `collections` like so: `collections = [SomeCollection, AnotherCollection]`"#

275

)]

276

    collections: Vec<Type>,

277

    #[attribute(expected = r#"Specify the the path to `core` like so: `core = bosaidb::core`"#)]

278

    core: Option<Path>,

279

280

281

/// Derives the `bonsaidb::core::schema::Schema` trait.

282

#[proc_macro_error]

283

/// `#[schema(name = "Name", authority = "Authority", collections = [A, B, C]), core = bonsaidb::core]`

284

/// `authority`, `collections` and `core` are optional

285

#[proc_macro_derive(Schema, attributes(schema))]

286

11

pub fn schema_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {

287

    let DeriveInput {

288

11

        attrs,

289

11

        ident,

290

11

        generics,

291

..

292

11

    } = parse_macro_input!(input as DeriveInput);

293

294

    let SchemaAttribute {

295

11

        name,

296

11

        authority,

297

11

        collections,

298

11

        core,

299

11

    } = SchemaAttribute::from_attributes(attrs).unwrap_or_abort();

300

11

301

11

    let core = core.unwrap_or_else(core_path);

302

11

    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

303

11

304

11

    let name = authority.map_or_else(

305

11

        || quote!(#core::schema::SchemaName::private(#name)),

306

11

        |authority| quote!(#core::schema::SchemaName::new(#authority, #name)),

307

11

);

308

11

309

11

    quote! {

310

11

        impl #impl_generics #core::schema::Schema for #ident #ty_generics #where_clause {

311

11

            fn schema_name() -> #core::schema::SchemaName {

312

11

                #name

313

11

314

11

315

11

            fn define_collections(

316

11

                schema: &mut #core::schema::Schematic

317

11

            ) -> ::core::result::Result<(), #core::Error> {

318

11

                #( schema.define_collection::<#collections>()?; )*

319

11

                ::core::result::Result::Ok(())

320

11

321

11

322

11

323

11

    .into()

324

325

326

1

#[test]

327

1

fn ui() {

328

1

    use trybuild::TestCases;

329

1

330

1

    TestCases::new().compile_fail("tests/ui/*/*.rs");

331

1