gaunt/subtle-encoding/tai64: Remove failure

These crates weren't getting much value out of `failure`, and the use of
proc macros to generate what is effectively a match statement on enum
variants which returns a string literal adds a lot to compile times.

Furthermore, `failure` is still using the non-1.0 proc macro crates. It
seems there's upstream work to get this fixed[1], but since we're not
really getting value out of the proc macros as-is, there's not much
reason to bother.

[1]: rust-lang-deprecated/failure#319

Author: tony-iqlusion

Cargo.lock

@@ -15,12 +15,10 @@ keywords    = ["api", "client", "http", "rest", "web"]
 travis-ci = { repository = "iqlusioninc/crates", branch = "develop" }
 
 [dependencies]
-failure = { version = "0.1", default-features = false }
-failure_derive = "0.1"
 slog = { version = "2", optional = true }
 
 [features]
 alloc = []
 default = ["std"]
 logger = ["slog", "std"]
-std = ["alloc", "failure/std"]
+std = ["alloc"]

gaunt/Cargo.toml

@@ -1,16 +1,16 @@
 //! Connections to HTTP servers
 
-use crate::prelude::*;
-
 #[cfg(feature = "logger")]
 use slog::Logger;
 use std::{
     fmt::Write as FmtWrite,
     io::Write,
     net::{TcpStream, ToSocketAddrs},
     ops::DerefMut,
+    string::String,
     sync::Mutex,
     time::{Duration, Instant},
+    vec::Vec,
 };
 
 use super::{HTTP_VERSION, USER_AGENT};

gaunt/src/connection.rs

@@ -2,17 +2,13 @@
 
 #![allow(unused_macros)]
 
-#[cfg(feature = "alloc")]
-use crate::prelude::*;
+use core::fmt;
 
 #[cfg(feature = "alloc")]
 use core::{num::ParseIntError, str::Utf8Error};
-use failure::Context;
 
 #[cfg(feature = "std")]
 use std::{
-    error::Error as StdError,
-    fmt::{self, Display},
     io,
     string::{FromUtf8Error, String, ToString},
 };
@@ -21,7 +17,7 @@ use std::{
 #[derive(Debug)]
 pub struct Error {
     /// Error context and kind
-    inner: Context<ErrorKind>,
+    kind: ErrorKind,
 
     /// Optional description
     #[cfg(feature = "alloc")]
@@ -45,72 +41,62 @@ impl Error {
 
     /// Obtain the inner `ErrorKind` for this `Error`
     pub fn kind(&self) -> ErrorKind {
-        *self.inner.get_context()
+        self.kind
     }
 }
 
-#[cfg(feature = "alloc")]
-impl Display for Error {
+impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.description().fmt(f)
+        self.kind.fmt(f)
     }
 }
 
-#[cfg(feature = "alloc")]
-impl StdError for Error {
-    fn description(&self) -> &str {
-        if let Some(ref desc) = self.description {
-            desc
-        } else {
-            "(none)"
-        }
-    }
-}
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
 
 impl From<ErrorKind> for Error {
     fn from(kind: ErrorKind) -> Error {
         Error {
-            inner: Context::new(kind),
-            #[cfg(feature = "alloc")]
-            description: None,
-        }
-    }
-}
-
-impl From<Context<ErrorKind>> for Error {
-    fn from(inner: Context<ErrorKind>) -> Self {
-        Self {
-            inner,
+            kind,
             #[cfg(feature = "alloc")]
             description: None,
         }
     }
 }
 
 /// Kinds of errors
-#[derive(Copy, Clone, Debug, Fail, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum ErrorKind {
     /// Invalid address
-    #[fail(display = "address invalid")]
     AddrInvalid,
 
     /// I/O operation failed
-    #[fail(display = "I/O error")]
     IoError,
 
     /// Parsing data failed
-    #[fail(display = "parse error")]
     ParseError,
 
     /// Request failed
-    #[fail(display = "request error")]
     RequestError,
 
     /// Error reading response
-    #[fail(display = "error reading response")]
     ResponseError,
 }
 
+impl fmt::Display for ErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let description = match self {
+            ErrorKind::AddrInvalid => "address invalid",
+            ErrorKind::IoError => "I/O error",
+            ErrorKind::ParseError => "parse error",
+            ErrorKind::RequestError => "request error",
+            ErrorKind::ResponseError => "error reading response",
+        };
+
+        write!(f, "{}", description)
+    }
+}
+
 /// Create a new error (of a given enum variant) with a formatted message
 macro_rules! err {
     ($variant:ident, $msg:expr) => {

gaunt/src/error.rs

@@ -1,23 +1,20 @@
 //! **gaunt.rs**: high-level, self-contained, minimalist HTTP toolkit.
 
-#![crate_name = "gaunt"]
-#![crate_type = "rlib"]
-#![deny(warnings, missing_docs, unused_import_braces, unused_qualifications)]
 #![no_std]
-#![cfg_attr(all(feature = "nightly", not(feature = "std")), feature(alloc))]
+#![deny(warnings, missing_docs, unused_import_braces, unused_qualifications)]
 #![forbid(unsafe_code)]
 #![doc(
     html_logo_url = "https://storage.googleapis.com/iqlusion-production-web/github/gaunt/gaunt-logo.svg",
     html_root_url = "https://docs.rs/gaunt/0.1.0"
 )]
 
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
 #[cfg(any(feature = "std", test))]
 #[macro_use]
 extern crate std;
 
-extern crate failure;
-#[macro_use]
-extern crate failure_derive;
 #[cfg(feature = "logger")]
 #[macro_use]
 extern crate slog;
@@ -28,7 +25,6 @@ pub mod error;
 #[cfg(feature = "std")]
 pub mod connection;
 pub mod path;
-pub mod prelude;
 #[cfg(feature = "alloc")]
 pub mod request;
 #[cfg(feature = "alloc")]

gaunt/src/lib.rs

@@ -2,7 +2,8 @@
 
 #[cfg(feature = "alloc")]
 use {
-    crate::{error::Error, prelude::*},
+    crate::error::Error,
+    alloc::{borrow::ToOwned, string::String},
     core::{
         fmt::{self, Display},
         str::FromStr,

gaunt/src/path.rs

@@ -1,6 +1,6 @@
 //! HTTP request types
 
-use crate::prelude::*;
+use alloc::vec::Vec;
 
 /// Request bodies
 #[derive(Debug, Default)]

gaunt/src/prelude.rs

@@ -1,7 +1,7 @@
 //! Response body types.
 // TODO: support for streaming response bodies
 
-use crate::prelude::*;
+use alloc::vec::Vec;
 
 /// Response body
 #[derive(Debug)]

gaunt/src/request.rs

@@ -1,8 +1,6 @@
 //! Read HTTP responses from an `io::Read`
 
-use crate::prelude::*;
-
-use std::{io::Read, str};
+use std::{io::Read, str, vec::Vec};
 
 use super::Body;
 use crate::error::Error;