Update nitrokey crate to 0.2.3

This change updates the nitrokey crate to version 0.2.3. This version
bumps the rand crate used to 0.6.1, which in turn requires an additional
set of dependencies.

Import subrepo nitrokey/:nitrokey at b3e2adc5bb1300441ca74cc7672617c042f3ea31
Import subrepo rand/:rand at 73613ff903512e9503e41cc8ba9eae76269dc598
Import subrepo rustc_version/:rustc_version at 0294f2ba2018bf7be672abd53db351ce5055fa02
Import subrepo semver-parser/:semver-parser at 750da9b11a04125231b1fb293866ca036845acee
Import subrepo semver/:semver at 5eb6db94fa03f4d5c64a625a56188f496be47598

12 files changed, 2355 insertions, 0 deletions

diff --git a/semver/.gitignore b/semver/.gitignore
new file mode 100644
index 0000000..cc3b589
--- /dev/null
+++ b/semver/.gitignore
@@ -0,0 +1,3 @@
+target/
+*.sw?
+Cargo.lock
diff --git a/semver/.travis.yml b/semver/.travis.yml
new file mode 100644
index 0000000..bb4ba27
--- /dev/null
+++ b/semver/.travis.yml
@@ -0,0 +1,18 @@
+language: rust
+rust:
+  - nightly
+  - beta
+  - stable
+sudo: false
+script:
+  - cargo build --verbose
+  - cargo test --verbose --features ci
+addons:
+  apt:
+    sources:
+      - kalakris-cmake
+    packages:
+      - cmake
+notifications:
+  email:
+    on_success: never
diff --git a/semver/Cargo.toml b/semver/Cargo.toml
new file mode 100644
index 0000000..1a31f59
--- /dev/null
+++ b/semver/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+
+name = "semver"
+version = "0.9.0"
+authors = ["Steve Klabnik <steve@steveklabnik.com>", "The Rust Project Developers"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/steveklabnik/semver"
+homepage = "https://docs.rs/crate/semver/"
+documentation = "https://docs.rs/crate/semver/"
+description = """
+Semantic version parsing and comparison.
+"""
+readme = "README.md"
+
+[badges]
+travis-ci = { repository = "steveklabnik/semver" }
+
+[dependencies]
+semver-parser = "0.7.0"
+serde = { version = "1.0", optional = true }
+
+[features]
+default = []
+
+# are we testing on CI?
+ci = ["serde"]
+
+[dev-dependencies]
+crates-index = "0.5.0"
+tempdir = "0.3.4"
+serde_json = "1.0"
+serde_derive = "1.0"
diff --git a/semver/LICENSE-APACHE b/semver/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/semver/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/semver/LICENSE-MIT b/semver/LICENSE-MIT
new file mode 100644
index 0000000..39d4bdb
--- /dev/null
+++ b/semver/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/semver/README.md b/semver/README.md
new file mode 100644
index 0000000..2a5306d
--- /dev/null
+++ b/semver/README.md
@@ -0,0 +1,103 @@
+semver
+======
+
+Semantic version parsing and comparison.
+
+[![Build Status](https://api.travis-ci.org/steveklabnik/semver.svg?branch=master)](https://travis-ci.org/steveklabnik/semver)
+
+[Documentation](https://steveklabnik.github.io/semver)
+
+Semantic versioning (see http://semver.org/) is a set of rules for
+assigning version numbers.
+
+## SemVer and the Rust ecosystem
+
+Rust itself follows the SemVer specification, as does its standard libraries. The two are
+not tied together.
+
+[Cargo](https://crates.io), Rust's package manager, uses SemVer to determine which versions of
+packages you need installed.
+
+## Installation
+
+To use `semver`, add this to your `[dependencies]` section:
+
+```toml
+semver = "0.7.0"
+```
+
+And this to your crate root:
+
+```rust
+extern crate semver;
+```
+
+## Versions
+
+At its simplest, the `semver` crate allows you to construct `Version` objects using the `parse`
+method:
+
+```rust
+use semver::Version;
+
+assert!(Version::parse("1.2.3") == Ok(Version {
+   major: 1,
+   minor: 2,
+   patch: 3,
+   pre: vec!(),
+   build: vec!(),
+}));
+```
+
+If you have multiple `Version`s, you can use the usual comparison operators to compare them:
+
+```rust
+use semver::Version;
+
+assert!(Version::parse("1.2.3-alpha")  != Version::parse("1.2.3-beta"));
+assert!(Version::parse("1.2.3-alpha2") >  Version::parse("1.2.0"));
+```
+
+## Requirements
+
+The `semver` crate also provides the ability to compare requirements, which are more complex
+comparisons.
+
+For example, creating a requirement that only matches versions greater than or
+equal to 1.0.0:
+
+```rust
+use semver::Version;
+use semver::VersionReq;
+
+let r = VersionReq::parse(">= 1.0.0").unwrap();
+let v = Version::parse("1.0.0").unwrap();
+
+assert!(r.to_string() == ">= 1.0.0".to_string());
+assert!(r.matches(&v))
+```
+
+It also allows parsing of `~x.y.z` and `^x.y.z` requirements as defined at
+https://www.npmjs.org/doc/misc/semver.html
+
+**Tilde requirements** specify a minimal version with some updates:
+
+```notrust
+~1.2.3 := >=1.2.3 <1.3.0
+~1.2   := >=1.2.0 <1.3.0
+~1     := >=1.0.0 <2.0.0
+```
+
+**Caret requirements** allow SemVer compatible updates to a specified version,
+`0.x` and `0.x+1` are not considered compatible, but `1.x` and `1.x+1` are.
+
+`0.0.x` is not considered compatible with any other version.
+Missing minor and patch versions are desugared to `0` but allow flexibility for that value.
+
+```notrust
+^1.2.3 := >=1.2.3 <2.0.0
+^0.2.3 := >=0.2.3 <0.3.0
+^0.0.3 := >=0.0.3 <0.0.4
+^0.0   := >=0.0.0 <0.1.0
+^0     := >=0.0.0 <1.0.0
+```
diff --git a/semver/src/lib.rs b/semver/src/lib.rs
new file mode 100644
index 0000000..a38aae0
--- /dev/null
+++ b/semver/src/lib.rs
@@ -0,0 +1,182 @@
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Semantic version parsing and comparison.
+//!
+//! Semantic versioning (see http://semver.org/) is a set of rules for
+//! assigning version numbers.
+//!
+//! ## SemVer overview
+//!
+//! Given a version number MAJOR.MINOR.PATCH, increment the:
+//!
+//! 1. MAJOR version when you make incompatible API changes,
+//! 2. MINOR version when you add functionality in a backwards-compatible
+//!    manner, and
+//! 3. PATCH version when you make backwards-compatible bug fixes.
+//!
+//! Additional labels for pre-release and build metadata are available as
+//! extensions to the MAJOR.MINOR.PATCH format.
+//!
+//! Any references to 'the spec' in this documentation refer to [version 2.0 of
+//! the SemVer spec](http://semver.org/spec/v2.0.0.html).
+//!
+//! ## SemVer and the Rust ecosystem
+//!
+//! Rust itself follows the SemVer specification, as does its standard
+//! libraries. The two are not tied together.
+//!
+//! [Cargo](http://crates.io), Rust's package manager, uses SemVer to determine
+//! which versions of packages you need installed.
+//!
+//! ## Versions
+//!
+//! At its simplest, the `semver` crate allows you to construct `Version`
+//! objects using the `parse` method:
+//!
+//! ```{rust}
+//! use semver::Version;
+//!
+//! assert!(Version::parse("1.2.3") == Ok(Version {
+//!    major: 1,
+//!    minor: 2,
+//!    patch: 3,
+//!    pre: vec!(),
+//!    build: vec!(),
+//! }));
+//! ```
+//!
+//! If you have multiple `Version`s, you can use the usual comparison operators
+//! to compare them:
+//!
+//! ```{rust}
+//! use semver::Version;
+//!
+//! assert!(Version::parse("1.2.3-alpha") != Version::parse("1.2.3-beta"));
+//! assert!(Version::parse("1.2.3-alpha2") >  Version::parse("1.2.0"));
+//! ```
+//!
+//! If you explicitly need to modify a Version, SemVer also allows you to
+//! increment the major, minor, and patch numbers in accordance with the spec.
+//!
+//! Please note that in order to do this, you must use a mutable Version:
+//!
+//! ```{rust}
+//! use semver::Version;
+//!
+//! let mut bugfix_release = Version::parse("1.0.0").unwrap();
+//! bugfix_release.increment_patch();
+//!
+//! assert_eq!(Ok(bugfix_release), Version::parse("1.0.1"));
+//! ```
+//!
+//! When incrementing the minor version number, the patch number resets to zero
+//! (in accordance with section 7 of the spec)
+//!
+//! ```{rust}
+//! use semver::Version;
+//!
+//! let mut feature_release = Version::parse("1.4.6").unwrap();
+//! feature_release.increment_minor();
+//!
+//! assert_eq!(Ok(feature_release), Version::parse("1.5.0"));
+//! ```
+//!
+//! Similarly, when incrementing the major version number, the patch and minor
+//! numbers reset to zero (in accordance with section 8 of the spec)
+//!
+//! ```{rust}
+//! use semver::Version;
+//!
+//! let mut chrome_release = Version::parse("41.5.5377").unwrap();
+//! chrome_release.increment_major();
+//!
+//! assert_eq!(Ok(chrome_release), Version::parse("42.0.0"));
+//! ```
+//!
+//! ## Requirements
+//!
+//! The `semver` crate also provides the ability to compare requirements, which
+//! are more complex comparisons.
+//!
+//! For example, creating a requirement that only matches versions greater than
+//! or equal to 1.0.0:
+//!
+//! ```{rust}
+//! # #![allow(unstable)]
+//! use semver::Version;
+//! use semver::VersionReq;
+//!
+//! let r = VersionReq::parse(">= 1.0.0").unwrap();
+//! let v = Version::parse("1.0.0").unwrap();
+//!
+//! assert!(r.to_string() == ">= 1.0.0".to_string());
+//! assert!(r.matches(&v))
+//! ```
+//!
+//! It also allows parsing of `~x.y.z` and `^x.y.z` requirements as defined at
+//! https://www.npmjs.org/doc/misc/semver.html
+//!
+//! **Tilde requirements** specify a minimal version with some updates:
+//!
+//! ```notrust
+//! ~1.2.3 := >=1.2.3 <1.3.0
+//! ~1.2   := >=1.2.0 <1.3.0
+//! ~1     := >=1.0.0 <2.0.0
+//! ```
+//!
+//! **Caret requirements** allow SemVer compatible updates to a specified
+//! verion, `0.x` and `0.x+1` are not considered compatible, but `1.x` and
+//! `1.x+1` are.
+//!
+//! `0.0.x` is not considered compatible with any other version.
+//! Missing minor and patch versions are desugared to `0` but allow flexibility
+//! for that value.
+//!
+//! ```notrust
+//! ^1.2.3 := >=1.2.3 <2.0.0
+//! ^0.2.3 := >=0.2.3 <0.3.0
+//! ^0.0.3 := >=0.0.3 <0.0.4
+//! ^0.0   := >=0.0.0 <0.1.0
+//! ^0     := >=0.0.0 <1.0.0
+//! ```
+//!
+//! **Wildcard requirements** allows parsing of version requirements of the
+//! formats `*`, `x.*` and `x.y.*`.
+//!
+//! ```notrust
+//! *     := >=0.0.0
+//! 1.*   := >=1.0.0 <2.0.0
+//! 1.2.* := >=1.2.0 <1.3.0
+//! ```
+
+#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+       html_favicon_url = "https://www.rust-lang.org/favicon.ico")]
+#![deny(missing_docs)]
+#![cfg_attr(test, deny(warnings))]
+
+extern crate semver_parser;
+
+// Serialization and deserialization support for version numbers
+#[cfg(feature = "serde")]
+extern crate serde;
+
+// We take the common approach of keeping our own module system private, and
+// just re-exporting the interface that we want.
+
+pub use version::{Version, Identifier, SemVerError};
+pub use version::Identifier::{Numeric, AlphaNumeric};
+pub use version_req::{VersionReq, ReqParseError};
+
+// SemVer-compliant versions.
+mod version;
+
+// advanced version comparisons
+mod version_req;
diff --git a/semver/src/version.rs b/semver/src/version.rs
new file mode 100644
index 0000000..38de133
--- /dev/null
+++ b/semver/src/version.rs
@@ -0,0 +1,759 @@
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The `version` module gives you tools to create and compare SemVer-compliant
+//! versions.
+
+use std::cmp::{self, Ordering};
+use std::fmt;
+use std::hash;
+use std::error::Error;
+
+use std::result;
+use std::str;
+
+use semver_parser;
+
+#[cfg(feature = "serde")]
+use serde::ser::{Serialize, Serializer};
+#[cfg(feature = "serde")]
+use serde::de::{self, Deserialize, Deserializer, Visitor};
+
+/// An identifier in the pre-release or build metadata.
+///
+/// See sections 9 and 10 of the spec for more about pre-release identifers and
+/// build metadata.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Identifier {
+    /// An identifier that's solely numbers.
+    Numeric(u64),
+    /// An identifier with letters and numbers.
+    AlphaNumeric(String),
+}
+
+impl From<semver_parser::version::Identifier> for Identifier {
+    fn from(other: semver_parser::version::Identifier) -> Identifier {
+        match other {
+            semver_parser::version::Identifier::Numeric(n) => Identifier::Numeric(n),
+            semver_parser::version::Identifier::AlphaNumeric(s) => Identifier::AlphaNumeric(s),
+        }
+    }
+}
+
+impl fmt::Display for Identifier {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Identifier::Numeric(ref n) => fmt::Display::fmt(n, f),
+            Identifier::AlphaNumeric(ref s) => fmt::Display::fmt(s, f),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Identifier {
+    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        // Serialize Identifier as a number or string.
+        match *self {
+            Identifier::Numeric(n) => serializer.serialize_u64(n),
+            Identifier::AlphaNumeric(ref s) => serializer.serialize_str(s),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Identifier {
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        struct IdentifierVisitor;
+
+        // Deserialize Identifier from a number or string.
+        impl<'de> Visitor<'de> for IdentifierVisitor {
+            type Value = Identifier;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a SemVer pre-release or build identifier")
+            }
+
+            fn visit_u64<E>(self, numeric: u64) -> result::Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok(Identifier::Numeric(numeric))
+            }
+
+            fn visit_str<E>(self, alphanumeric: &str) -> result::Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok(Identifier::AlphaNumeric(alphanumeric.to_owned()))
+            }
+        }
+
+        deserializer.deserialize_any(IdentifierVisitor)
+    }
+}
+
+/// Represents a version number conforming to the semantic versioning scheme.
+#[derive(Clone, Eq, Debug)]
+pub struct Version {
+    /// The major version, to be incremented on incompatible changes.
+    pub major: u64,
+    /// The minor version, to be incremented when functionality is added in a
+    /// backwards-compatible manner.
+    pub minor: u64,
+    /// The patch version, to be incremented when backwards-compatible bug
+    /// fixes are made.
+    pub patch: u64,
+    /// The pre-release version identifier, if one exists.
+    pub pre: Vec<Identifier>,
+    /// The build metadata, ignored when determining version precedence.
+    pub build: Vec<Identifier>,
+}
+
+impl From<semver_parser::version::Version> for Version {
+    fn from(other: semver_parser::version::Version) -> Version {
+        Version {
+            major: other.major,
+            minor: other.minor,
+            patch: other.patch,
+            pre: other.pre.into_iter().map(From::from).collect(),
+            build: other.build.into_iter().map(From::from).collect(),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Version {
+    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        // Serialize Version as a string.
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Version {
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        struct VersionVisitor;
+
+        // Deserialize Version from a string.
+        impl<'de> Visitor<'de> for VersionVisitor {
+            type Value = Version;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a SemVer version as a string")
+            }
+
+            fn visit_str<E>(self, v: &str) -> result::Result<Self::Value, E>
+                where E: de::Error
+            {
+                Version::parse(v).map_err(de::Error::custom)
+            }
+        }
+
+        deserializer.deserialize_str(VersionVisitor)
+    }
+}
+
+/// An error type for this crate
+///
+/// Currently, just a generic error. Will make this nicer later.
+#[derive(Clone,PartialEq,Debug,PartialOrd)]
+pub enum SemVerError {
+    /// An error ocurred while parsing.
+    ParseError(String),
+}
+
+impl fmt::Display for SemVerError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            &SemVerError::ParseError(ref m) => write!(f, "{}", m),
+        }
+    }
+}
+
+impl Error for SemVerError {
+    fn description(&self) -> &str {
+        match self {
+            &SemVerError::ParseError(ref m) => m,
+        }
+    }
+}
+
+/// A Result type for errors
+pub type Result<T> = result::Result<T, SemVerError>;
+
+impl Version {
+
+    /// Contructs the simple case without pre or build.
+    pub fn new(major: u64, minor: u64, patch: u64) -> Version {
+        Version {
+            major: major,
+            minor: minor,
+            patch: patch,
+            pre: Vec::new(),
+            build: Vec::new()
+        }
+    }
+
+    /// Parse a string into a semver object.
+    pub fn parse(version: &str) -> Result<Version> {
+        let res = semver_parser::version::parse(version);
+
+        match res {
+            // Convert plain String error into proper ParseError
+            Err(e) => Err(SemVerError::ParseError(e)),
+            Ok(v) => Ok(From::from(v)),
+        }
+    }
+
+    /// Clears the build metadata
+    fn clear_metadata(&mut self) {
+        self.build = Vec::new();
+        self.pre = Vec::new();
+    }
+
+    /// Increments the patch number for this Version (Must be mutable)
+    pub fn increment_patch(&mut self) {
+        self.patch += 1;
+        self.clear_metadata();
+    }
+
+    /// Increments the minor version number for this Version (Must be mutable)
+    ///
+    /// As instructed by section 7 of the spec, the patch number is reset to 0.
+    pub fn increment_minor(&mut self) {
+        self.minor += 1;
+        self.patch = 0;
+        self.clear_metadata();
+    }
+
+    /// Increments the major version number for this Version (Must be mutable)
+    ///
+    /// As instructed by section 8 of the spec, the minor and patch numbers are
+    /// reset to 0
+    pub fn increment_major(&mut self) {
+        self.major += 1;
+        self.minor = 0;
+        self.patch = 0;
+        self.clear_metadata();
+    }
+
+    /// Checks to see if the current Version is in pre-release status
+    pub fn is_prerelease(&self) -> bool {
+        !self.pre.is_empty()
+    }
+}
+
+impl str::FromStr for Version {
+    type Err = SemVerError;
+
+    fn from_str(s: &str) -> Result<Version> {
+        Version::parse(s)
+    }
+}
+
+impl fmt::Display for Version {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        try!(write!(f, "{}.{}.{}", self.major, self.minor, self.patch));
+        if !self.pre.is_empty() {
+            try!(write!(f, "-"));
+            for (i, x) in self.pre.iter().enumerate() {
+                if i != 0 {
+                    try!(write!(f, "."))
+                }
+                try!(write!(f, "{}", x));
+            }
+        }
+        if !self.build.is_empty() {
+            try!(write!(f, "+"));
+            for (i, x) in self.build.iter().enumerate() {
+                if i != 0 {
+                    try!(write!(f, "."))
+                }
+                try!(write!(f, "{}", x));
+            }
+        }
+        Ok(())
+    }
+}
+
+impl cmp::PartialEq for Version {
+    #[inline]
+    fn eq(&self, other: &Version) -> bool {
+        // We should ignore build metadata here, otherwise versions v1 and v2
+        // can exist such that !(v1 < v2) && !(v1 > v2) && v1 != v2, which
+        // violate strict total ordering rules.
+        self.major == other.major && self.minor == other.minor && self.patch == other.patch &&
+        self.pre == other.pre
+    }
+}
+
+impl cmp::PartialOrd for Version {
+    fn partial_cmp(&self, other: &Version) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl cmp::Ord for Version {
+    fn cmp(&self, other: &Version) -> Ordering {
+        match self.major.cmp(&other.major) {
+            Ordering::Equal => {}
+            r => return r,
+        }
+
+        match self.minor.cmp(&other.minor) {
+            Ordering::Equal => {}
+            r => return r,
+        }
+
+        match self.patch.cmp(&other.patch) {
+            Ordering::Equal => {}
+            r => return r,
+        }
+
+        // NB: semver spec says 0.0.0-pre < 0.0.0
+        // but the version of ord defined for vec
+        // says that [] < [pre] so we alter it here
+        match (self.pre.len(), other.pre.len()) {
+            (0, 0) => Ordering::Equal,
+            (0, _) => Ordering::Greater,
+            (_, 0) => Ordering::Less,
+            (_, _) => self.pre.cmp(&other.pre),
+        }
+    }
+}
+
+impl hash::Hash for Version {
+    fn hash<H: hash::Hasher>(&self, into: &mut H) {
+        self.major.hash(into);
+        self.minor.hash(into);
+        self.patch.hash(into);
+        self.pre.hash(into);
+    }
+}
+
+impl From<(u64,u64,u64)> for Version {
+    fn from(tuple: (u64,u64,u64)) -> Version {
+        let (major, minor, patch) = tuple;
+        Version::new(major, minor, patch)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::result;
+    use super::Version;
+    use super::Identifier;
+    use super::SemVerError;
+
+    #[test]
+    fn test_parse() {
+        fn parse_error(e: &str) -> result::Result<Version, SemVerError> {
+            return Err(SemVerError::ParseError(e.to_string()));
+        }
+
+        assert_eq!(Version::parse(""),
+                   parse_error("Error parsing major identifier"));
+        assert_eq!(Version::parse("  "),
+                   parse_error("Error parsing major identifier"));
+        assert_eq!(Version::parse("1"),
+                   parse_error("Expected dot"));
+        assert_eq!(Version::parse("1.2"),
+                   parse_error("Expected dot"));
+        assert_eq!(Version::parse("1.2.3-"),
+                   parse_error("Error parsing prerelease"));
+        assert_eq!(Version::parse("a.b.c"),
+                   parse_error("Error parsing major identifier"));
+        assert_eq!(Version::parse("1.2.3 abc"),
+                   parse_error("Extra junk after valid version:  abc"));
+
+        assert_eq!(Version::parse("1.2.3"),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: Vec::new(),
+                   }));
+
+        assert_eq!(Version::parse("1.2.3"),
+                   Ok(Version::new(1,2,3)));
+
+        assert_eq!(Version::parse("  1.2.3  "),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: Vec::new(),
+                   }));
+        assert_eq!(Version::parse("1.2.3-alpha1"),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: Vec::new(),
+                   }));
+        assert_eq!(Version::parse("  1.2.3-alpha1  "),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: Vec::new(),
+                   }));
+        assert_eq!(Version::parse("1.2.3+build5"),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!(Version::parse("  1.2.3+build5  "),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!(Version::parse("1.2.3-alpha1+build5"),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!(Version::parse("  1.2.3-alpha1+build5  "),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!(Version::parse("1.2.3-1.alpha1.9+build5.7.3aedf  "),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::Numeric(1),
+                      Identifier::AlphaNumeric(String::from("alpha1")),
+                      Identifier::Numeric(9),
+            ],
+                       build: vec![Identifier::AlphaNumeric(String::from("build5")),
+                        Identifier::Numeric(7),
+                        Identifier::AlphaNumeric(String::from("3aedf")),
+            ],
+                   }));
+        assert_eq!(Version::parse("0.4.0-beta.1+0851523"),
+                   Ok(Version {
+                       major: 0,
+                       minor: 4,
+                       patch: 0,
+                       pre: vec![Identifier::AlphaNumeric(String::from("beta")),
+                      Identifier::Numeric(1),
+            ],
+                       build: vec![Identifier::AlphaNumeric(String::from("0851523"))],
+                   }));
+
+    }
+
+    #[test]
+    fn test_increment_patch() {
+        let mut buggy_release = Version::parse("0.1.0").unwrap();
+        buggy_release.increment_patch();
+        assert_eq!(buggy_release, Version::parse("0.1.1").unwrap());
+    }
+
+    #[test]
+    fn test_increment_minor() {
+        let mut feature_release = Version::parse("1.4.6").unwrap();
+        feature_release.increment_minor();
+        assert_eq!(feature_release, Version::parse("1.5.0").unwrap());
+    }
+
+    #[test]
+    fn test_increment_major() {
+        let mut chrome_release = Version::parse("46.1.246773").unwrap();
+        chrome_release.increment_major();
+        assert_eq!(chrome_release, Version::parse("47.0.0").unwrap());
+    }
+
+    #[test]
+    fn test_increment_keep_prerelease() {
+        let mut release = Version::parse("1.0.0-alpha").unwrap();
+        release.increment_patch();
+
+        assert_eq!(release, Version::parse("1.0.1").unwrap());
+
+        release.increment_minor();
+
+        assert_eq!(release, Version::parse("1.1.0").unwrap());
+
+        release.increment_major();
+
+        assert_eq!(release, Version::parse("2.0.0").unwrap());
+    }
+
+
+    #[test]
+    fn test_increment_clear_metadata() {
+        let mut release = Version::parse("1.0.0+4442").unwrap();
+        release.increment_patch();
+
+        assert_eq!(release, Version::parse("1.0.1").unwrap());
+        release = Version::parse("1.0.1+hello").unwrap();
+
+        release.increment_minor();
+
+        assert_eq!(release, Version::parse("1.1.0").unwrap());
+        release = Version::parse("1.1.3747+hello").unwrap();
+
+        release.increment_major();
+
+        assert_eq!(release, Version::parse("2.0.0").unwrap());
+    }
+
+    #[test]
+    fn test_eq() {
+        assert_eq!(Version::parse("1.2.3"), Version::parse("1.2.3"));
+        assert_eq!(Version::parse("1.2.3-alpha1"),
+                   Version::parse("1.2.3-alpha1"));
+        assert_eq!(Version::parse("1.2.3+build.42"),
+                   Version::parse("1.2.3+build.42"));
+        assert_eq!(Version::parse("1.2.3-alpha1+42"),
+                   Version::parse("1.2.3-alpha1+42"));
+        assert_eq!(Version::parse("1.2.3+23"), Version::parse("1.2.3+42"));
+    }
+
+    #[test]
+    fn test_ne() {
+        assert!(Version::parse("0.0.0") != Version::parse("0.0.1"));
+        assert!(Version::parse("0.0.0") != Version::parse("0.1.0"));
+        assert!(Version::parse("0.0.0") != Version::parse("1.0.0"));
+        assert!(Version::parse("1.2.3-alpha") != Version::parse("1.2.3-beta"));
+    }
+
+    #[test]
+    fn test_show() {
+        assert_eq!(format!("{}", Version::parse("1.2.3").unwrap()),
+                   "1.2.3".to_string());
+        assert_eq!(format!("{}", Version::parse("1.2.3-alpha1").unwrap()),
+                   "1.2.3-alpha1".to_string());
+        assert_eq!(format!("{}", Version::parse("1.2.3+build.42").unwrap()),
+                   "1.2.3+build.42".to_string());
+        assert_eq!(format!("{}", Version::parse("1.2.3-alpha1+42").unwrap()),
+                   "1.2.3-alpha1+42".to_string());
+    }
+
+    #[test]
+    fn test_to_string() {
+        assert_eq!(Version::parse("1.2.3").unwrap().to_string(),
+                   "1.2.3".to_string());
+        assert_eq!(Version::parse("1.2.3-alpha1").unwrap().to_string(),
+                   "1.2.3-alpha1".to_string());
+        assert_eq!(Version::parse("1.2.3+build.42").unwrap().to_string(),
+                   "1.2.3+build.42".to_string());
+        assert_eq!(Version::parse("1.2.3-alpha1+42").unwrap().to_string(),
+                   "1.2.3-alpha1+42".to_string());
+    }
+
+    #[test]
+    fn test_lt() {
+        assert!(Version::parse("0.0.0") < Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.0.0") < Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.2.0") < Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.2.3-alpha1") < Version::parse("1.2.3"));
+        assert!(Version::parse("1.2.3-alpha1") < Version::parse("1.2.3-alpha2"));
+        assert!(!(Version::parse("1.2.3-alpha2") < Version::parse("1.2.3-alpha2")));
+        assert!(!(Version::parse("1.2.3+23") < Version::parse("1.2.3+42")));
+    }
+
+    #[test]
+    fn test_le() {
+        assert!(Version::parse("0.0.0") <= Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.0.0") <= Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.2.0") <= Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.2.3-alpha1") <= Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.2.3-alpha2") <= Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.2.3+23") <= Version::parse("1.2.3+42"));
+    }
+
+    #[test]
+    fn test_gt() {
+        assert!(Version::parse("1.2.3-alpha2") > Version::parse("0.0.0"));
+        assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.0.0"));
+        assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.0"));
+        assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.3-alpha1"));
+        assert!(Version::parse("1.2.3") > Version::parse("1.2.3-alpha2"));
+        assert!(!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.3-alpha2")));
+        assert!(!(Version::parse("1.2.3+23") > Version::parse("1.2.3+42")));
+    }
+
+    #[test]
+    fn test_ge() {
+        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("0.0.0"));
+        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.0.0"));
+        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.0"));
+        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.3-alpha1"));
+        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.3-alpha2"));
+        assert!(Version::parse("1.2.3+23") >= Version::parse("1.2.3+42"));
+    }
+
+    #[test]
+    fn test_prerelease_check() {
+        assert!(Version::parse("1.0.0").unwrap().is_prerelease() == false);
+        assert!(Version::parse("0.0.1").unwrap().is_prerelease() == false);
+        assert!(Version::parse("4.1.4-alpha").unwrap().is_prerelease());
+        assert!(Version::parse("1.0.0-beta294296").unwrap().is_prerelease());
+    }
+
+    #[test]
+    fn test_spec_order() {
+        let vs = ["1.0.0-alpha",
+                  "1.0.0-alpha.1",
+                  "1.0.0-alpha.beta",
+                  "1.0.0-beta",
+                  "1.0.0-beta.2",
+                  "1.0.0-beta.11",
+                  "1.0.0-rc.1",
+                  "1.0.0"];
+        let mut i = 1;
+        while i < vs.len() {
+            let a = Version::parse(vs[i - 1]);
+            let b = Version::parse(vs[i]);
+            assert!(a < b, "nope {:?} < {:?}", a, b);
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn test_from_str() {
+        assert_eq!("1.2.3".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: Vec::new(),
+                   }));
+        assert_eq!("  1.2.3  ".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: Vec::new(),
+                   }));
+        assert_eq!("1.2.3-alpha1".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: Vec::new(),
+                   }));
+        assert_eq!("  1.2.3-alpha1  ".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: Vec::new(),
+                   }));
+        assert_eq!("1.2.3+build5".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!("  1.2.3+build5  ".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: Vec::new(),
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!("1.2.3-alpha1+build5".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!("  1.2.3-alpha1+build5  ".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
+                       build: vec![Identifier::AlphaNumeric(String::from("build5"))],
+                   }));
+        assert_eq!("1.2.3-1.alpha1.9+build5.7.3aedf  ".parse(),
+                   Ok(Version {
+                       major: 1,
+                       minor: 2,
+                       patch: 3,
+                       pre: vec![Identifier::Numeric(1),
+                      Identifier::AlphaNumeric(String::from("alpha1")),
+                      Identifier::Numeric(9),
+            ],
+                       build: vec![Identifier::AlphaNumeric(String::from("build5")),
+                        Identifier::Numeric(7),
+                        Identifier::AlphaNumeric(String::from("3aedf")),
+            ],
+                   }));
+        assert_eq!("0.4.0-beta.1+0851523".parse(),
+                   Ok(Version {
+                       major: 0,
+                       minor: 4,
+                       patch: 0,
+                       pre: vec![Identifier::AlphaNumeric(String::from("beta")),
+                      Identifier::Numeric(1),
+            ],
+                       build: vec![Identifier::AlphaNumeric(String::from("0851523"))],
+                   }));
+
+    }
+
+    #[test]
+    fn test_from_str_errors() {
+        fn parse_error(e: &str) -> result::Result<Version, SemVerError> {
+            return Err(SemVerError::ParseError(e.to_string()));
+        }
+
+        assert_eq!("".parse(), parse_error("Error parsing major identifier"));
+        assert_eq!("  ".parse(), parse_error("Error parsing major identifier"));
+        assert_eq!("1".parse(), parse_error("Expected dot"));
+        assert_eq!("1.2".parse(),
+                   parse_error("Expected dot"));
+        assert_eq!("1.2.3-".parse(),
+                   parse_error("Error parsing prerelease"));
+        assert_eq!("a.b.c".parse(),
+                   parse_error("Error parsing major identifier"));
+        assert_eq!("1.2.3 abc".parse(),
+                   parse_error("Extra junk after valid version:  abc"));
+    }
+}
diff --git a/semver/src/version_req.rs b/semver/src/version_req.rs
new file mode 100644
index 0000000..6e6a542
--- /dev/null
+++ b/semver/src/version_req.rs
@@ -0,0 +1,895 @@
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::error::Error;
+use std::fmt;
+use std::result;
+use std::str;
+
+use Version;
+use version::Identifier;
+use semver_parser;
+
+#[cfg(feature = "serde")]
+use serde::ser::{Serialize, Serializer};
+#[cfg(feature = "serde")]
+use serde::de::{self, Deserialize, Deserializer, Visitor};
+
+use self::Op::{Ex, Gt, GtEq, Lt, LtEq, Tilde, Compatible, Wildcard};
+use self::WildcardVersion::{Major, Minor, Patch};
+use self::ReqParseError::*;
+
+/// A `VersionReq` is a struct containing a list of predicates that can apply to ranges of version
+/// numbers. Matching operations can then be done with the `VersionReq` against a particular
+/// version to see if it satisfies some or all of the constraints.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub struct VersionReq {
+    predicates: Vec<Predicate>,
+}
+
+impl From<semver_parser::range::VersionReq> for VersionReq {
+    fn from(other: semver_parser::range::VersionReq) -> VersionReq {
+        VersionReq { predicates: other.predicates.into_iter().map(From::from).collect() }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for VersionReq {
+    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        // Serialize VersionReq as a string.
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for VersionReq {
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        struct VersionReqVisitor;
+
+        /// Deserialize `VersionReq` from a string.
+        impl<'de> Visitor<'de> for VersionReqVisitor {
+            type Value = VersionReq;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a SemVer version requirement as a string")
+            }
+
+            fn visit_str<E>(self, v: &str) -> result::Result<Self::Value, E>
+                where E: de::Error
+            {
+                VersionReq::parse(v).map_err(de::Error::custom)
+            }
+        }
+
+        deserializer.deserialize_str(VersionReqVisitor)
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+enum WildcardVersion {
+    Major,
+    Minor,
+    Patch,
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+enum Op {
+    Ex, // Exact
+    Gt, // Greater than
+    GtEq, // Greater than or equal to
+    Lt, // Less than
+    LtEq, // Less than or equal to
+    Tilde, // e.g. ~1.0.0
+    Compatible, // compatible by definition of semver, indicated by ^
+    Wildcard(WildcardVersion), // x.y.*, x.*, *
+}
+
+impl From<semver_parser::range::Op> for Op {
+    fn from(other: semver_parser::range::Op) -> Op {
+        use semver_parser::range;
+        match other {
+            range::Op::Ex => Op::Ex,
+            range::Op::Gt => Op::Gt,
+            range::Op::GtEq => Op::GtEq,
+            range::Op::Lt => Op::Lt,
+            range::Op::LtEq => Op::LtEq,
+            range::Op::Tilde => Op::Tilde,
+            range::Op::Compatible => Op::Compatible,
+            range::Op::Wildcard(version) => {
+                match version {
+                    range::WildcardVersion::Major => Op::Wildcard(WildcardVersion::Major),
+                    range::WildcardVersion::Minor => Op::Wildcard(WildcardVersion::Minor),
+                    range::WildcardVersion::Patch => Op::Wildcard(WildcardVersion::Patch),
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+struct Predicate {
+    op: Op,
+    major: u64,
+    minor: Option<u64>,
+    patch: Option<u64>,
+    pre: Vec<Identifier>,
+}
+
+impl From<semver_parser::range::Predicate> for Predicate {
+    fn from(other: semver_parser::range::Predicate) -> Predicate {
+        Predicate {
+            op: From::from(other.op),
+            major: other.major,
+            minor: other.minor,
+            patch: other.patch,
+            pre: other.pre.into_iter().map(From::from).collect(),
+        }
+    }
+}
+
+/// A `ReqParseError` is returned from methods which parse a string into a `VersionReq`. Each
+/// enumeration is one of the possible errors that can occur.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ReqParseError {
+    /// The given version requirement is invalid.
+    InvalidVersionRequirement,
+    /// You have already provided an operation, such as `=`, `~`, or `^`. Only use one.
+    OpAlreadySet,
+    /// The sigil you have written is not correct.
+    InvalidSigil,
+    /// All components of a version must be numeric.
+    VersionComponentsMustBeNumeric,
+    /// There was an error parsing an identifier.
+    InvalidIdentifier,
+    /// At least a major version is required.
+    MajorVersionRequired,
+    /// An unimplemented version requirement.
+    UnimplementedVersionRequirement,
+    /// This form of requirement is deprecated.
+    DeprecatedVersionRequirement(VersionReq),
+}
+
+impl fmt::Display for ReqParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.description().fmt(f)
+    }
+}
+
+impl Error for ReqParseError {
+    fn description(&self) -> &str {
+        match self {
+            &InvalidVersionRequirement => "the given version requirement is invalid",
+            &OpAlreadySet => {
+                "you have already provided an operation, such as =, ~, or ^; only use one"
+            },
+            &InvalidSigil => "the sigil you have written is not correct",
+            &VersionComponentsMustBeNumeric => "version components must be numeric",
+            &InvalidIdentifier => "invalid identifier",
+            &MajorVersionRequired => "at least a major version number is required",
+            &UnimplementedVersionRequirement => {
+                "the given version requirement is not implemented, yet"
+            },
+            &DeprecatedVersionRequirement(_) => "This requirement is deprecated",
+        }
+    }
+}
+
+impl From<String> for ReqParseError {
+    fn from(other: String) -> ReqParseError {
+        match &*other {
+            "Null is not a valid VersionReq" => ReqParseError::InvalidVersionRequirement,
+            "VersionReq did not parse properly." => ReqParseError::OpAlreadySet,
+            _ => ReqParseError::InvalidVersionRequirement,
+        }
+    }
+}
+
+impl VersionReq {
+    /// `any()` is a factory method which creates a `VersionReq` with no constraints. In other
+    /// words, any version will match against it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use semver::VersionReq;
+    ///
+    /// let anything = VersionReq::any();
+    /// ```
+    pub fn any() -> VersionReq {
+        VersionReq { predicates: vec![] }
+    }
+
+    /// `parse()` is the main constructor of a `VersionReq`. It takes a string like `"^1.2.3"`
+    /// and turns it into a `VersionReq` that matches that particular constraint.
+    ///
+    /// A `Result` is returned which contains a `ReqParseError` if there was a problem parsing the
+    /// `VersionReq`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use semver::VersionReq;
+    ///
+    /// let version = VersionReq::parse("=1.2.3");
+    /// let version = VersionReq::parse(">1.2.3");
+    /// let version = VersionReq::parse("<1.2.3");
+    /// let version = VersionReq::parse("~1.2.3");
+    /// let version = VersionReq::parse("^1.2.3");
+    /// let version = VersionReq::parse("1.2.3"); // synonym for ^1.2.3
+    /// let version = VersionReq::parse("<=1.2.3");
+    /// let version = VersionReq::parse(">=1.2.3");
+    /// ```
+    ///
+    /// This example demonstrates error handling, and will panic.
+    ///
+    /// ```should-panic
+    /// use semver::VersionReq;
+    ///
+    /// let version = match VersionReq::parse("not a version") {
+    ///     Ok(version) => version,
+    ///     Err(e) => panic!("There was a problem parsing: {}", e),
+    /// }
+    /// ```
+    pub fn parse(input: &str) -> Result<VersionReq, ReqParseError> {
+        let res = semver_parser::range::parse(input);
+
+        if let Ok(v) = res {
+            return Ok(From::from(v));
+        }
+
+        return match VersionReq::parse_deprecated(input) {
+            Some(v) => {
+                Err(ReqParseError::DeprecatedVersionRequirement(v))
+            }
+            None => Err(From::from(res.err().unwrap())),
+        }
+    }
+
+    fn parse_deprecated(version: &str) -> Option<VersionReq> {
+        return match version {
+            ".*" => Some(VersionReq::any()),
+            "0.1.0." => Some(VersionReq::parse("0.1.0").unwrap()),
+            "0.3.1.3" => Some(VersionReq::parse("0.3.13").unwrap()),
+            "0.2*" => Some(VersionReq::parse("0.2.*").unwrap()),
+            "*.0" => Some(VersionReq::any()),
+            _ => None,
+        }
+    }
+
+    /// `exact()` is a factory method which creates a `VersionReq` with one exact constraint.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use semver::VersionReq;
+    /// use semver::Version;
+    ///
+    /// let version = Version { major: 1, minor: 1, patch: 1, pre: vec![], build: vec![] };
+    /// let exact = VersionReq::exact(&version);
+    /// ```
+    pub fn exact(version: &Version) -> VersionReq {
+        VersionReq { predicates: vec![Predicate::exact(version)] }
+    }
+
+    /// `matches()` matches a given `Version` against this `VersionReq`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use semver::VersionReq;
+    /// use semver::Version;
+    ///
+    /// let version = Version { major: 1, minor: 1, patch: 1, pre: vec![], build: vec![] };
+    /// let exact = VersionReq::exact(&version);
+    ///
+    /// assert!(exact.matches(&version));
+    /// ```
+    pub fn matches(&self, version: &Version) -> bool {
+        // no predicates means anything matches
+        if self.predicates.is_empty() {
+            return true;
+        }
+
+        self.predicates.iter().all(|p| p.matches(version)) &&
+        self.predicates.iter().any(|p| p.pre_tag_is_compatible(version))
+    }
+}
+
+impl str::FromStr for VersionReq {
+    type Err = ReqParseError;
+
+    fn from_str(s: &str) -> Result<VersionReq, ReqParseError> {
+        VersionReq::parse(s)
+    }
+}
+
+impl Predicate {
+    fn exact(version: &Version) -> Predicate {
+        Predicate {
+            op: Ex,
+            major: version.major,
+            minor: Some(version.minor),
+            patch: Some(version.patch),
+            pre: version.pre.clone(),
+        }
+    }
+
+    /// `matches()` takes a `Version` and determines if it matches this particular `Predicate`.
+    pub fn matches(&self, ver: &Version) -> bool {
+        match self.op {
+            Ex => self.is_exact(ver),
+            Gt => self.is_greater(ver),
+            GtEq => self.is_exact(ver) || self.is_greater(ver),
+            Lt => !self.is_exact(ver) && !self.is_greater(ver),
+            LtEq => !self.is_greater(ver),
+            Tilde => self.matches_tilde(ver),
+            Compatible => self.is_compatible(ver),
+            Wildcard(_) => self.matches_wildcard(ver),
+        }
+    }
+
+    fn is_exact(&self, ver: &Version) -> bool {
+        if self.major != ver.major {
+            return false;
+        }
+
+        match self.minor {
+            Some(minor) => {
+                if minor != ver.minor {
+                    return false;
+                }
+            }
+            None => return true,
+        }
+
+        match self.patch {
+            Some(patch) => {
+                if patch != ver.patch {
+                    return false;
+                }
+            }
+            None => return true,
+        }
+
+        if self.pre != ver.pre {
+            return false;
+        }
+
+        true
+    }
+
+    // https://docs.npmjs.com/misc/semver#prerelease-tags
+    fn pre_tag_is_compatible(&self, ver: &Version) -> bool {
+        // If a version has a prerelease tag (for example, 1.2.3-alpha.3) then it will
+        // only be
+        // allowed to satisfy comparator sets if at least one comparator with the same
+        // [major,
+        // minor, patch] tuple also has a prerelease tag.
+        !ver.is_prerelease() ||
+        (self.major == ver.major && self.minor == Some(ver.minor) &&
+         self.patch == Some(ver.patch) && !self.pre.is_empty())
+    }
+
+    fn is_greater(&self, ver: &Version) -> bool {
+        if self.major != ver.major {
+            return ver.major > self.major;
+        }
+
+        match self.minor {
+            Some(minor) => {
+                if minor != ver.minor {
+                    return ver.minor > minor;
+                }
+            }
+            None => return false,
+        }
+
+        match self.patch {
+            Some(patch) => {
+                if patch != ver.patch {
+                    return ver.patch > patch;
+                }
+            }
+            None => return false,
+        }
+
+        if !self.pre.is_empty() {
+            return ver.pre.is_empty() || ver.pre > self.pre;
+        }
+
+        false
+    }
+
+    // see https://www.npmjs.org/doc/misc/semver.html for behavior
+    fn matches_tilde(&self, ver: &Version) -> bool {
+        let minor = match self.minor {
+            Some(n) => n,
+            None => return self.major == ver.major,
+        };
+
+        match self.patch {
+            Some(patch) => {
+                self.major == ver.major && minor == ver.minor &&
+                (ver.patch > patch || (ver.patch == patch && self.pre_is_compatible(ver)))
+            }
+            None => self.major == ver.major && minor == ver.minor,
+        }
+    }
+
+    // see https://www.npmjs.org/doc/misc/semver.html for behavior
+    fn is_compatible(&self, ver: &Version) -> bool {
+        if self.major != ver.major {
+            return false;
+        }
+
+        let minor = match self.minor {
+            Some(n) => n,
+            None => return self.major == ver.major,
+        };
+
+        match self.patch {
+            Some(patch) => {
+                if self.major == 0 {
+                    if minor == 0 {
+                        ver.minor == minor && ver.patch == patch && self.pre_is_compatible(ver)
+                    } else {
+                        ver.minor == minor &&
+                        (ver.patch > patch || (ver.patch == patch && self.pre_is_compatible(ver)))
+                    }
+                } else {
+                    ver.minor > minor ||
+                    (ver.minor == minor &&
+                     (ver.patch > patch || (ver.patch == patch && self.pre_is_compatible(ver))))
+                }
+            }
+            None => {
+                if self.major == 0 {
+                    ver.minor == minor
+                } else {
+                    ver.minor >= minor
+                }
+            }
+        }
+    }
+
+    fn pre_is_compatible(&self, ver: &Version) -> bool {
+        ver.pre.is_empty() || ver.pre >= self.pre
+    }
+
+    // see https://www.npmjs.org/doc/misc/semver.html for behavior
+    fn matches_wildcard(&self, ver: &Version) -> bool {
+        match self.op {
+            Wildcard(Major) => true,
+            Wildcard(Minor) => self.major == ver.major,
+            Wildcard(Patch) => {
+                match self.minor {
+                    Some(minor) => self.major == ver.major && minor == ver.minor,
+                    None => {
+                        // minor and patch version astericks mean match on major
+                        self.major == ver.major
+                    }
+                }
+            }
+            _ => false,  // unreachable
+        }
+    }
+}
+
+impl fmt::Display for VersionReq {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        if self.predicates.is_empty() {
+            try!(write!(fmt, "*"));
+        } else {
+            for (i, ref pred) in self.predicates.iter().enumerate() {
+                if i == 0 {
+                    try!(write!(fmt, "{}", pred));
+                } else {
+                    try!(write!(fmt, ", {}", pred));
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for Predicate {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self.op {
+            Wildcard(Major) => try!(write!(fmt, "*")),
+            Wildcard(Minor) => try!(write!(fmt, "{}.*", self.major)),
+            Wildcard(Patch) => {
+                if let Some(minor) = self.minor {
+                    try!(write!(fmt, "{}.{}.*", self.major, minor))
+                } else {
+                    try!(write!(fmt, "{}.*.*", self.major))
+                }
+            }
+            _ => {
+                try!(write!(fmt, "{}{}", self.op, self.major));
+
+                match self.minor {
+                    Some(v) => try!(write!(fmt, ".{}", v)),
+                    None => (),
+                }
+
+                match self.patch {
+                    Some(v) => try!(write!(fmt, ".{}", v)),
+                    None => (),
+                }
+
+                if !self.pre.is_empty() {
+                    try!(write!(fmt, "-"));
+                    for (i, x) in self.pre.iter().enumerate() {
+                        if i != 0 {
+                            try!(write!(fmt, "."))
+                        }
+                        try!(write!(fmt, "{}", x));
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for Op {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Ex => try!(write!(fmt, "= ")),
+            Gt => try!(write!(fmt, "> ")),
+            GtEq => try!(write!(fmt, ">= ")),
+            Lt => try!(write!(fmt, "< ")),
+            LtEq => try!(write!(fmt, "<= ")),
+            Tilde => try!(write!(fmt, "~")),
+            Compatible => try!(write!(fmt, "^")),
+            // gets handled specially in Predicate::fmt
+            Wildcard(_) => try!(write!(fmt, "")),
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{VersionReq, Op};
+    use super::super::version::Version;
+    use std::hash::{Hash, Hasher};
+
+    fn req(s: &str) -> VersionReq {
+        VersionReq::parse(s).unwrap()
+    }
+
+    fn version(s: &str) -> Version {
+        match Version::parse(s) {
+            Ok(v) => v,
+            Err(e) => panic!("`{}` is not a valid version. Reason: {:?}", s, e),
+        }
+    }
+
+    fn assert_match(req: &VersionReq, vers: &[&str]) {
+        for ver in vers.iter() {
+            assert!(req.matches(&version(*ver)), "did not match {}", ver);
+        }
+    }
+
+    fn assert_not_match(req: &VersionReq, vers: &[&str]) {
+        for ver in vers.iter() {
+            assert!(!req.matches(&version(*ver)), "matched {}", ver);
+        }
+    }
+
+    fn calculate_hash<T: Hash>(t: T) -> u64 {
+        use std::collections::hash_map::DefaultHasher;
+
+        let mut s = DefaultHasher::new();
+        t.hash(&mut s);
+        s.finish()
+    }
+
+    #[test]
+    fn test_parsing_default() {
+        let r = req("1.0.0");
+
+        assert_eq!(r.to_string(), "^1.0.0".to_string());
+
+        assert_match(&r, &["1.0.0", "1.0.1"]);
+        assert_not_match(&r, &["0.9.9", "0.10.0", "0.1.0"]);
+    }
+
+    #[test]
+    fn test_parsing_exact() {
+        let r = req("=1.0.0");
+
+        assert!(r.to_string() == "= 1.0.0".to_string());
+        assert_eq!(r.to_string(), "= 1.0.0".to_string());
+
+        assert_match(&r, &["1.0.0"]);
+        assert_not_match(&r, &["1.0.1", "0.9.9", "0.10.0", "0.1.0", "1.0.0-pre"]);
+
+        let r = req("=0.9.0");
+
+        assert_eq!(r.to_string(), "= 0.9.0".to_string());
+
+        assert_match(&r, &["0.9.0"]);
+        assert_not_match(&r, &["0.9.1", "1.9.0", "0.0.9"]);
+
+        let r = req("=0.1.0-beta2.a");
+
+        assert_eq!(r.to_string(), "= 0.1.0-beta2.a".to_string());
+
+        assert_match(&r, &["0.1.0-beta2.a"]);
+        assert_not_match(&r, &["0.9.1", "0.1.0", "0.1.1-beta2.a", "0.1.0-beta2"]);
+    }
+
+    #[test]
+    fn test_parse_metadata_see_issue_88_see_issue_88() {
+        for op in &[Op::Compatible, Op::Ex, Op::Gt, Op::GtEq, Op::Lt, Op::LtEq, Op::Tilde] {
+            req(&format!("{} 1.2.3+meta", op));
+        }
+    }
+
+    #[test]
+    pub fn test_parsing_greater_than() {
+        let r = req(">= 1.0.0");
+
+        assert_eq!(r.to_string(), ">= 1.0.0".to_string());
+
+        assert_match(&r, &["1.0.0", "2.0.0"]);
+        assert_not_match(&r, &["0.1.0", "0.0.1", "1.0.0-pre", "2.0.0-pre"]);
+
+        let r = req(">= 2.1.0-alpha2");
+
+        assert_match(&r, &["2.1.0-alpha2", "2.1.0-alpha3", "2.1.0", "3.0.0"]);
+        assert_not_match(&r,
+                         &["2.0.0", "2.1.0-alpha1", "2.0.0-alpha2", "3.0.0-alpha2"]);
+    }
+
+    #[test]
+    pub fn test_parsing_less_than() {
+        let r = req("< 1.0.0");
+
+        assert_eq!(r.to_string(), "< 1.0.0".to_string());
+
+        assert_match(&r, &["0.1.0", "0.0.1"]);
+        assert_not_match(&r, &["1.0.0", "1.0.0-beta", "1.0.1", "0.9.9-alpha"]);
+
+        let r = req("<= 2.1.0-alpha2");
+
+        assert_match(&r, &["2.1.0-alpha2", "2.1.0-alpha1", "2.0.0", "1.0.0"]);
+        assert_not_match(&r,
+                         &["2.1.0", "2.2.0-alpha1", "2.0.0-alpha2", "1.0.0-alpha2"]);
+    }
+
+    #[test]
+    pub fn test_multiple() {
+        let r = req("> 0.0.9, <= 2.5.3");
+        assert_eq!(r.to_string(), "> 0.0.9, <= 2.5.3".to_string());
+        assert_match(&r, &["0.0.10", "1.0.0", "2.5.3"]);
+        assert_not_match(&r, &["0.0.8", "2.5.4"]);
+
+        let r = req("0.3.0, 0.4.0");
+        assert_eq!(r.to_string(), "^0.3.0, ^0.4.0".to_string());
+        assert_not_match(&r, &["0.0.8", "0.3.0", "0.4.0"]);
+
+        let r = req("<= 0.2.0, >= 0.5.0");
+        assert_eq!(r.to_string(), "<= 0.2.0, >= 0.5.0".to_string());
+        assert_not_match(&r, &["0.0.8", "0.3.0", "0.5.1"]);
+
+        let r = req("0.1.0, 0.1.4, 0.1.6");
+        assert_eq!(r.to_string(), "^0.1.0, ^0.1.4, ^0.1.6".to_string());
+        assert_match(&r, &["0.1.6", "0.1.9"]);
+        assert_not_match(&r, &["0.1.0", "0.1.4", "0.2.0"]);
+
+        assert!(VersionReq::parse("> 0.1.0,").is_err());
+        assert!(VersionReq::parse("> 0.3.0, ,").is_err());
+
+        let r = req(">=0.5.1-alpha3, <0.6");
+        assert_eq!(r.to_string(), ">= 0.5.1-alpha3, < 0.6".to_string());
+        assert_match(&r,
+                     &["0.5.1-alpha3", "0.5.1-alpha4", "0.5.1-beta", "0.5.1", "0.5.5"]);
+        assert_not_match(&r,
+                         &["0.5.1-alpha1", "0.5.2-alpha3", "0.5.5-pre", "0.5.0-pre"]);
+        assert_not_match(&r, &["0.6.0", "0.6.0-pre"]);
+    }
+
+    #[test]
+    pub fn test_parsing_tilde() {
+        let r = req("~1");
+        assert_match(&r, &["1.0.0", "1.0.1", "1.1.1"]);
+        assert_not_match(&r, &["0.9.1", "2.9.0", "0.0.9"]);
+
+        let r = req("~1.2");
+        assert_match(&r, &["1.2.0", "1.2.1"]);
+        assert_not_match(&r, &["1.1.1", "1.3.0", "0.0.9"]);
+
+        let r = req("~1.2.2");
+        assert_match(&r, &["1.2.2", "1.2.4"]);
+        assert_not_match(&r, &["1.2.1", "1.9.0", "1.0.9", "2.0.1", "0.1.3"]);
+
+        let r = req("~1.2.3-beta.2");
+        assert_match(&r, &["1.2.3", "1.2.4", "1.2.3-beta.2", "1.2.3-beta.4"]);
+        assert_not_match(&r, &["1.3.3", "1.1.4", "1.2.3-beta.1", "1.2.4-beta.2"]);
+    }
+
+    #[test]
+    pub fn test_parsing_compatible() {
+        let r = req("^1");
+        assert_match(&r, &["1.1.2", "1.1.0", "1.2.1", "1.0.1"]);
+        assert_not_match(&r, &["0.9.1", "2.9.0", "0.1.4"]);
+        assert_not_match(&r, &["1.0.0-beta1", "0.1.0-alpha", "1.0.1-pre"]);
+
+        let r = req("^1.1");
+        assert_match(&r, &["1.1.2", "1.1.0", "1.2.1"]);
+        assert_not_match(&r, &["0.9.1", "2.9.0", "1.0.1", "0.1.4"]);
+
+        let r = req("^1.1.2");
+        assert_match(&r, &["1.1.2", "1.1.4", "1.2.1"]);
+        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.0.1"]);
+        assert_not_match(&r, &["1.1.2-alpha1", "1.1.3-alpha1", "2.9.0-alpha1"]);
+
+        let r = req("^0.1.2");
+        assert_match(&r, &["0.1.2", "0.1.4"]);
+        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.0.1"]);
+        assert_not_match(&r, &["0.1.2-beta", "0.1.3-alpha", "0.2.0-pre"]);
+
+        let r = req("^0.5.1-alpha3");
+        assert_match(&r,
+                     &["0.5.1-alpha3", "0.5.1-alpha4", "0.5.1-beta", "0.5.1", "0.5.5"]);
+        assert_not_match(&r,
+                         &["0.5.1-alpha1", "0.5.2-alpha3", "0.5.5-pre", "0.5.0-pre", "0.6.0"]);
+
+        let r = req("^0.0.2");
+        assert_match(&r, &["0.0.2"]);
+        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.0.1", "0.1.4"]);
+
+        let r = req("^0.0");
+        assert_match(&r, &["0.0.2", "0.0.0"]);
+        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.1.4"]);
+
+        let r = req("^0");
+        assert_match(&r, &["0.9.1", "0.0.2", "0.0.0"]);
+        assert_not_match(&r, &["2.9.0", "1.1.1"]);
+
+        let r = req("^1.4.2-beta.5");
+        assert_match(&r,
+                     &["1.4.2", "1.4.3", "1.4.2-beta.5", "1.4.2-beta.6", "1.4.2-c"]);
+        assert_not_match(&r,
+                         &["0.9.9", "2.0.0", "1.4.2-alpha", "1.4.2-beta.4", "1.4.3-beta.5"]);
+    }
+
+    #[test]
+    pub fn test_parsing_wildcard() {
+        let r = req("");
+        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);
+        assert_not_match(&r, &[]);
+        let r = req("*");
+        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);
+        assert_not_match(&r, &[]);
+        let r = req("x");
+        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);
+        assert_not_match(&r, &[]);
+        let r = req("X");
+        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);
+        assert_not_match(&r, &[]);
+
+        let r = req("1.*");
+        assert_match(&r, &["1.2.0", "1.2.1", "1.1.1", "1.3.0"]);
+        assert_not_match(&r, &["0.0.9"]);
+        let r = req("1.x");
+        assert_match(&r, &["1.2.0", "1.2.1", "1.1.1", "1.3.0"]);
+        assert_not_match(&r, &["0.0.9"]);
+        let r = req("1.X");
+        assert_match(&r, &["1.2.0", "1.2.1", "1.1.1", "1.3.0"]);
+        assert_not_match(&r, &["0.0.9"]);
+
+        let r = req("1.2.*");
+        assert_match(&r, &["1.2.0", "1.2.2", "1.2.4"]);
+        assert_not_match(&r, &["1.9.0", "1.0.9", "2.0.1", "0.1.3"]);
+        let r = req("1.2.x");
+        assert_match(&r, &["1.2.0", "1.2.2", "1.2.4"]);
+        assert_not_match(&r, &["1.9.0", "1.0.9", "2.0.1", "0.1.3"]);
+        let r = req("1.2.X");
+        assert_match(&r, &["1.2.0", "1.2.2", "1.2.4"]);
+        assert_not_match(&r, &["1.9.0", "1.0.9", "2.0.1", "0.1.3"]);
+    }
+
+    #[test]
+    pub fn test_any() {
+        let r = VersionReq::any();
+        assert_match(&r, &["0.0.1", "0.1.0", "1.0.0"]);
+    }
+
+    #[test]
+    pub fn test_pre() {
+        let r = req("=2.1.1-really.0");
+        assert_match(&r, &["2.1.1-really.0"]);
+    }
+
+    // #[test]
+    // pub fn test_parse_errors() {
+    //    assert_eq!(Err(InvalidVersionRequirement), VersionReq::parse("\0"));
+    //    assert_eq!(Err(OpAlreadySet), VersionReq::parse(">= >= 0.0.2"));
+    //    assert_eq!(Err(InvalidSigil), VersionReq::parse(">== 0.0.2"));
+    //    assert_eq!(Err(VersionComponentsMustBeNumeric),
+    //               VersionReq::parse("a.0.0"));
+    //    assert_eq!(Err(InvalidIdentifier), VersionReq::parse("1.0.0-"));
+    //    assert_eq!(Err(MajorVersionRequired), VersionReq::parse(">="));
+    // }
+
+    #[test]
+    pub fn test_from_str() {
+        assert_eq!("1.0.0".parse::<VersionReq>().unwrap().to_string(),
+                   "^1.0.0".to_string());
+        assert_eq!("=1.0.0".parse::<VersionReq>().unwrap().to_string(),
+                   "= 1.0.0".to_string());
+        assert_eq!("~1".parse::<VersionReq>().unwrap().to_string(),
+                   "~1".to_string());
+        assert_eq!("~1.2".parse::<VersionReq>().unwrap().to_string(),
+                   "~1.2".to_string());
+        assert_eq!("^1".parse::<VersionReq>().unwrap().to_string(),
+                   "^1".to_string());
+        assert_eq!("^1.1".parse::<VersionReq>().unwrap().to_string(),
+                   "^1.1".to_string());
+        assert_eq!("*".parse::<VersionReq>().unwrap().to_string(),
+                   "*".to_string());
+        assert_eq!("1.*".parse::<VersionReq>().unwrap().to_string(),
+                   "1.*".to_string());
+        assert_eq!("< 1.0.0".parse::<VersionReq>().unwrap().to_string(),
+                   "< 1.0.0".to_string());
+    }
+
+    // #[test]
+    // pub fn test_from_str_errors() {
+    //    assert_eq!(Err(InvalidVersionRequirement), "\0".parse::<VersionReq>());
+    //    assert_eq!(Err(OpAlreadySet), ">= >= 0.0.2".parse::<VersionReq>());
+    //    assert_eq!(Err(InvalidSigil), ">== 0.0.2".parse::<VersionReq>());
+    //    assert_eq!(Err(VersionComponentsMustBeNumeric),
+    //               "a.0.0".parse::<VersionReq>());
+    //    assert_eq!(Err(InvalidIdentifier), "1.0.0-".parse::<VersionReq>());
+    //    assert_eq!(Err(MajorVersionRequired), ">=".parse::<VersionReq>());
+    // }
+
+    #[test]
+    fn test_cargo3202() {
+        let v = "0.*.*".parse::<VersionReq>().unwrap();
+        assert_eq!("0.*.*", format!("{}", v.predicates[0]));
+
+        let v = "0.0.*".parse::<VersionReq>().unwrap();
+        assert_eq!("0.0.*", format!("{}", v.predicates[0]));
+
+        let r = req("0.*.*");
+        assert_match(&r, &["0.5.0"]);
+    }
+
+    #[test]
+    fn test_eq_hash() {
+        assert!(req("^1") == req("^1"));
+        assert!(calculate_hash(req("^1")) == calculate_hash(req("^1")));
+        assert!(req("^1") != req("^2"));
+    }
+
+    #[test]
+    fn test_ordering() {
+        assert!(req("=1") < req("*"));
+        assert!(req(">1") < req("*"));
+        assert!(req(">=1") < req("*"));
+        assert!(req("<1") < req("*"));
+        assert!(req("<=1") < req("*"));
+        assert!(req("~1") < req("*"));
+        assert!(req("^1") < req("*"));
+        assert!(req("*") == req("*"));
+    }
+}
diff --git a/semver/tests/deprecation.rs b/semver/tests/deprecation.rs
new file mode 100644
index 0000000..a5f533a
--- /dev/null
+++ b/semver/tests/deprecation.rs
@@ -0,0 +1,22 @@
+extern crate semver;
+
+#[test]
+fn test_regressions() {
+    use semver::VersionReq;
+    use semver::ReqParseError;
+
+    let versions = vec![
+        (".*", VersionReq::any()),
+        ("0.1.0.", VersionReq::parse("0.1.0").unwrap()),
+        ("0.3.1.3", VersionReq::parse("0.3.13").unwrap()),
+        ("0.2*", VersionReq::parse("0.2.*").unwrap()),
+        ("*.0", VersionReq::any()),
+    ];
+
+    for (version, requirement) in versions.into_iter() {
+        let parsed = VersionReq::parse(version);
+        let error = parsed.err().unwrap();
+
+        assert_eq!(ReqParseError::DeprecatedVersionRequirement(requirement), error);
+    }
+}
diff --git a/semver/tests/regression.rs b/semver/tests/regression.rs
new file mode 100644
index 0000000..ef568a7
--- /dev/null
+++ b/semver/tests/regression.rs
@@ -0,0 +1,25 @@
+extern crate semver;
+extern crate crates_index;
+extern crate tempdir;
+
+// This test checks to see if every existing crate parses successfully. Important to not break the
+// Rust universe!
+
+#[cfg(feature = "ci")]
+#[test]
+fn test_regressions() {
+    use tempdir::TempDir;
+    use crates_index::Index;
+    use semver::Version;
+
+    let dir = TempDir::new("semver").unwrap();
+    let index = Index::new(dir.into_path());
+    index.clone().unwrap();
+
+    for krate in index.crates() {
+        for version in krate.versions() {
+            let v = version.version();
+            assert!(Version::parse(v).is_ok(), "failed: {} ({})", version.name(), v);
+        }
+    }
+}
diff --git a/semver/tests/serde.rs b/semver/tests/serde.rs
new file mode 100644
index 0000000..bcb9264
--- /dev/null
+++ b/semver/tests/serde.rs
@@ -0,0 +1,90 @@
+#![cfg(feature = "serde")]
+
+#[macro_use]
+extern crate serde_derive;
+
+extern crate semver;
+extern crate serde_json;
+
+use semver::{Identifier, Version, VersionReq};
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+struct Identified {
+    name: String,
+    identifier: Identifier,
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+struct Versioned {
+    name: String,
+    vers: Version,
+}
+
+#[test]
+fn serialize_identifier() {
+    let id = Identified {
+        name: "serde".to_owned(),
+        identifier: Identifier::Numeric(100),
+    };
+    let j = serde_json::to_string(&id).unwrap();
+    assert_eq!(j, r#"{"name":"serde","identifier":100}"#);
+
+    let id = Identified {
+        name: "serde".to_owned(),
+        identifier: Identifier::AlphaNumeric("b100".to_owned()),
+    };
+    let j = serde_json::to_string(&id).unwrap();
+    assert_eq!(j, r#"{"name":"serde","identifier":"b100"}"#);
+}
+
+#[test]
+fn deserialize_identifier() {
+    let j = r#"{"name":"serde","identifier":100}"#;
+    let id = serde_json::from_str::<Identified>(j).unwrap();
+    let expected = Identified {
+        name: "serde".to_owned(),
+        identifier: Identifier::Numeric(100),
+    };
+    assert_eq!(id, expected);
+
+    let j = r#"{"name":"serde","identifier":"b100"}"#;
+    let id = serde_json::from_str::<Identified>(j).unwrap();
+    let expected = Identified {
+        name: "serde".to_owned(),
+        identifier: Identifier::AlphaNumeric("b100".to_owned()),
+    };
+    assert_eq!(id, expected);
+}
+
+#[test]
+fn serialize_version() {
+    let v = Versioned {
+        name: "serde".to_owned(),
+        vers: Version::parse("1.0.0").unwrap(),
+    };
+    let j = serde_json::to_string(&v).unwrap();
+    assert_eq!(j, r#"{"name":"serde","vers":"1.0.0"}"#);
+}
+
+#[test]
+fn deserialize_version() {
+    let j = r#"{"name":"serde","vers":"1.0.0"}"#;
+    let v = serde_json::from_str::<Versioned>(j).unwrap();
+    let expected = Versioned {
+        name: "serde".to_owned(),
+        vers: Version::parse("1.0.0").unwrap(),
+    };
+    assert_eq!(v, expected);
+}
+
+#[test]
+fn serialize_versionreq() {
+    let v = VersionReq::exact(&Version::parse("1.0.0").unwrap());
+
+    assert_eq!(serde_json::to_string(&v).unwrap(), r#""= 1.0.0""#);
+}
+
+#[test]
+fn deserialize_versionreq() {
+    assert_eq!("1.0.0".parse::<VersionReq>().unwrap(), serde_json::from_str(r#""1.0.0""#).unwrap());
+}