semver-parser tutorial

<

>

1 Set up basic project structure and metadata

Welcome to the semver-parser tutorial!

This tutorial is an example of a "literate git" project. For an explanation of the motivations for this project, view the report here.

Our goal is to build a Rust library that can parse semver version strings. The maintainer of the semver crate has decided to split off the parsing operations to a separate crate, and he assigned us to implement it.

We'll document both the steps we take to build the crate and the reasons (or lack thereof) behind our implementation choices. When someone comes along later with an idea for improving our program, they can read our tutorial for more information about the project's structure and history.

There are two main public functions we need to expose to be able to plug in to the semver crate. The version::parse function transforms a version string into a struct with individual fields for each part of the version number. The range::parse function takes a string that specifies a range of matching versions and returns a struct containing one or more predicates which can be compared to individual versions.

Lucky for us, there is already a large set of test cases that we can use to verify our results. Since the function names and return types are already mostly taken care of, we can just focus on passing those tests. Ah, the life of a junior programmer!

Before we start putting together our functions, let's do some basic setup. We're going to use the Cargo package manager and build system to help streamline development, since the semver crate is already using it.

Check out the initial project structure below, then click the arrow above to move on to the next step.

.gitignore

Cargo automatically creates a basic .gitignore file for us. The target directory is where build artifacts land, so we don't want to be tracking that. Because this is a library, we also ignore the Cargo.lock file. If we were building an executable application, we would not ignore it.

Cargo.toml

The Cargo.toml file contains metadata about our crate. This includes links to related resources, dependency lists, license information, and many other possible fields. Since we have great foresight, we'll just fill this all in right now and forget about it. If we didn't have a crystal ball, we'd be updating this along the way.

+

-

.gitignore

Cargo.toml

LICENSE-APACHE

LICENSE-MIT

1.1 Introduce .gitignore and Cargo.toml

.gitignore

Cargo.toml

1.2 Add extra metadata

Cargo.toml

1.3 bump to 0.2.0

Cargo.toml

1.4 bump to 0.3.0

Cargo.toml

1.5 bump to 0.4.0

Cargo.toml

1.6 Bump to 0.4.1

Cargo.toml

1.7 bump version to 0.5.0

Cargo.toml

1.8 bump for 0.5.1

Cargo.toml

1.9 relax regex requirement a bit

Conflicts: Cargo.toml

Cargo.toml

1.10 bump to 0.6.0

Cargo.toml

1.11 Link to documentation on docs.rs

Fixes #3

Cargo.toml

1.12 Update to 0.6.2

Cargo.toml

1.13 include LICENSE files

These were already in the Cargo.toml, but we should include them anyway.

LICENSE-APACHE

LICENSE-MIT

<

>

2 Implement `version::parse`

The version::parse function takes a semver version string as input and returns a Result containing either a Version struct or an error string.

The Version struct contains a field for each possible component of a semver version string. The major, minor, and patch fields are all required integers. The pre and build fields consist of zero or more alphanumeric or numeric identifiers.

This is a bit too much code to explain at once, so click the + symbol on the left for a step-by-step explanation. Once you're done, click the arrow at the top right to continue on to the range parsing function.

What about that test suite you mentioned?

There are a lot of tests! To keep things clean, we'll show them all in the final step of the tutorial.

+

-

src/common.rs

src/lib.rs

src/version.rs

2.1 Humble beginnings

Time to write some Rust code! It's all very basic for now, but we have to start somewhere.

src/lib.rs

Since this is a library crate, we list our public modules in src/lib.rs. For now, that's just our version module. While we're at it, let's pull in the regex crate we listed as a dependency. If we list it here, we can use it from any future modules, like the range parsing one we will make in the next step.

src/version.rs

There are three main components here.

On the first line, we bring the Regex module into our local scope so we can refer to it with a short name.

Next, we introduce a basic Version struct. If you're reading carefully, you'll see we don't even have the pre and build fields yet. Let's just start here and add those in later. We don't have to pass all the tests until we're done!

Note that Version and its fields are all marked public. Unlike some other languages, in Rust you must mark each field of a struct public if you want to expose it. Our users will be able to use the struct and all its fields.

The parse_version function uses Regex to extract the major, minor, and patch levels from a version string. This isn't robust enough to handle all of semver yet, but we have a mostly working module in under 20 lines of code.

Are you worried about all those calls to unwrap()? You should be! If an error occurs, the unwrap() will panic and crash our program. We'll have to implement error handling at some point, but for now let's just keep things simple.

But the function is supposed to be version::parse, you called it parse_version!

Oops, we'll have to fix that in a future step.

+

-

src/lib.rs

src/version.rs

2.1.1 Introduce version.rs

src/version.rs

2.1.2 Make these pub

src/version.rs

2.1.3 Add lib.rs

Conflicts: src/version.rs

src/lib.rs

src/version.rs

2.2 Disallow leading zeros and return Result

When we started applying our test suite to the result of the previous step, we found an error. Time to fix it!

src/lib.rs

Remember the lazy_static dependency we listed in Cargo.toml? The lazy static crate gives us a macro that allows us to declare statics that are evaluated at runtime.

What?

A static in rust is like a global constant. Statics live for the entire lifetime of your program at a fixed memory location. Normally they are limited to simple values, but with the lazy_static! macro, we can create statics that require function calls or heap allocations. We'll use it to make a static Regex that matches semver version strings.

src/version.rs

There are two separate things happening at once here. We made some upgrades to our regex, then changed our return type.

First, we moved the regex creation up out of parse_version into the lazy_static! macro. The result of the macro is the static called REGEX which we can use to match version strings.

The regex declaration went from one line to over a dozen, and we switched from matching on \d+ to matching on the more sophisticated numeric_identifier pattern. This pattern allows a plain zero or a number starting with any other digit, but not a number with a leading zero.

Back in parse_version, we have changed from an unwrap() on REGEX.captures() to a match. The match lets us return an error string when the supplied version number is not matched by the regex. In the version of our program from the previous step, any error in matching the regex would have caused a panic.

Since we can now return either a Version on success or a String on an error, we have changed the return type from Version to Result<Version, String>. When our result is an error, we return Err(...), and when the result is a Version, we return Ok(Version...).

How did you pass any tests if you had the wrong return type at the previous step!

This is hard, we'll get there eventually!

+

-

src/lib.rs

src/version.rs

2.2.1 Introduce lazy_static and return Result

Conflicts: Cargo.toml src/version.rs

src/version.rs

2.2.2 Refactor repeated regexes

src/version.rs

2.2.3 Trim version string

src/version.rs

2.2.4 Change error type from Box to String

src/version.rs

⋮

2.2.5 Move lazy_static to lib.rs

src/lib.rs

src/version.rs

2.2.6 Remove trailing whitespace

Conflicts: src/version.rs

src/version.rs

2.2.7 Fix regex

src/version.rs

2.3 Add support for prerelease tags

Semver allows prerelease tags, denoted by appending a hyphen and a series of dot-separated identifiers immediately following the patch version. Let's add support for them! Or at least partial support. This might take a couple steps.

src/version.rs

The allowed characters in the prerelease label are alphanumerics, hyphens, and periods. We'll call that letters_numbers_dash_dot and tack on an optional prerelease version in our regex. Since that line was getting a bit long, we'll add x mode, which allows us to describe the regex over multiple lines, with comments for each important bit.

We also have to add the pre field to the Version struct and capture it from the regex. For now, we're just reading the whole string into an optional single-element vector. Later on, we will have to break it apart into individual dot-separated identifiers.

+

-

src/version.rs

⋮

2.3.1 Add basic prerelease handling

Conflicts: src/version.rs

src/version.rs

⋮

2.3.2 Add named pattern to prerelease handling

Conflicts: src/version.rs

src/version.rs

⋮

2.3.3 Remove this println, lol

Conflicts: src/version.rs

src/version.rs

2.3.4 Fix regex for uppercase prerelease and build strings

Conflicts: src/version.rs

src/version.rs

2.3.5 Remove println

2.3.6 Remove build stuff that snuck in

src/version.rs

2.4 Add support for build tags

This should look familiar.

The build tag is denoted by a plus sign followed by a series of dot-separated identifiers. We'll use the exact same pattern we followed to add prerelease tag support.

+

-

src/version.rs

⋮

2.4.1 Add basic build string handling

Conflicts: src/version.rs

src/version.rs

⋮

2.4.2 Fix regex

Conflicts: src/version.rs

src/version.rs

2.5 Properly parse prerelease and build tags

Time to fix the types on our prerelease and build tags. Instead of just reading the whole thing into a string, we will break them apart on periods into either alphanumeric or numeric identifiers.

src/version.rs

Semver's prerelease and build tag specification describes tags as either alphanumeric or numeric. Instead of using the type Option<Vec<String>> for the pre and build fields, let's create the Identifier enum. Identifiers may be either AlphaNumeric or Numeric.

Note that we removed the Option around the type of pre and build. Our tests expect just Vec<Identifier>, so we will return an empty vector if nothing is present, rather than a None. The unwrap_or(vec![]) on the lines assigning pre and build assigns them empty vectors when no match was found.

Since we have to parse out the metadata twice, we'll use the parse_meta function. The operation is fairly straightforward. Just split on periods. If all the characters in the string are digits, call it a Numeric, otherwise call it AlphaNumeric.

+

-

src/version.rs

⋮

2.5.1 Introduce parse_meta and Identifier for metadata strings

Conflicts: src/version.rs

src/version.rs

⋮

2.5.2 Fix zero checking

src/version.rs

2.5.3 Remove early trait

src/version.rs

2.5.4 Remove Option from pre and build fields

Conflicts: src/version.rs

src/version.rs

⋮

2.6 Add traits to structs and enums in version.rs

We can make Identifier and Version more useful by adding some traits. Traits act like interfaces; the compiler knows that a type with a trait implemented on it can perform certain operations.

src/version.rs

We can add the Clone, Debug, PartialEq, and Eq traits by simply attaching a derive attribute. Rust automatically generates the code for these traits for us.

To add the Display trait, we need to implement it ourselves. We just need to fill out the fmt function for each. The implementation for Version makes use of the write! macro.

+

-

src/version.rs

⋮

2.6.1 Implement traits for Identifier and Version

Conflicts: src/version.rs

src/version.rs

⋮

2.7 Finish up, move parse_meta to common.rs

We're almost done! Just some little cleanup things remain.

src/version.rs

Turns out our tests and the semver package we're writing this for expect the function to be called parse rather than parse_version. We'll fix that now.

Also, it seems likely that the parse_meta function will be useful in the range parsing module we will be making in the next step. Let's move that to a new file, common.rs.

Now that parse_meta livse in another file, we will use common and call it with common::parse_meta.

src/lib.rs

Add in the (private) common module. We don't need to add this to our public interface.

src/common.rs

Let's make a couple changes to parse_meta while we're at it. First, we will change the argument name from pre to s, since it is used for both prerelease and build tags. We'll also split out the alphanumeric check to a separate function. Finally, we need to accept a plain number 0 as a Numeric, so a slight adjustment is needed on the regex here.

+

-

src/common.rs

src/lib.rs

src/version.rs

⋮

2.7.1 Move parse_meta to common.rs and rename parse_version

Conflicts: src/version.rs

src/common.rs

src/lib.rs

src/version.rs

⋮

2.7.2 Update parse_meta with is_alpha_numeric

src/common.rs

<

>

3 Implement `range::parse`

The range::parse function takes a string containing one or more range specifications and returns a VersionReq with the parsed representation.

The VersionReq contains a vector of Predicate. For a semver version to match the range, it must match each predicate. We don't have to do the matching, that's handled by the semver crate. Here, we just need to parse the string into the individual predicates and return the result.

Predicate is similar to the Version struct we worked with in the version parsing module. It contains the major, minor, patch, and pre fields, but their types are a little different. Minor and patch versions are now optional, since a range can omit them.

There is also an Op field. Op stands for operator. Ranges look like a version string with an optional operator in front. The operators are defined in the Cargo documentation. One of the major, minor, or patch versions can also be a wildcard. If a wildcard is used, the Wildcard operator is chosen.

Let's go through the creation of range::parse step-by-step. Similar to our tutorial for version::parse, we will start with a partial implementation and fill it out as we move along. By the end, we will be passing our entire test suite.

Click the plus sign below to view the step-by-step guide.

But where are those tests!?

They're all listed in the final step of this guide. There are so many that they clutter up the diffs and make the guide hard to follow.

+

-

src/lib.rs

src/range.rs

3.1 Start out with the range-matching regex

This is going to be a big file, before we get a working version, let's just introduce the pieces in smaller chunks to make sure we explain each part.

src/lib.rs

We need to add the range module to our public interface.

src/range.rs

Our use of lazy_static! is similar to the way we used it in version parsing. The main differences are we now look for an operation before the major version, and each of the major, minor, and patch versions can be either a number or a wildcard.

There is no matching for build tags, either. Apparently build tags are not to be used on range specifications...or are they?

+

-

src/lib.rs

src/range.rs

3.1.1 Begin range parsing with regex to match strings

src/lib.rs

src/range.rs

3.1.2 Fix some regexes

Conflicts: src/range.rs

src/range.rs

3.2 Add enums and structs for range parsing

Let's define all the nifty types we'll need!

src/range.rs

We've described some of these back in the introduction to range parsing, but a little more won't hurt.

VersionReq contains one or more predicates. This is what we need to supply to the semver crate.

Predicate is similar to the Version struct we used in the version parsing module, but the types are slightly different. We have added the Op field and the minor and patch versions are now optional.

Op stands for operator. The operator defines how to match a specific version to this predicate.

WildcardVersion is used for the Wildcard operator. There might be a wildcard at the major, minor, or patch version. Since they are numeric types, we don't assign Wildcard to the field directly, instead we list it as the operator.

We'll also pull in version::Identifier, for use with the prerelease strings. I wonder if that should have been common::Identifier. Hmm.

+

-

src/range.rs

⋮

3.2.1 Add structs and enums for ranges

src/range.rs

⋮

3.2.2 Make predicate fields public

src/range.rs

3.3 Add traits for range parsing

Implementing traits will give our new structs and enums some extra behavior. Most of them come along automatically!

src/range.rs

We can derive Debug and PartialEq with just the derive annotation.

The FromStr trait lets us turn a string into a value of the type. So when we find an equal sign, we can automatically turn it into the Op::Ex operator.

+

-

src/range.rs

⋮

3.3.1 Add traits for range structs

src/range.rs

⋮

3.3.2 Add Debug for VersionReq

src/range.rs

3.4 Add the parsing function, with just major wildcard support

Finally, it's here! The function that does the real work. We'll put this together in a couple steps to keep things simple.

src/range.rs

So, we parse the range string into a Result<VersionReq, String>. This is similar to the signature of version::Parse.

If the string was null, we'll just respond with an error.

The only kind of version we'll accept for now is a wildcard in the major version number. This can be represented in four different ways. We just create a single-element vector with a Predicate inside and return it.

+

-

src/range.rs

3.4.1 Add range parsing for major version wildcard

src/range.rs

3.4.2 Add check for empty

src/range.rs

3.4.3 Change range to ranges

src/range.rs

3.5 Add major, minor, patch, and pre support

So much for splitting this into multiple steps! Turns out, there is a lot of repetition going on here. We can describe what's going on in a lot less space than the large diff takes up.

src/range.rs

First, we run the regex on our string and get the captures variable. Then we get a variable out of each field we captured. Finally, we build a Predicate with them and return it.

In gathering the operation, the map(str::parse) call runs the FromStr code we implemented in a previous step. If no operation is listed, we use the default, Op::Compatible.

Parsing the major version number might result in an error such as integer overflow, so we need to be a little careful with a match instead of just unwrapping.

The minor and patch fields go through very similar steps. They are both optional and could also encounter errors, so multiple layers of match are used. The innermost match checks if the version was a wildcard. If it was, we override the Op that was set, instead changing it to the applicable WildcardVersion.

+

-

src/range.rs

⋮

3.5.1 Add support for other range types

src/range.rs

⋮

3.5.2 Remove trailing whitespace

src/range.rs

⋮

3.5.3 Check for integer overflow on major version number

src/range.rs

⋮

3.5.4 remove unnecessary 'first'

src/range.rs

3.5.5 Check for integer overflow in minor parsing

src/range.rs

3.5.6 Check for integer overflow in patch

src/range.rs

3.6 Add support for multiple predicates

We're supposed to be able to handle multiple predicates, but so far our code only works with one.

src/range.rs

Let's split the parse function up. Most of what we already had will be called parse_predicate. It works on one predicate at a time.

We'll use parse to split apart the string on commas and send each portion to parse_predicate. A quick bit of error checking verifies that we have at least one predicate, then we can return our VersionReq.

+

-

src/range.rs

⋮

3.6.1 Add support for multiple range predicates

Conflicts: src/range.rs

src/range.rs

⋮

3.6.2 Change range to ranges

src/range.rs

3.7 Add build tag to regex

As hinted earlier, apparently we do need to allow for a build string in the range specification.

src/range.rs

If there was a build string in the predicate, we'll at least accept it. So far we aren't doing anything with this capture group, but it's there.

	1	[package]
	2	name = "semver-parser"
	3	version = "0.6.2"
	4	authors = ["Steve Klabnik <[email protected]>"]
	5	license = "MIT/Apache-2.0"
	6	repository = "https://github.com/steveklabnik/semver-parser"
	7	homepage = "https://github.com/steveklabnik/semver-parser"
	8	documentation = "https://docs.rs/semver-parser"
	9	description = """
	10	Parsing of the semver spec
	11	"""
	12
	13	[dependencies]
	14	regex = "0.1"
	15	lazy_static = "0.2.1"

	1	Copyright (c) 2016 Steve Klabnik
	2
	3	Permission is hereby granted, free of charge, to any
	4	person obtaining a copy of this software and associated
	5	documentation files (the "Software"), to deal in the
	6	Software without restriction, including without
	7	limitation the rights to use, copy, modify, merge,
	8	publish, distribute, sublicense, and/or sell copies of
	9	the Software, and to permit persons to whom the Software
	10	is furnished to do so, subject to the following
	11	conditions:
	12
	13	The above copyright notice and this permission notice
	14	shall be included in all copies or substantial portions
	15	of the Software.
	16
	17	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
	18	ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
	19	TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
	20	PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
	21	SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	22	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	23	OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
	24	IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	25	DEALINGS IN THE SOFTWARE.

	1	[package]
	2	name = "semver-parser"
	3	version = "0.1.0"
	4	authors = ["Steve Klabnik <[email protected]>"]
	5
	6	[dependencies]
	7	regex = "0.1.69"

2	2	name = "semver-parser"
3	3	version = "0.1.0"
4	4	authors = ["Steve Klabnik <[email protected]>"]
	5	license = "MIT/Apache-2.0"
	6	repository = "https://github.com/steveklabnik/semver-parser"
	7	homepage = "https://github.com/steveklabnik/semver-parser"
	8	documentation = "http://steveklabnik.github.io/semver-parser"
	9	description = """
	10	Parsing of the semver spec
	11	"""
5	12
6	13	[dependencies]
7	14	regex = "0.1.69"

1	1	[package]
2	2	name = "semver-parser"
3		version = "0.1.0"
	3	version = "0.2.0"
4	4	authors = ["Steve Klabnik <[email protected]>"]
5	5	license = "MIT/Apache-2.0"
6	6	repository = "https://github.com/steveklabnik/semver-parser"

	1	Apache License
	2	Version 2.0, January 2004
	3	http://www.apache.org/licenses/
	4
	5	TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
	6
	7	1. Definitions.
	8
	9	"License" shall mean the terms and conditions for use, reproduction,
	10	and distribution as defined by Sections 1 through 9 of this document.
	11
	12	"Licensor" shall mean the copyright owner or entity authorized by
	13	the copyright owner that is granting the License.
	14
	15	"Legal Entity" shall mean the union of the acting entity and all
	16	other entities that control, are controlled by, or are under common
	17	control with that entity. For the purposes of this definition,
	18	"control" means (i) the power, direct or indirect, to cause the
	19	direction or management of such entity, whether by contract or
	20	otherwise, or (ii) ownership of fifty percent (50%) or more of the
	21	outstanding shares, or (iii) beneficial ownership of such entity.
	22
	23	"You" (or "Your") shall mean an individual or Legal Entity
	24	exercising permissions granted by this License.
	25
	26	"Source" form shall mean the preferred form for making modifications,
	27	including but not limited to software source code, documentation
	28	source, and configuration files.
	29
	30	"Object" form shall mean any form resulting from mechanical
	31	transformation or translation of a Source form, including but
	32	not limited to compiled object code, generated documentation,
	33	and conversions to other media types.
	34
	35	"Work" shall mean the work of authorship, whether in Source or
	36	Object form, made available under the License, as indicated by a
	37	copyright notice that is included in or attached to the work
	38	(an example is provided in the Appendix below).
	39
	40	"Derivative Works" shall mean any work, whether in Source or Object
	41	form, that is based on (or derived from) the Work and for which the
	42	editorial revisions, annotations, elaborations, or other modifications
	43	represent, as a whole, an original work of authorship. For the purposes
	44	of this License, Derivative Works shall not include works that remain
	45	separable from, or merely link (or bind by name) to the interfaces of,
	46	the Work and Derivative Works thereof.
	47
	48	"Contribution" shall mean any work of authorship, including
	49	the original version of the Work and any modifications or additions
	50	to that Work or Derivative Works thereof, that is intentionally
	51	submitted to Licensor for inclusion in the Work by the copyright owner
	52	or by an individual or Legal Entity authorized to submit on behalf of
	53	the copyright owner. For the purposes of this definition, "submitted"
	54	means any form of electronic, verbal, or written communication sent
	55	to the Licensor or its representatives, including but not limited to
	56	communication on electronic mailing lists, source code control systems,
	57	and issue tracking systems that are managed by, or on behalf of, the
	58	Licensor for the purpose of discussing and improving the Work, but
	59	excluding communication that is conspicuously marked or otherwise
	60	designated in writing by the copyright owner as "Not a Contribution."
	61
	62	"Contributor" shall mean Licensor and any individual or Legal Entity
	63	on behalf of whom a Contribution has been received by Licensor and
	64	subsequently incorporated within the Work.
	65
	66	2. Grant of Copyright License. Subject to the terms and conditions of
	67	this License, each Contributor hereby grants to You a perpetual,
	68	worldwide, non-exclusive, no-charge, royalty-free, irrevocable
	69	copyright license to reproduce, prepare Derivative Works of,
	70	publicly display, publicly perform, sublicense, and distribute the
	71	Work and such Derivative Works in Source or Object form.
	72
	73	3. Grant of Patent License. Subject to the terms and conditions of
	74	this License, each Contributor hereby grants to You a perpetual,
	75	worldwide, non-exclusive, no-charge, royalty-free, irrevocable
	76	(except as stated in this section) patent license to make, have made,
	77	use, offer to sell, sell, import, and otherwise transfer the Work,
	78	where such license applies only to those patent claims licensable
	79	by such Contributor that are necessarily infringed by their
	80	Contribution(s) alone or by combination of their Contribution(s)
	81	with the Work to which such Contribution(s) was submitted. If You
	82	institute patent litigation against any entity (including a
	83	cross-claim or counterclaim in a lawsuit) alleging that the Work
	84	or a Contribution incorporated within the Work constitutes direct
	85	or contributory patent infringement, then any patent licenses
	86	granted to You under this License for that Work shall terminate
	87	as of the date such litigation is filed.
	88
	89	4. Redistribution. You may reproduce and distribute copies of the
	90	Work or Derivative Works thereof in any medium, with or without
	91	modifications, and in Source or Object form, provided that You
	92	meet the following conditions:
	93
	94	(a) You must give any other recipients of the Work or
	95	Derivative Works a copy of this License; and
	96
	97	(b) You must cause any modified files to carry prominent notices
	98	stating that You changed the files; and
	99
	100	(c) You must retain, in the Source form of any Derivative Works
	101	that You distribute, all copyright, patent, trademark, and
	102	attribution notices from the Source form of the Work,
	103	excluding those notices that do not pertain to any part of
	104	the Derivative Works; and
	105
	106	(d) If the Work includes a "NOTICE" text file as part of its
	107	distribution, then any Derivative Works that You distribute must
	108	include a readable copy of the attribution notices contained
	109	within such NOTICE file, excluding those notices that do not
	110	pertain to any part of the Derivative Works, in at least one
	111	of the following places: within a NOTICE text file distributed
	112	as part of the Derivative Works; within the Source form or
	113	documentation, if provided along with the Derivative Works; or,
	114	within a display generated by the Derivative Works, if and
	115	wherever such third-party notices normally appear. The contents
	116	of the NOTICE file are for informational purposes only and
	117	do not modify the License. You may add Your own attribution
	118	notices within Derivative Works that You distribute, alongside
	119	or as an addendum to the NOTICE text from the Work, provided
	120	that such additional attribution notices cannot be construed
	121	as modifying the License.
	122
	123	You may add Your own copyright statement to Your modifications and
	124	may provide additional or different license terms and conditions
	125	for use, reproduction, or distribution of Your modifications, or
	126	for any such Derivative Works as a whole, provided Your use,
	127	reproduction, and distribution of the Work otherwise complies with
	128	the conditions stated in this License.
	129
	130	5. Submission of Contributions. Unless You explicitly state otherwise,
	131	any Contribution intentionally submitted for inclusion in the Work
	132	by You to the Licensor shall be under the terms and conditions of
	133	this License, without any additional terms or conditions.
	134	Notwithstanding the above, nothing herein shall supersede or modify
	135	the terms of any separate license agreement you may have executed
	136	with Licensor regarding such Contributions.
	137
	138	6. Trademarks. This License does not grant permission to use the trade
	139	names, trademarks, service marks, or product names of the Licensor,
	140	except as required for reasonable and customary use in describing the
	141	origin of the Work and reproducing the content of the NOTICE file.
	142
	143	7. Disclaimer of Warranty. Unless required by applicable law or
	144	agreed to in writing, Licensor provides the Work (and each
	145	Contributor provides its Contributions) on an "AS IS" BASIS,
	146	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
	147	implied, including, without limitation, any warranties or conditions
	148	of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
	149	PARTICULAR PURPOSE. You are solely responsible for determining the
	150	appropriateness of using or redistributing the Work and assume any
	151	risks associated with Your exercise of permissions under this License.
	152
	153	8. Limitation of Liability. In no event and under no legal theory,
	154	whether in tort (including negligence), contract, or otherwise,
	155	unless required by applicable law (such as deliberate and grossly
	156	negligent acts) or agreed to in writing, shall any Contributor be
	157	liable to You for damages, including any direct, indirect, special,
	158	incidental, or consequential damages of any character arising as a
	159	result of this License or out of the use or inability to use the
	160	Work (including but not limited to damages for loss of goodwill,
	161	work stoppage, computer failure or malfunction, or any and all
	162	other commercial damages or losses), even if such Contributor
	163	has been advised of the possibility of such damages.
	164
	165	9. Accepting Warranty or Additional Liability. While redistributing
	166	the Work or Derivative Works thereof, You may choose to offer,
	167	and charge a fee for, acceptance of support, warranty, indemnity,
	168	or other liability obligations and/or rights consistent with this
	169	License. However, in accepting such obligations, You may act only
	170	on Your own behalf and on Your sole responsibility, not on behalf
	171	of any other Contributor, and only if You agree to indemnify,
	172	defend, and hold each Contributor harmless for any liability
	173	incurred by, or claims asserted against, such Contributor by reason
	174	of your accepting any such warranty or additional liability.
	175
	176	END OF TERMS AND CONDITIONS
	177
	178	APPENDIX: How to apply the Apache License to your work.
	179
	180	To apply the Apache License to your work, attach the following
	181	boilerplate notice, with the fields enclosed by brackets "[]"
	182	replaced with your own identifying information. (Don't include
	183	the brackets!) The text should be enclosed in the appropriate
	184	comment syntax for the file format. We also recommend that a
	185	file or class name and description of purpose be included on the
	186	same "printed page" as the copyright notice for easier
	187	identification within third-party archives.
	188
	189	Copyright [yyyy] [name of copyright owner]
	190
	191	Licensed under the Apache License, Version 2.0 (the "License");
	192	you may not use this file except in compliance with the License.
	193	You may obtain a copy of the License at
	194
	195	http://www.apache.org/licenses/LICENSE-2.0
	196
	197	Unless required by applicable law or agreed to in writing, software
	198	distributed under the License is distributed on an "AS IS" BASIS,
	199	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	200	See the License for the specific language governing permissions and
	201	limitations under the License.

1	1	[package]
2	2	name = "semver-parser"
3		version = "0.3.0"
	3	version = "0.4.0"
4	4	authors = ["Steve Klabnik <[email protected]>"]
5	5	license = "MIT/Apache-2.0"
6	6	repository = "https://github.com/steveklabnik/semver-parser"

1	1	[package]
2	2	name = "semver-parser"
3		version = "0.4.1"
	3	version = "0.5.0"
4	4	authors = ["Steve Klabnik <[email protected]>"]
5	5	license = "MIT/Apache-2.0"
6	6	repository = "https://github.com/steveklabnik/semver-parser"

1	1	[package]
2	2	name = "semver-parser"
3		version = "0.5.1"
	3	version = "0.6.0"
4	4	authors = ["Steve Klabnik <[email protected]>"]
5	5	license = "MIT/Apache-2.0"
6	6	repository = "https://github.com/steveklabnik/semver-parser"

	1	use regex::Regex;
	2	use version::Identifier;
	3
	4	// by the time we get here, we know that it's all valid characters, so this doesn't need to return
	5	// a result or anything
	6	pub fn parse_meta(s: &str) -> Vec<Identifier> {
	7	// Originally, I wanted to implement this method via calling parse, but parse is tolerant of
	8	// leading zeroes, and we want anything with leading zeroes to be considered alphanumeric, not
	9	// numeric. So the strategy is to check with a regex first, and then call parse once we've
	10	// determined that it's a number without a leading zero.
	11	s.split(".")
	12	.map(\|part\| {
	13	// another wrinkle: we made sure that any number starts with a
	14	// non-zero. But there's a problem: an actual zero is a number, yet
	15	// gets left out by this heuristic. So let's also check for the
	16	// single, lone zero.
	17	if is_alpha_numeric(part) {
	18	Identifier::AlphaNumeric(part.to_string())
	19	} else {
	20	// we can unwrap here because we know it is only digits due to the regex
	21	Identifier::Numeric(part.parse().unwrap())
	22	}
	23	}).collect()
	24	}
	25
	26	pub fn is_alpha_numeric(s: &str) -> bool {
	27	lazy_static! {
	28	static ref REGEX: Regex = Regex::new(r"^(0\|[1-9][0-9]*)$").unwrap();
	29	};
	30	!REGEX.is_match(s)
	31	}

	1	extern crate regex;
	2
	3	#[macro_use]
	4	extern crate lazy_static;
	5
	6	pub mod version;
	7
	8	// for private stuff the two share
	9	mod common;

	1	use std::fmt;
	2
	3	use regex::Regex;
	4	use common;
	5
	6	lazy_static! {
	7	static ref REGEX: Regex = {
	8	// a numeric identifier is either zero or multiple numbers without a leading zero
	9	let numeric_identifier = r"0\|(?:[1-9][0-9]*)";
	10
	11	let major = numeric_identifier;
	12	let minor = numeric_identifier;
	13	let patch = numeric_identifier;
	14
	15	let letters_numbers_dash_dot = r"[-.A-Za-z0-9]+";
	16
	17	// This regex does not fully parse prereleases, just extracts the whole prerelease string.
	18	// parse_version() will parse this further.
	19	let pre = letters_numbers_dash_dot;
	20
	21	// This regex does not fully parse builds, just extracts the whole build string.
	22	// parse_version() will parse this further.
	23	let build = letters_numbers_dash_dot;
	24
	25	let regex = format!(r"^(?x) # heck yes x mode
	26	(?P<major>{}) # major version
	27	\. # dot
	28	(?P<minor>{}) # minor version
	29	\. # dot
	30	(?P<patch>{}) # patch version
	31	(?:-(?P<pre>{}))? # optional prerelease version
	32	(?:\+(?P<build>{}))? # optional build metadata
	33	$",
	34	major,
	35	minor,
	36	patch,
	37	pre,
	38	build);
	39	let regex = Regex::new(&regex);
	40
	41	// this unwrap is okay because everything above here is const, so this will never fail.
	42	regex.unwrap()
	43	};
	44	}
	45
	46	#[derive(Clone, Debug, PartialEq, Eq)]
	47	pub struct Version {
	48	pub major: u64,
	49	pub minor: u64,
	50	pub patch: u64,
	51	pub pre: Vec<Identifier>,
	52	pub build: Vec<Identifier>,
	53	}
	54
	55	#[derive(Clone, Debug, PartialEq, Eq)]
	56	pub enum Identifier {
	57	/// An identifier that's solely numbers.
	58	Numeric(u64),
	59	/// An identifier with letters and numbers.
	60	AlphaNumeric(String),
	61	}
	62
	63	pub fn parse(version: &str) -> Result<Version, String> {
	64	let captures = match REGEX.captures(version.trim()) {
	65	Some(captures) => captures,
	66	None => return Err(From::from("Version did not parse properly.")),
	67	};
	68
	69	let pre = captures.name("pre").map(common::parse_meta).unwrap_or(vec![]);
	70
	71	let build = captures.name("build").map(common::parse_meta).unwrap_or(vec![]);
	72
	73	Ok(Version {
	74	major: captures.name("major").unwrap().parse().unwrap(),
	75	minor: captures.name("minor").unwrap().parse().unwrap(),
	76	patch: captures.name("patch").unwrap().parse().unwrap(),
	77	pre: pre,
	78	build: build,
	79	})
	80	}
	81
	82	impl fmt::Display for Version {
	83	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	84	try!(write!(f, "{}.{}.{}", self.major, self.minor, self.patch));
	85	if !self.pre.is_empty() {
	86	let strs: Vec<_> =
	87	self.pre.iter().map(ToString::to_string).collect();
	88	try!(write!(f, "-{}", strs.join(".")));
	89	}
	90	if !self.build.is_empty() {
	91	let strs: Vec<_> =
	92	self.build.iter().map(ToString::to_string).collect();
	93	try!(write!(f, "+{}", strs.join(".")));
	94	}
	95	Ok(())
	96	}
	97	}
	98
	99	impl fmt::Display for Identifier {
	100	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	101	match *self {
	102	Identifier::Numeric(ref id) => id.fmt(f),
	103	Identifier::AlphaNumeric(ref id) => id.fmt(f),
	104	}
	105	}
	106	}

3	3	use regex::Regex;
4	4
5	5	pub struct Version {
6		major: u64,
7		minor: u64,
8		patch: u64,
	6	pub major: u64,
	7	pub minor: u64,
	8	pub patch: u64,
9	9	}
10	10
11	11	pub fn parse_version(version: &str) -> Version {

7	7
8	8	lazy_static! {
9	9	static ref REGEX: Regex = {
10		let major = r"0\|(:?[1-9][0-9]*)";
11		let minor = r"0\|(:?[1-9][0-9]*)";
12		let patch = r"0\|(:?[1-9][0-9]*)";
	10	// a numeric identifier is either zero or multiple numbers without a leading zero
	11	let numeric_identifier = r"0\|(:?[1-9][0-9]*)";
13	12
	13	let major = numeric_identifier;
	14	let minor = numeric_identifier;
	15	let patch = numeric_identifier;
	16
14	17	let regex = format!(r"^(?P<major>{})\.(?P<minor>{})\.(?P<patch>{})$", major, minor, patch);
15	18	let regex = Regex::new(&regex);
16	19

29	29	}
30	30
31	31	pub fn parse_version(version: &str) -> Result<Version, Box<Error>> {
32		let captures = match REGEX.captures(version) {
	32	let captures = match REGEX.captures(version.trim()) {
33	33	Some(captures) => captures,
34	34	None => return Err(From::from("Version did not parse properly.")),
35	35	};

3	3
4	4	use regex::Regex;
5	5
6		use std::error::Error;
7
8	6	lazy_static! {
9	7	static ref REGEX: Regex = {
10	8	// a numeric identifier is either zero or multiple numbers without a leading zero

29	47	None => return Err(From::from("Version did not parse properly.")),
30	48	};
31	49
	50	let pre = captures.name("pre").map(\|pre\| {
	51	vec![pre.to_string()]
	52	});
	53
32	54	Ok(Version {
33	55	major: captures.name("major").unwrap().parse().unwrap(),
34	56	minor: captures.name("minor").unwrap().parse().unwrap(),
35	57	patch: captures.name("patch").unwrap().parse().unwrap(),
	58	pre: pre,
36	59	})
37	60	}

9	9	let minor = numeric_identifier;
10	10	let patch = numeric_identifier;
11	11
12		let pre = r"\w+";
	12	let letters_numbers_dash_dot = r"[.-A-Za-z0-9]+";
	13
	14	// This regex does not fully parse prereleases, just extracts the whole prerelease string.
	15	// parse_version() will parse this further.
	16	let pre = letters_numbers_dash_dot;
13	17
14	18	let regex = format!(r"^(?P<major>{})\.(?P<minor>{})\.(?P<patch>{})(:?-(?P<pre>{}))?$", major, minor, patch, pre);
15	19	println!("{}", regex);

39	45	pub minor: u64,
40	46	pub patch: u64,
41	47	pub pre: Option<Vec<String>>,
	48	pub build: Option<Vec<String>>,
42	49	}
43	50
44	51	pub fn parse_version(version: &str) -> Result<Version, String> {

51	58	vec![pre.to_string()]
52	59	});
53	60
	61	let build = captures.name("build").map(\|build\| {
	62	vec![build.to_string()]
	63	});
	64
54	65	Ok(Version {
55	66	major: captures.name("major").unwrap().parse().unwrap(),
56	67	minor: captures.name("minor").unwrap().parse().unwrap(),
57	68	patch: captures.name("patch").unwrap().parse().unwrap(),
58	69	pre: pre,
	70	build: build,
59	71	})
60	72	}

86	86
87	87	pre.split(".")
88	88	.map(\|part\| {
89		if regex.is_match(part) {
	89	// another wrinkle: we made sure that any number starts with a non-zero. But there's a
	90	// problem: an actual zero is a number, yet gets left out by this heuristic. So let's
	91	// also check for the single, lone zero.
	92	if regex.is_match(part) \|\| part == "0" {
90	93	// we can unwrap here because we know it is only digits due to the regex
91	94	Identifier::Numeric(part.parse().unwrap())
92	95	} else {

48	48	pub build: Option<Vec<Identifier>>,
49	49	}
50	50
51		#[derive(Debug,PartialEq)]
52	51	pub enum Identifier {
53	52	/// An identifier that's solely numbers.
54	53	Numeric(u64),

61	61	None => return Err(From::from("Version did not parse properly.")),
62	62	};
63	63
64		let pre = captures.name("pre").map(parse_meta);
	64	let pre = captures.name("pre").map(parse_meta).unwrap_or(vec![]);
65	65
66		let build = captures.name("build").map(parse_meta);
	66	let build = captures.name("build").map(parse_meta).unwrap_or(vec![]);
67	67
68	68	Ok(Version {
69	69	major: captures.name("major").unwrap().parse().unwrap(),

78	79	})
79	80	}
80	81
81		// by the time we get here, we know that it's all valid characters, so this doesn't need to return
82		// a result or anything
83		fn parse_meta(pre: &str) -> Vec<Identifier> {
84		// Originally, I wanted to implement this method via calling parse, but parse is tolerant of
85		// leading zeroes, and we want anything with leading zeroes to be considered alphanumeric, not
86		// numeric. So the strategy is to check with a regex first, and then call parse once we've
87		// determined that it's a number without a leading zero.
88		let regex = Regex::new(r"^[1-9][0-9]*$").unwrap();
89
90		pre.split(".")
91		.map(\|part\| {
92		// another wrinkle: we made sure that any number starts with a non-zero. But there's a
93		// problem: an actual zero is a number, yet gets left out by this heuristic. So let's
94		// also check for the single, lone zero.
95		if regex.is_match(part) \|\| part == "0" {
96		// we can unwrap here because we know it is only digits due to the regex
97		Identifier::Numeric(part.parse().unwrap())
98		} else {
99		Identifier::AlphaNumeric(part.to_string())
100		}
101		}).collect()
102
103	82	impl fmt::Display for Version {
104	83	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
105	84	try!(write!(f, "{}.{}.{}", self.major, self.minor, self.patch));

3	3
4	4	// by the time we get here, we know that it's all valid characters, so this doesn't need to return
5	5	// a result or anything
6		pub fn parse_meta(pre: &str) -> Vec<Identifier> {
	6	pub fn parse_meta(s: &str) -> Vec<Identifier> {
7	7	// Originally, I wanted to implement this method via calling parse, but parse is tolerant of
8	8	// leading zeroes, and we want anything with leading zeroes to be considered alphanumeric, not
9	9	// numeric. So the strategy is to check with a regex first, and then call parse once we've
10	10	// determined that it's a number without a leading zero.
11		let regex = Regex::new(r"^[1-9][0-9]*$").unwrap();
12
13		pre.split(".")
	11	s.split(".")
14	12	.map(\|part\| {
15		// another wrinkle: we made sure that any number starts with a non-zero. But there's a
16		// problem: an actual zero is a number, yet gets left out by this heuristic. So let's
17		// also check for the single, lone zero.
18		if regex.is_match(part) \|\| part == "0" {
	13	// another wrinkle: we made sure that any number starts with a
	14	// non-zero. But there's a problem: an actual zero is a number, yet
	15	// gets left out by this heuristic. So let's also check for the
	16	// single, lone zero.
	17	if is_alpha_numeric(part) {
	18	Identifier::AlphaNumeric(part.to_string())
	19	} else {
19	20	// we can unwrap here because we know it is only digits due to the regex
20	21	Identifier::Numeric(part.parse().unwrap())
21		} else {
22		Identifier::AlphaNumeric(part.to_string())
23	22	}
24	23	}).collect()
25	24	}
26	25
	26	pub fn is_alpha_numeric(s: &str) -> bool {
	27	lazy_static! {
	28	static ref REGEX: Regex = Regex::new(r"^(0\|[1-9][0-9]*)$").unwrap();
	29	};
	30	!REGEX.is_match(s)
	31	}

4	4	extern crate lazy_static;
5	5
6	6	pub mod version;
	7	pub mod range;
7	8
8	9	// for private stuff the two share
9	10	mod common;

11	11	// * <=
12	12	// * ~
13	13	// * ^
14		let operation = r"=\|>\|(:?>=)\|<\|(:?<=)\|~\|\^";
	14	let operation = r"=\|>\|>=\|<\|<=\|~\|\^";
15	15
16	16	// a numeric identifier is either zero or multiple numbers without a leading zero
17		let numeric_identifier = r"0\|(:?[1-9][0-9]*)";
	17	let numeric_identifier = r"0\|[1-9][0-9]*";
18	18
19	19	let major = numeric_identifier;
20	20
21	21	// minor can be either a number or a wildcard. *, x, and X are wildcards.
22		let minor = format!(r"(:?{})\|\*\|[xX]", numeric_identifier);
	22	let minor = format!(r"{}\|\*\|[xX]", numeric_identifier);
23	23
24	24	// patch can be either a number or a wildcard. *, x, and X are wildcards.
25		let patch = format!(r"(:?{})\|\*\|[xX]", numeric_identifier);
	25	let patch = format!(r"{}\|\*\|[xX]", numeric_identifier);
26	26
27	27	let letters_numbers_dash_dot = r"[-.A-Za-z0-9]+";
28	28
29	29	// This regex does not fully parse prereleases, just extracts the whole prerelease string.
30	30	// parse_version() will parse this further.
31	31	let pre = letters_numbers_dash_dot;
32
33		let regex = format!(r"^(?x) # heck yes x mode
	32
	33	let regex = format!(r"(?x) # heck yes x mode
	34	^\s* # leading whitespace
34	35	(?P<operation>{})?\s* # optional operation
35	36	(?P<major>{}) # major version
36		(:?\.(?P<minor>{}))? # optional dot and then minor
37		(:?\.(?P<patch>{}))? # optional dot and then patch
38		(:?-(?P<pre>{}))? # optional prerelease version
39		$",
	37	(?:\.(?P<minor>{}))? # optional dot and then minor
	38	(?:\.(?P<patch>{}))? # optional dot and then patch
	39	(?:-(?P<pre>{}))? # optional prerelease version
	40	\s*$ # trailing whitespace
	41	",
40	42	operation,
41	43	major,
42	44	minor,
43	45	patch,
44	46	pre);
45	47	let regex = Regex::new(&regex);
46
	48
47	49	// this unwrap is okay because everything above here is const, so this will never fail.
48	50	regex.unwrap()
49	51	};

50	51	regex.unwrap()
51	52	};
52	53	}
	54
	55	pub struct VersionReq {
	56	pub predicates: Vec<Predicate>,
	57	}
	58
	59	pub enum WildcardVersion {
	60	Major,
	61	Minor,
	62	Patch,
	63	}
	64
	65	pub enum Op {
	66	Ex, // Exact
	67	Gt, // Greater than
	68	GtEq, // Greater than or equal to
	69	Lt, // Less than
	70	LtEq, // Less than or equal to
	71	Tilde, // e.g. ~1.0.0
	72	Compatible, // compatible by definition of semver, indicated by ^
	73	Wildcard(WildcardVersion), // x.y., x., *
	74	}
	75
	76	pub struct Predicate {
	77	pub op: Op,
	78	pub major: u64,
	79	pub minor: Option<u64>,
	80	pub patch: Option<u64>,
	81	pub pre: Vec<Identifier>,
	82	}

74	74	}
75	75
76	76	pub struct Predicate {
77		op: Op,
78		major: u64,
79		minor: Option<u64>,
80		patch: Option<u64>,
81		pre: Vec<Identifier>,
	77	pub op: Op,
	78	pub major: u64,
	79	pub minor: Option<u64>,
	80	pub patch: Option<u64>,
	81	pub pre: Vec<Identifier>,
82	82	}

1	1	use regex::Regex;
2	2	use version::Identifier;
	3	use std::str::FromStr;
3	4
4	5	lazy_static! {
5	6	static ref REGEX: Regex = {

52	53	};
53	54	}
54	55
	56	#[derive(Debug)]
55	57	pub struct VersionReq {
56	58	pub predicates: Vec<Predicate>,
57	59	}
58	60
	61	#[derive(PartialEq,Debug)]
59	62	pub enum WildcardVersion {
60	63	Major,
61	64	Minor,
62	65	Patch,
63	66	}
64	67
	68	#[derive(PartialEq,Debug)]
65	69	pub enum Op {
66	70	Ex, // Exact
67	71	Gt, // Greater than

73	77	Wildcard(WildcardVersion), // x.y., x., *
74	78	}
75	79
	80	impl FromStr for Op {
	81	type Err = String;
	82
	83	fn from_str(s: &str) -> Result<Op, String> {
	84	match s {
	85	"=" => Ok(Op::Ex),
	86	">" => Ok(Op::Gt),
	87	">=" => Ok(Op::GtEq),
	88	"<" => Ok(Op::Lt),
	89	"<=" => Ok(Op::LtEq),
	90	"~" => Ok(Op::Tilde),
	91	"^" => Ok(Op::Compatible),
	92	_ => Err(String::from("Could not parse Op")),
	93	}
	94	}
	95	}
	96
	97	#[derive(PartialEq,Debug)]
76	98	pub struct Predicate {
77	99	pub op: Op,
78	100	pub major: u64,

102	102	pub patch: Option<u64>,
103	103	pub pre: Vec<Identifier>,
104	104	}
	105
	106	pub fn parse(ranges: &str) -> Result<VersionReq, String> {
	107	// null is an error
	108	if ranges == "\0" {
	109	return Err(String::from("Null is not a valid VersionReq"));
	110	}
	111
	112	// an empty range is a major version wildcard
	113	// so is a lone * or x of either capitalization
	114	if (ranges == "")
	115	\|\| (ranges == "*")
	116	\|\| (ranges == "x")
	117	\|\| (ranges == "X") {
	118	return Ok(VersionReq {
	119	predicates: vec![Predicate {
	120	op: Op::Wildcard(WildcardVersion::Major),
	121	major: 0,
	122	minor: None,
	123	patch: None,
	124	pre: Vec::new(),
	125	}],
	126	});
	127	}
	128	}

102	102	pub patch: Option<u64>,
103	103	pub pre: Vec<Identifier>,
104	104	}
	105
	106	pub fn parse(range: &str) -> Result<VersionReq, String> {
	107	// an empty range is a major version wildcard
	108	// so is a lone * or x of either capitalization
	109	if (range == "")
	110	\|\| (range == "*")
	111	\|\| (range == "x")
	112	\|\| (range == "X") {
	113	return Ok(VersionReq {
	114	predicates: vec![Predicate {
	115	op: Op::Wildcard(WildcardVersion::Major),
	116	major: 0,
	117	minor: None,
	118	patch: None,
	119	pre: Vec::new(),
	120	}],
	121	});
	122	}
	123	}

104	104	}
105	105
106	106	pub fn parse(range: &str) -> Result<VersionReq, String> {
	107	// null is an error
	108	if range == "\0" {
	109	return Err(String::from("Null is not a valid VersionReq"));
	110	}
	111
107	112	// an empty range is a major version wildcard
108	113	// so is a lone * or x of either capitalization
109	114	if (range == "")