commit 24298d6fce66190a4a9de195a60e7b2538b9c470
parent e2adf2957f19cc5a8c2378e9cf5dadd10d3711c0
Author: Remy Noulin <loader2x@gmail.com>
Date: Thu, 21 Mar 2019 15:25:07 -0400
implement versioning with a release number based on semver
Readme.md | 212 +++++++
main.c | 111 ++++
memTest.c.template | 23 +
memcheckVersion.c | 792 +++++++++++++++++++++++++
package.yml | 33 ++
runMemtest.c | 108 ++++
testVersion.c | 818 ++++++++++++++++++++++++++
testVersionMem.sh | 2 +
version.c | 1630 ++++++++++++++++++++++++++++++++++++++++++++++++++++
version.h | 226 ++++++++
versionInternal.h | 7 +
11 files changed, 3962 insertions(+)
Diffstat:
| A | Readme.md | | | 212 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | main.c | | | 111 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | memTest.c.template | | | 24 | ++++++++++++++++++++++++ |
| A | memcheckVersion.c | | | 792 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | package.yml | | | 33 | +++++++++++++++++++++++++++++++++ |
| A | runMemtest.c | | | 109 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | testVersion.c | | | 818 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | testVersionMem.sh | | | 3 | +++ |
| A | version.c | | | 1630 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | version.h | | | 226 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | versionInternal.h | | | 8 | ++++++++ |
11 files changed, 3966 insertions(+), 0 deletions(-)
diff --git a/Readme.md b/Readme.md
@@ -0,0 +1,212 @@
+RelVer:
+
+- [Format](#format)
+- [Summary](#summary)
+- [Versioning](#versioning)
+- [Range matching](#range-matching)
+- [Advandced range Syntax](#advandced-range-syntax)
+
+# Sheepy
+This is a sheepy package for [sheepy](https://github.com/RemyNoulin/sheepy) and using [libsheepy](https://github.com/RemyNoulin/libsheepy)
+
+# Usage
+
+Install with spm: `spm install version`
+
+Include header file:
+- `#include "shpPackages/version/version.h"`
+
+Usage examples are on the top of the headers and in `main.c`.
+
+
+# Format
+
+Release.Major.minor[.Patch[.Other...]][-prerelease][+build]
+
+# Summary
+
+Values in [] are optional, given a version number R.M.m.P.O, increment the:
+1. Release version as you see fit.
+2. Major version when you make incompatible API changes,
+3. Minor version when you add functionality in a backwards-compatible manner, and
+4. Patch version when you make backwards-compatible bug fixes.
+5. Other version when you make internal changes, documentation update, non-visible change, ABI change, dependency updates.
+
+The other optional labels are for pre-release and build metadata.
+
+## Based on semver 2.0.0
+
+- Add release version on front of the major version
+- All version components have a defined sorting order
+- Arbitrary numbers of components
+- The major version number has only one meaning: breaking change, major version 0 is a normal version (simplifies range criteria)
+- Clear criteria for verion numbers, version strings and ordering
+- Range and comparator syntax is specified
+- Prereleases are supported in the comparators (include or exclude)
+
+# Versioning
+
+The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119.
+
+1. Versions MUST have the form Release.Major.minor (R.M.m), and MAY optionally have any number of additional components. All leading characters are ignored.
+2. Other versions (R.M.m.P.O) MUST have a Patch version.
+3. Missing components are equal to 0 or empty strings.
+4. Numbers are digit strings composed of characters in [0-9] and MUST fit in a 64 bit int and MUST NOT contain leading zeroes. Numbers MUST increase numerically: For instance: 1.9.0 -> 1.10.0 -> 1.11.0.
+5. Non numbers are strings composed of alphanumeric characters [a-zA-Z0-9].
+6. Components are separated with dots, hyphen, plus sign and MAY be either numbers or strings and MUST NOT be empty.
+7. Numbers preceded by a dot, a hyphen or a plus sign are sorted numerically.
+8. Release version, Major version, minor version and Patch version MUST be numbers.
+9. Components that are not numbers are sorted using lexicographic ordering.
+10. Once a versioned package has been released, the contents of that version MUST NOT be modified. Any modifications MUST be released as a new version.
+11. Release version 0 (0) is for initial development. Anything may change at any time. The public API should not be considered stable.
+12. Version 1.0 defines the public API. The way in which the version number is incremented after this release is dependent on this public API and how it changes.
+13. Release version R (R.M and R > 0) MUST NOT reset other components.
+14. MAJOR version M (R.M and R > 0) MUST be incremented if any backwards incompatible changes are introduced to the public API. It MAY include minor and patch level changes. Patch and minor version MUST be reset to 0 when major version is incremented.
+15. Minor version m (R.M.m and R > 0) MUST be incremented if new, backwards compatible functionality is introduced to the public API. It MUST be incremented if any public API functionality is marked as deprecated. It MAY be incremented if substantial new functionality or improvements are introduced within the private code. It MAY include patch level changes. Patch version MUST be reset to 0 when minor version is incremented.
+16. Patch version P (R.M.m.P and R > 0) MUST be incremented if only backwards compatible bug fixes are introduced. A bug fix is defined as an internal change that fixes incorrect behavior.
+17. Other version O (R.M.m.P.O and R > 0) is a series of components with meanings as you see fit.
+18. A pre-release version MAY be denoted by appending a hyphen and a series of components (1.0.0-2, 1.0.1-alpha.1). Pre-release versions have a lower precedence than the associated normal version. A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version.
+19. Build metadata MAY be denoted by appending a plus sign and a series of components (1.0-2+b001, 1.0.1-alpha.1+archAmd64.3).
+20. Precedence refers to how versions are compared to each other when ordered. Precedence MUST be calculated by separating the version into Release, Major, minor, Patch, Other and pre-release identifiers and build metadata in that order. Release version has the highest precedence and the most right component has the lowest.
+
+
+## How do I know when to release 1.0.0?
+
+If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backwards compatibility, you should probably already be 1.0.0.
+
+## How to comunicate a major change in the API?
+
+Bump the release version and the Major version.
+
+
+## Doesn’t this discourage rapid development and fast iteration?
+
+Release version zero is all about rapid development. If you’re changing the API every day you should either still be in version 0.y.z or on a separate development branch working on the next major version.
+
+
+## What do I do if I accidentally release a backwards incompatible change as a minor version?
+
+As soon as you realize that you’ve broken the Versioning spec, fix the problem and release a new minor version that corrects the problem and restores backwards compatibility. Even under this circumstance, it is unacceptable to modify versioned releases. If it’s appropriate, document the offending version and inform your users of the problem so that they are aware of the offending version.
+
+
+
+## What should I do if I update my own dependencies without changing the public API?
+
+That would be considered compatible since it does not affect the public API. Software that explicitly depends on the same dependencies as your package should have their own dependency specifications and the author will notice any conflicts. Determining whether the change is a Patch level or minor level modification depends on whether you updated your dependencies in order to fix a bug or introduce new functionality. I would usually expect additional code for the latter instance, in which case it’s obviously a minor level increment.
+
+
+# Range matching
+
+- Numbers are compared numerically
+- Strings are compared using lexicographic ordering
+- Numbers are compared to strings using lexicographic ordering
+
+
+A comparator is composed of an operator and a version. The set of primitive operators is:
+
+- < Less than
+- <= Less than or equal to
+- > Greater than
+- >= Greater than or equal to
+- = Equal. If no operator is specified, then equality is assumed, so this operator is optional, but MAY be included.
+- Adding '-' to the version in a comparator selects the highest prerelease for the specified version
+- Adding '+' to the version in a comparator selects the lowest build for the specified version
+
+For example,
+- the comparator >=1.2.7 would match the versions 1.2.7, 1.2.8, 2.5.3, and 1.3.9, but not the versions 1.2.6 or 1.1.0
+- the comparator >1.2.7- would match 1.2.7 and 1.2.7-alpha.1
+- the comparator >=1.2.7+ would match 1.2.7+arch64.build-1 and 1.2.7 but not and 1.2.7-alpha.1
+
+Comparators can be joined by whitespace to form a comparator set, which is satisfied by the intersection of all of the comparators it includes.
+A range is composed of one or more comparator sets, joined by ||. A version matches a range if and only if every comparator in at least one of the ||-separated comparator sets is satisfied by the version.
+For example, the range >=1.2.7 <1.3.0 would match the versions 1.2.7, 1.2.8, and 1.2.99, but not the versions 1.2.6, 1.3.0, or 1.1.0.
+The range 1.2.7 || >=1.2.9 <2.0.0 would match the versions 1.2.7, 1.2.9, and 1.4.6, but not the versions 1.2.8 or 2.0.0.
+
+# Advandced range Syntax
+
+## Any version x.0.1 X.0.X 1.1.*.0
+
+x,X,* select any value in component in comparators and ranges.
+
+- * := >= 0.0.0 (Any version)
+- x.1.2 := =0.1.2 || =1.1.2 || 2.1.2... (Any release version with specified major.minor)
+- 1.0.0.x.2 := 1.0.0.0.2 || 1.0.0.1.2 || 1.0.0.2.2... (Any patch version with Release.Major.minor equal to 1.0.0 and with other version equal to 2)
+
+## Hyphen Ranges X.Y.Z - A.B.C
+
+Specifies an inclusive set.
+
+- 1.2.3 - 2.3.4 := >=1.2.3 <=2.3.4
+
+If a partial version is provided as the first version in the inclusive range, then the missing pieces are replaced with zeroes.
+
+- 1.2 - 2.3.4 := >=1.2.0 <=2.3.4
+
+If a partial version is provided as the second version in the inclusive range, then all versions that start with the supplied parts of the tuple are accepted, but nothing that would be greater than the provided tuple parts.
+
+- 1.2.3 - 2.3 := >=1.2.3 <2.4.0
+- 1.2.3 - 2 := >=1.2.3 <3.0.0
+
+## X-Ranges 1.2.x 1.X 1.2.* *
+
+Any of X, x or * may be used to "stand in" for any component.
+
+- * := >=0.0.0 (Any version satisfies)
+- 1.x := >=1.0.0- <2.0.0 (Matching major version)
+- 1.2.x := >=1.2.0- <1.3.0 (Matching major and minor versions)
+- 1.*- := >=1.0.0 <2.0.0 (Matching major version and prereleases)
+- 1.X+ := >=1.0.0+ <2.0.0 (Matching major version and build version)
+
+//A partial version range is treated as an X-Range, so the special character is in fact optional.
+// >>> no, eq is without any x,X or *
+
+- "" (empty string) := * := >=0.0.0
+//- 1 := 1.x.x := >=1.0.0 <2.0.0
+//- 1.2 := 1.2.x := >=1.2.0 <1.3.0
+
+## Tilde Ranges ~1.1.2.3 ~1.2.3 ~1.2 ~1
+
+Allows patch-level changes if a minor version is specified on the comparator. Allows minor-level changes if not.
+
+- ~1.1.2.3 := >=1.1.2.3- <1.1.3.0
+- ~1.1.2.3- := >=1.1.2.3 <1.1.3.0 (same as the line above, adds 1.1.2.3 prereleases)
+- ~1.1.2 := >=1.1.2.0- <1.1.3.0 (Same as 1.1.2.x)
+- ~1.1 := >=1.1.0.0- <1.2.0.0 (Same as 1.1.x)
+- ~1 := >=1.0.0- <2.0.0 (Same as 1.x)
+- ~0.2.3 >=0.2.3- <0.3.0
+- ~0.2 := >=0.2.0- <0.3.0 (Same as 0.2.x)
+- ~0 := >=0.0.0- <1.0.0 (same as 0.x)
+- ~0- := >=0.0.0 <1.0.0 (same as 0.x-, same as the line above, adds 0.0.0 prereleases)
+- ~1.2.3-beta.2 := >=1.2.3-beta.2 <1.3.0 Note that prereleases in the 1.2.3 version will be allowed, if they are greater than or equal to beta.2. So, 1.2.3-beta.4 would be allowed, but 1.2.4-beta.2 would not, because it is a prerelease
+ of a different [major, minor, patch] tuple.
+
+The any operator is allowed:
+
+TODO - ~x.1.2.3 := >=0.1.2.3- < 0.1.3.0 || >=1.1.2.3- <1.1.3.0 || >=2.1.2.3- <2.1.3.0 ...
+
+## Caret Ranges ^1.2.3 ^0.2.5 ^0.0.4
+
+Allows changes that do not modify the 2 left-most non-zero digits in the [release, major, minor, patch] tuple. In other words, this allows patch and minor updates.
+
+- ^1.1.2.3 := >=1.1.2.3- <1.2.0.0
+- ^0.0.2.3 := >=0.0.2.3- <0.1.0.0
+- ^0.0.0.3 := >=0.0.0.3- <0.1.0.0
+- ^1.2.3-beta.2 := >=1.2.3-beta.2 <1.3.0 Note that prereleases in the 1.2.3 version will be allowed, if they are greater than or equal to beta.2. So, 1.2.3-beta.4 would be allowed, but 1.2.4-beta.2 would not, because it is a prerelease
+ of a different [major, minor, patch] tuple.
+- ^0.0.3-beta := >=0.0.3-beta <0.1.0 Note that prereleases in the 0.0.3 version only will be allowed, if they are greater than or equal to beta. So, 0.0.3-pr.2 would be allowed.
+
+When parsing caret ranges, a missing patch value desugars to the number 0, but will allow flexibility within that value, even if the major and minor versions are both 0.
+
+- ^1.1.2.x := >=1.1.2.0- <1.2.0.0
+- ^0.0.0.x := >=0.0.0- <0.1.0
+- ^0.0 := >=0.0.0- <0.1.0
+
+A missing minor and patch values will desugar to zero, but also allow flexibility within those values, even if the major version is zero.
+
+- ^1.1.x := >=1.1.0- <1.2.0
+- ^0.0.x := >=0.0.0- <0.1.0
+
+The any operator is allowed:
+
+TODO - ^#.1 := >=0.1.0- < 0.2.0 || >=1.1.0- <1.2.0 || >=2.1.0- <2.2.0 ...
+
diff --git a/main.c b/main.c
@@ -0,0 +1,111 @@
+#! /usr/bin/env sheepy
+/* or direct path to sheepy: #! /usr/local/bin/sheepy */
+
+/* Libsheepy documentation: http://spartatek.se/libsheepy/ */
+#include "libsheepyObject.h"
+#include "version.h"
+#include "shpPackages/short/short.h"
+
+int argc; char **argv;
+
+/* enable/disable logging */
+/* #undef pLog */
+/* #define pLog(...) */
+
+int main(int ARGC, char** ARGV) {
+
+ argc = ARGC; argv = ARGV;
+
+ initLibsheepy(ARGV[0]);
+ setLogMode(LOG_FUNC);
+ setLogSymbols(LOG_UTF8);
+
+ createVersion(ver);
+ goto ltgt;
+
+prerel:
+ /* lv(parseO(&ver, "1.1.1.x-pre")); */
+ /* ver.f->log(&ver); */
+ /* XSUCCESS */
+equal:
+ lv(parseO(&ver, "ver-1.1.2.1.xxv-23+qwe"));
+ logO(&ver);
+ lv(satisfiesO(&ver, "1.1.2.1.x-x+x"))
+ XSUCCESS
+
+ltgt:
+ lv(parseO(&ver, "ver-1.2.3-beta.3"));
+ logO(&ver);
+ var vs = toJsonStrO(&ver);
+ lv(vs);
+ free(vs);
+ lv(satisfiesO(&ver, "~1.2.3-beta.2"))
+ XSUCCESS
+
+inc:
+ lv(parseO(&ver, "1"));
+ var S = toStringO(&ver);
+ lv(S);
+ free(S);
+ incO(&ver, releaseVer);
+ S = toStringO(&ver);
+ lv(S);
+ free(S);
+ incO(&ver, 4);
+ S = toStringO(&ver);
+ lv(S);
+ incO(&ver, patchVer);
+ S = toStringO(&ver);
+ lv(S);
+ free(S);
+ incO(&ver, minorVer);
+ S = toStringO(&ver);
+ lv(S);
+ free(S);
+ incO(&ver, majorVer);
+ S = toStringO(&ver);
+ lv(S);
+ free(S);
+
+build:
+ lv(parseO(&ver, "0.2+pre"));
+ lv(&ver.build);
+ logNFree(toStringO(&ver));
+
+ createVersion(vr);
+ lv(parseO(&vr, "0.2+pre-1"));
+ lv(eqO(&ver, &vr));
+
+cmp:
+ lv(cmpO(&ver, &vr));
+ vr.major--;
+ lv(cmpO(&ver, &vr));
+ vr.major++;
+ vr.minor++;
+ lv(cmpO(&ver, &vr));
+
+json:;
+ var j = toJsonO(&vr);
+ lv(j);
+ terminateG(j);
+ var s = toJsonStrO(&vr);
+ lv(s);
+ fromJsonStrO(&ver, s);
+ free(s);
+
+ logNFree(toStringO(&ver));
+
+sorting:;
+ var arr = createSA("1.1+b.1", "1.1+b", "1.1", "2.0", "1.0", "1.1.1", "1.1-pr", "1.1-pr.1");
+
+ var sorted = vsortO(&ver, arr);
+
+ lv(arr);
+ lv(sorted);
+
+ terminateManyG(arr,sorted);
+
+ freeO(&ver);
+ freeO(&vr);
+}
+// vim: set expandtab ts=2 sw=2:
diff --git a/memTest.c.template b/memTest.c.template
@@ -0,0 +1,23 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define ck_assert_str_eq(a,b) a;b;
+#define ck_assert_str_ne(a,b) a;b;
+#define ck_assert_ptr_eq(a,b) a;b;
+#define ck_assert_ptr_ne(a,b) a;b;
+#define ck_assert_uint_eq(a,b) a;b;
+#define ck_assert_uint_ne(a,b) a;b;
+#define ck_assert_int_eq(a,b) a;b;
+#define ck_assert_int_ne(a,b) a;b;
+#define ck_assert(a) a;
+
+__tests
+
+int main(int n, char**v) {
+
+initLibsheepy(v[0]);
+setLogMode(LOG_FUNC);
+
+__calls
+}+
\ No newline at end of file
diff --git a/memcheckVersion.c b/memcheckVersion.c
@@ -0,0 +1,792 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define ck_assert_str_eq(a,b) a;b;
+#define ck_assert_str_ne(a,b) a;b;
+#define ck_assert_ptr_eq(a,b) a;b;
+#define ck_assert_ptr_ne(a,b) a;b;
+#define ck_assert_uint_eq(a,b) a;b;
+#define ck_assert_uint_ne(a,b) a;b;
+#define ck_assert_int_eq(a,b) a;b;
+#define ck_assert_int_ne(a,b) a;b;
+#define ck_assert(a) a;
+
+
+#include "libsheepyObject.h"
+#include "shpPackages/short/short.h"
+#include "version.h"
+
+int argc; char **argv;
+
+versiont ver;
+
+
+void basetT(void) {
+
+ // STEPS
+ // init
+ // init allocate
+ // terminate
+ // allocate
+ // string
+ // duplicate
+
+ // init
+ initiateVersion(&ver);
+ freeO(&ver);
+
+ // init allocate
+ versiont *v;
+ initiateAllocateVersion(&v);
+
+ // terminate
+ terminateO(v);
+
+ // allocate
+ v = allocVersion("");
+
+ // string
+ char *s = toStringO(v);
+
+ ck_assert_str_eq(s, "0.0.0");
+ free(s);
+
+ // duplicate
+ versiont *oDup = duplicateO(v);
+ terminateO(oDup);
+ terminateO(v);
+
+}
+
+
+void validT(void) {
+
+ createVersion(ver);
+
+ ck_assert(validO(&ver, "1.2.3.0"));
+ ck_assert(validO(&ver, "10.2.3"));
+ ck_assert(validO(&ver, "0.2.3"));
+ ck_assert(validO(&ver, "0.2"));
+ ck_assert(validO(&ver, "0-p"));
+ ck_assert(validO(&ver, "0-p+b"));
+ ck_assert(validO(&ver, "0+b"));
+ ck_assert(validO(&ver, "0.2.3-p"));
+ ck_assert(validO(&ver, "0.2.3.0-p+b"));
+ ck_assert(validO(&ver, "0.2.3+b"));
+ ck_assert(validO(&ver, "0.2-pre"));
+ ck_assert(validO(&ver, "0.2-pre-234"));
+ ck_assert(validO(&ver, "0.2-pre+r3"));
+ ck_assert(validO(&ver, "0.2-pre+3-r"));
+ ck_assert(validO(&ver, "0.2-pre-234+r3r"));
+ ck_assert(validO(&ver, "0.2-pre.exp34"));
+ ck_assert(validO(&ver, "0.2-pre.exp-wd3-0"));
+
+ ck_assert(!validO(&ver, "0.2.3-+b"));
+ ck_assert(!validO(&ver, "0.2.3-."));
+ ck_assert(!validO(&ver, "0.2.3--"));
+ ck_assert(!validO(&ver, "0.2.3.-p"));
+ ck_assert(!validO(&ver, "0.2.3.+b"));
+ ck_assert(!validO(&ver, "0.2.3+."));
+ ck_assert(!validO(&ver, "0.2.3+-"));
+ ck_assert(!validO(&ver, "0.2.3+b."));
+ ck_assert(!validO(&ver, "0.2.3+b-"));
+ ck_assert(!validO(&ver, "0.2.3+b+"));
+ ck_assert(!validO(&ver, "1.2-pre"));
+ ck_assert(!validO(&ver, "1.-pre"));
+ ck_assert(!validO(&ver, "1.2+b"));
+ ck_assert(!validO(&ver, "1.+b"));
+ ck_assert(!validO(&ver, "0.2-"));
+ ck_assert(!validO(&ver, "0.2-pre+"));
+ ck_assert(!validO(&ver, "0.2.3-"));
+ ck_assert(!validO(&ver, "0.2.3.0-+b"));
+ ck_assert(!validO(&ver, "0.2.3.0-p+"));
+ ck_assert(!validO(&ver, "0.2-pre+3r"));
+ ck_assert(!validO(&ver, "0.2-pre.exp-wd3-00"));
+ ck_assert(!validO(&ver, "0.2-0pre.exp-wd3"));
+ ck_assert(!validO(&ver, "0.2-pre.01-wd3"));
+ ck_assert(!validO(&ver, ".3.3"));
+ ck_assert(!validO(&ver, "3.3."));
+ ck_assert(!validO(&ver, "0..3"));
+ ck_assert(!validO(&ver, "1.2.3.00"));
+ ck_assert(!validO(&ver, "00.2.3"));
+ ck_assert(!validO(&ver, "a.b.c"));
+ ck_assert(!validO(&ver, "=1.3.3"));
+
+ freeO(&ver);
+
+}
+
+void parseT(void) {
+
+ createVersion(ver);
+
+ ck_assert(parseO(&ver, "1.2.3.0"));
+ ck_assert(parseO(&ver, "10.2.3"));
+ ck_assert(parseO(&ver, "0.2.3"));
+ ck_assert(parseO(&ver, "0.2"));
+ ck_assert(parseO(&ver, "0-p"));
+ ck_assert(parseO(&ver, "0-p+b"));
+ ck_assert(parseO(&ver, "0+b"));
+ ck_assert(parseO(&ver, "0.2.3-p"));
+ ck_assert(parseO(&ver, "0.2.3.0-p+b"));
+ ck_assert(parseO(&ver, "0.2.3+b"));
+ ck_assert(parseO(&ver, "0.2-pre"));
+ ck_assert(parseO(&ver, "0.2-pre-234"));
+ ck_assert(parseO(&ver, "0.2-pre+r3"));
+ ck_assert(parseO(&ver, "0.2-pre+3-r"));
+ ck_assert(parseO(&ver, "0.2-pre-234+r3r"));
+ ck_assert(parseO(&ver, "0.2-pre.exp34"));
+ ck_assert(parseO(&ver, "0.2-pre.exp-wd3-0"));
+ ck_assert(parseO(&ver, "0.2.3+b-"));
+ ck_assert(parseO(&ver, "0.2.3+b+"));
+ ck_assert(parseO(&ver, "1.2-pre"));
+ ck_assert(parseO(&ver, "1.2+b"));
+ ck_assert(parseO(&ver, "0.2-"));
+ ck_assert(parseO(&ver, "0.2-pre+"));
+ ck_assert(parseO(&ver, "0.2.3-"));
+ ck_assert(parseO(&ver, "0.2.3.0-p+"));
+ ck_assert(parseO(&ver, ".3.3"));
+ ck_assert(parseO(&ver, "a.b.c"));
+ ck_assert(parseO(&ver, "=1.3.3"));
+
+ ck_assert(!parseO(&ver, "0.2-pre+3r"));
+ ck_assert(!parseO(&ver, "0.2.3-+b"));
+ ck_assert(!parseO(&ver, "0.2.3-."));
+ ck_assert(!parseO(&ver, "0.2.3--"));
+ ck_assert(!parseO(&ver, "0.2.3.-p"));
+ ck_assert(!parseO(&ver, "0.2.3.+b"));
+ ck_assert(!parseO(&ver, "0.2.3+."));
+ ck_assert(!parseO(&ver, "0.2.3+-"));
+ ck_assert(!parseO(&ver, "0.2.3+b."));
+ ck_assert(!parseO(&ver, "1.-pre"));
+ ck_assert(!parseO(&ver, "1.+b"));
+ ck_assert(!parseO(&ver, "0.2.3.0-+b"));
+ ck_assert(!parseO(&ver, "0.2-pre.exp-wd3-00"));
+ ck_assert(!parseO(&ver, "0.2-0pre.exp-wd3"));
+ ck_assert(!parseO(&ver, "0.2-pre.01-wd3"));
+ ck_assert(!parseO(&ver, "3.3."));
+ ck_assert(!parseO(&ver, "0..3"));
+ ck_assert(!parseO(&ver, "1.2.3.00"));
+ ck_assert(!parseO(&ver, "00.2.3"));
+
+ freeO(&ver);
+
+}
+
+void parseStrictT(void) {
+
+ createVersion(ver);
+
+ ck_assert(parseStrictO(&ver, "1.2.3.0"));
+ ck_assert(parseStrictO(&ver, "10.2.3"));
+ ck_assert(parseStrictO(&ver, "0.2.3"));
+ ck_assert(parseStrictO(&ver, "0.2"));
+ ck_assert(parseStrictO(&ver, "0-p"));
+ ck_assert(parseStrictO(&ver, "0-p+b"));
+ ck_assert(parseStrictO(&ver, "0+b"));
+ ck_assert(parseStrictO(&ver, "0.2.3-p"));
+ ck_assert(parseStrictO(&ver, "0.2.3.0-p+b"));
+ ck_assert(parseStrictO(&ver, "0.2.3+b"));
+ ck_assert(parseStrictO(&ver, "0.2-pre"));
+ ck_assert(parseStrictO(&ver, "0.2-pre-234"));
+ ck_assert(parseStrictO(&ver, "0.2-pre+r3"));
+ ck_assert(parseStrictO(&ver, "0.2-pre+3-r"));
+ ck_assert(parseStrictO(&ver, "0.2-pre-234+r3r"));
+ ck_assert(parseStrictO(&ver, "0.2-pre.exp34"));
+ ck_assert(parseStrictO(&ver, "0.2-pre.exp-wd3-0"));
+ ck_assert(parseStrictO(&ver, "=1.3.3"));
+
+ ck_assert(!parseStrictO(&ver, "0.2.3-+b"));
+ ck_assert(!parseStrictO(&ver, "0.2.3-."));
+ ck_assert(!parseStrictO(&ver, "0.2.3--"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.-p"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.+b"));
+ ck_assert(!parseStrictO(&ver, "0.2.3+."));
+ ck_assert(!parseStrictO(&ver, "0.2.3+-"));
+ ck_assert(!parseStrictO(&ver, "0.2.3+b."));
+ ck_assert(!parseStrictO(&ver, "0.2.3+b-"));
+ ck_assert(!parseStrictO(&ver, "0.2.3+b+"));
+ ck_assert(!parseStrictO(&ver, "1.2-pre"));
+ ck_assert(!parseStrictO(&ver, "1.-pre"));
+ ck_assert(!parseStrictO(&ver, "1.2+b"));
+ ck_assert(!parseStrictO(&ver, "1.+b"));
+ ck_assert(!parseStrictO(&ver, "0.2-"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre+"));
+ ck_assert(!parseStrictO(&ver, "0.2.3-"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.0-+b"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.0-p+"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre+3r"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre.exp-wd3-00"));
+ ck_assert(!parseStrictO(&ver, "0.2-0pre.exp-wd3"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre.01-wd3"));
+ ck_assert(!parseStrictO(&ver, ".3.3"));
+ ck_assert(!parseStrictO(&ver, "3.3."));
+ ck_assert(!parseStrictO(&ver, "0..3"));
+ ck_assert(!parseStrictO(&ver, "1.2.3.00"));
+ ck_assert(!parseStrictO(&ver, "00.2.3"));
+ ck_assert(!parseStrictO(&ver, "a.b.c"));
+
+ freeO(&ver);
+
+}
+
+
+
+void cleanT(void) {
+
+ createVersion(ver);
+
+ char *v = strdup("#$%23.34#4.53");
+
+ ver.f->clean(&ver, v);
+
+ ck_assert_str_eq(v, "23.344.53");
+
+ free(v);
+ freeO(&ver);
+
+}
+
+
+void equalT(void) {
+
+ createVersion(ver);
+ createVersion(ver2);
+
+ parseO(&ver, "v1");
+ parseO(&ver2,"1.0.0");
+ ck_assert(eqO(&ver, &ver2));
+
+ incO(&ver, releaseVer);
+ ck_assert(!eqO(&ver, &ver2));
+
+ freeO(&ver2);
+ freeO(&ver);
+
+}
+
+void equalST(void) {
+
+ createVersion(ver);
+
+ parseO(&ver, "v1");
+ ck_assert(eqSO(&ver, "1.0"));
+
+ incO(&ver, releaseVer);
+ ck_assert(!eqSO(&ver, "1.0"));
+
+ freeO(&ver);
+
+}
+
+void equalSST(void) {
+
+ createVersion(ver);
+
+ ck_assert(eqSSO(&ver, "v1", "1.0"));
+
+ ck_assert(!eqSSO(&ver,"v1", "1.0-pre"));
+
+ freeO(&ver);
+
+}
+
+void cmpT(void) {
+
+ createVersion(ver);
+ createVersion(ver2);
+
+ parseO(&ver, "v1");
+ parseO(&ver2,"1.0.0");
+ ck_assert_int_eq(cmpO(&ver, &ver2), 0);
+
+ incO(&ver, releaseVer);
+ ck_assert_int_eq(cmpO(&ver, &ver2), 1);
+
+ incO(&ver2, releaseVer);
+ incO(&ver2, releaseVer);
+ ck_assert_int_eq(cmpO(&ver, &ver2), -1);
+
+ freeO(&ver2);
+ freeO(&ver);
+
+}
+
+void cmpST(void) {
+
+ createVersion(ver);
+
+ parseO(&ver, "v1");
+ ck_assert_int_eq(cmpSO(&ver, "1.0"), 0);
+
+ incO(&ver, releaseVer);
+ ck_assert_int_eq(cmpSO(&ver, "1.0"), 1);
+
+ ck_assert_int_eq(cmpSO(&ver, "3.1"), -1);
+
+ freeO(&ver);
+
+}
+
+void cmpSST(void) {
+
+ createVersion(ver);
+
+ ck_assert_int_eq(cmpSSO(&ver, "v1", "1.0"), 0);
+
+ ck_assert_int_eq(cmpSSO(&ver, "1.1", "1.0"), 1);
+
+ ck_assert_int_eq(cmpSSO(&ver, "1.0", "1.1"), -1);
+
+ freeO(&ver);
+
+}
+
+void incT(void) {
+
+ createVersion(ver);
+
+ parseO(&ver, "0.0.0");
+
+ incO(&ver, releaseVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 0);
+ ck_assert_int_eq(ver.minor, 0);
+ ck_assert_int_eq(ver.patch, 0);
+
+ incO(&ver, majorVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 1);
+ ck_assert_int_eq(ver.minor, 0);
+ ck_assert_int_eq(ver.patch, 0);
+
+ incO(&ver, minorVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 1);
+ ck_assert_int_eq(ver.minor, 1);
+ ck_assert_int_eq(ver.patch, 0);
+
+ incO(&ver, patchVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 1);
+ ck_assert_int_eq(ver.minor, 1);
+ ck_assert_int_eq(ver.patch, 1);
+
+ freeO(&ver);
+
+
+}
+
+void sortT(void) {
+
+ createVersion(ver);
+
+ var arr = createSA("1.1+b.1", "1.1+b", "1.1", "2.0", "1.0", "1.1.1", "1.1-pr", "1.1-pr.1");
+ var ref = createSA("1.0", "1.1-pr", "1.1-pr.1", "1.1", "1.1+b", "1.1+b.1", "1.1.1", "2.0");
+
+ var sorted = vsortO(&ver, arr);
+
+ ck_assert(eqG(sorted, ref));
+
+ terminateManyG(arr,sorted,ref);
+
+ freeO(&ver);
+
+}
+
+void satisfiesT(void) {
+
+ createVersion(ver);
+
+ parseO(&ver, "ver-1.1");
+
+ ck_assert(satisfiesO(&ver, "1.1"));
+ ck_assert(satisfiesO(&ver, "=1.1"));
+
+ // the comparator >=1.2.7 would match the versions 1.2.7, 1.2.8, 2.5.3, and 1.3.9, but not the versions 1.2.6 or 1.1.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.2.8");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-2.5.3");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.3.9");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.2.6");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.1.0");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.2.7-pre");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7"));
+
+ // the comparator >1.2.7- would match 1.2.7 and 1.2.7-alpha.1
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7-"));
+ parseO(&ver, "ver-1.2.7-alpha.1");
+ ck_assert(satisfiesO(&ver, ">=1.2.7-"));
+
+ // the comparator >=1.2.7+ would match 1.2.7+arch64.build-1 and 1.2.7 but not and 1.2.7-alpha.1
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7+"));
+ parseO(&ver, "ver-1.2.7+arch64.build-1");
+ ck_assert(satisfiesO(&ver, ">=1.2.7+"));
+ parseO(&ver, "ver-1.2.7-alpha.1");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7+"));
+
+ // the range >=1.2.7 <1.3.0 would match the versions 1.2.7, 1.2.8, and 1.2.99, but not the versions 1.2.6, 1.3.0, or 1.1.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.2.8");
+ ck_assert(satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.2.99");
+ ck_assert(satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.2.6");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.3.0");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+
+ // the range 1.2.7 || >=1.2.9 <2.0.0 would match the versions 1.2.7, 1.2.9, and 1.4.6, but not the versions 1.2.8 or 2.0.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-1.2.9");
+ ck_assert(satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-1.4.6");
+ ck_assert(satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-1.2.8");
+ ck_assert(!satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-2.0.0");
+ ck_assert(!satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+
+ // * := >= 0.0.0 (Any version)
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, "*"));
+ ck_assert(satisfiesO(&ver, "x"));
+ ck_assert(satisfiesO(&ver, "X"));
+
+ // x.1.2 := =0.1.2 || =1.1.2 || 2.1.2... (Any release version with specified major.minor)
+ ck_assert(satisfiesO(&ver, "X.2.7"));
+ parseO(&ver, "ver-2.2.7");
+ ck_assert(satisfiesO(&ver, "X.2.7"));
+
+ // 1.0.0.x.2 := 1.0.0.0.2 || 1.0.0.1.2 || 1.0.0.2.2... (Any patch version with Release.Major.minor equal to 1.0.0 and with other version equal to 2)
+ parseO(&ver, "ver-1.0.0.3.2");
+ ck_assert(satisfiesO(&ver, "1.0.0.x.2"));
+
+ // 1.2.3 - 2.3.4 := >=1.2.3 <=2.3.4
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.4");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-1.2.2");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.5");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+
+ // 1.2 - 2.3.4 := >=1.2.0 <=2.3.4
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.4");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.5");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+
+ // 1.2.3 - 2.3 := >=1.2.3 <2.4.0
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3"));
+ parseO(&ver, "ver-2.3.30");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3"));
+ parseO(&ver, "ver-2.4");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3"));
+ parseO(&ver, "ver-1.2.2");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3"));
+
+ // 1.2.3 - 2 := >=1.2.3 <3.0.0
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-2.3.30");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-2.4");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-3.0.0");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-1.2.2");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2"));
+
+ // 1.x := >=1.0.0- <2.0.0 (Matching major version)
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.x"));
+ parseO(&ver, "ver-1.0.0-pre");
+ ck_assert(!satisfiesO(&ver, "1.x"));
+ parseO(&ver, "ver-2.0");
+ ck_assert(!satisfiesO(&ver, "1.x"));
+
+ // 1.2.x := >=1.2.0- <1.3.0 (Matching major and minor versions)
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.x"));
+ parseO(&ver, "ver-1.2.3-pre");
+ ck_assert(!satisfiesO(&ver, "1.2.x"));
+ parseO(&ver, "ver-1.3.0.1");
+ ck_assert(!satisfiesO(&ver, "1.2.x"));
+
+ // 1.*- := >=1.0.0 <2.0.0 (Matching major version and prereleases)
+ parseO(&ver, "ver-1.0");
+ ck_assert(satisfiesO(&ver, "1.*-"));
+ parseO(&ver, "ver-1.0-pre");
+ ck_assert(satisfiesO(&ver, "1.*-"));
+ parseO(&ver, "ver-2.0-pre");
+ ck_assert(!satisfiesO(&ver, "1.*-"));
+
+ // 1.X+ := >=1.0.0+ <2.0.0 (Matching major version and build version)
+ parseO(&ver, "ver-1.0+build1");
+ ck_assert(satisfiesO(&ver, "1.X+"));
+ parseO(&ver, "ver-1.6");
+ ck_assert(satisfiesO(&ver, "1.X+"));
+ parseO(&ver, "ver-1.6-pre");
+ ck_assert(!satisfiesO(&ver, "1.X+"));
+ parseO(&ver, "ver-2.0-pre");
+ ck_assert(!satisfiesO(&ver, "1.X+"));
+
+ // "" (empty string) := * := >=0.0.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ""));
+
+ // ~1.1.2.3 := >=1.1.2.3- <1.1.3.0
+ parseO(&ver, "ver-1.1.2.3");
+ ck_assert(satisfiesO(&ver, "~1.1.2.3"));
+ parseO(&ver, "ver-1.1.2.3-pre");
+ ck_assert(!satisfiesO(&ver, "~1.1.2.3"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "~1.1.2.3"));
+
+ // ~1.1.2.3- := >=1.1.2.3 <1.1.3.0 (same as the line above, adds 1.1.2.3 prereleases)
+ parseO(&ver, "ver-1.1.2.3");
+ ck_assert(satisfiesO(&ver, "~1.1.2.3-"));
+ parseO(&ver, "ver-1.1.2.3-pre");
+ ck_assert(satisfiesO(&ver, "~1.1.2.3-"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "~1.1.2.3-"));
+
+ // ~1.1.2 := >=1.1.2.0- <1.1.3.0 (Same as 1.1.2.x)
+ parseO(&ver, "ver-1.1.2.0");
+ ck_assert(satisfiesO(&ver, "~1.1.2"));
+ parseO(&ver, "ver-1.1.2.0-pre");
+ ck_assert(!satisfiesO(&ver, "~1.1.2"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "~1.1.2"));
+
+ // ~1.1 := >=1.1.0.0- <1.2.0.0 (Same as 1.1.x)
+ parseO(&ver, "ver-1.1");
+ ck_assert(satisfiesO(&ver, "~1.1"));
+ parseO(&ver, "ver-1.2");
+ ck_assert(!satisfiesO(&ver, "~1.1"));
+
+ // ~1 := >=1.0.0- <2.0.0 (Same as 1.x)
+ parseO(&ver, "ver-1");
+ ck_assert(satisfiesO(&ver, "~1"));
+ parseO(&ver, "ver-2.0");
+ ck_assert(!satisfiesO(&ver, "~1"));
+
+ // ~0.2.3 >=0.2.3- <0.3.0
+ parseO(&ver, "ver-0.2.3");
+ ck_assert(satisfiesO(&ver, "~0.2.3"));
+ parseO(&ver, "ver-0.3");
+ ck_assert(!satisfiesO(&ver, "~0.2.3"));
+
+ // ~0.2 := >=0.2.0- <0.3.0 (Same as 0.2.x)
+ parseO(&ver, "ver-0.2");
+ ck_assert(satisfiesO(&ver, "~0.2"));
+ parseO(&ver, "ver-0.3");
+ ck_assert(!satisfiesO(&ver, "~0.2"));
+
+ // ~0 := >=0.0.0- <1.0.0 (same as 0.x)
+ parseO(&ver, "ver-0.0.1");
+ ck_assert(satisfiesO(&ver, "~0"));
+ parseO(&ver, "ver-1.0");
+ ck_assert(!satisfiesO(&ver, "~0"));
+
+ // ~0- := >=0.0.0 <1.0.0 (same as 0.x-, same as the line above, adds 0.0.0 prereleases)
+ parseO(&ver, "ver-0.0-pre");
+ ck_assert(satisfiesO(&ver, "~0-"));
+ parseO(&ver, "ver-1.0");
+ ck_assert(!satisfiesO(&ver, "~0-"));
+
+ // ~1.2.3-beta.2 := >=1.2.3-beta.2 <1.3.0 Note that prereleases in the 1.2.3 version will be allowed, if they are greater than or equal to beta.2. So, 1.2.3-beta.4 would be allowed, but 1.2.4-beta.2 would not, because it is a prerelease of a different [major, minor, patch] tuple.
+ parseO(&ver, "ver-1.2.3-beta.2");
+ ck_assert(satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.3");
+ ck_assert(satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.1");
+ ck_assert(!satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.3");
+ ck_assert(!satisfiesO(&ver, "~1.2.3-beta.2"));
+
+ // ^1.1.2.3 := >=1.1.2.3- <1.2.0.0
+ parseO(&ver, "ver-1.1.2.3");
+ ck_assert(satisfiesO(&ver, "^1.1.2.3"));
+ parseO(&ver, "ver-1.2.0");
+ ck_assert(!satisfiesO(&ver, "^1.1.2.3"));
+
+ // ^0.0.2.3 := >=0.0.2.3- <0.1.0.0
+ parseO(&ver, "ver-0.0.2.3");
+ ck_assert(satisfiesO(&ver, "^0.0.2.3"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.2.3"));
+
+ // ^0.0.0.3 := >=0.0.0.3- <0.1.0.0
+ parseO(&ver, "ver-0.0.2.3");
+ ck_assert(satisfiesO(&ver, "^0.0.0.3"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.0.3"));
+
+ // ^1.2.3-beta.2 := >=1.2.3-beta.2 <1.3.0 Note that prereleases in the 1.2.3 version will be allowed, if they are greater than or equal to beta.2. So, 1.2.3-beta.4 would be allowed, but 1.2.4-beta.2 would not, because it is a prerelease of a different [major, minor, patch] tuple.
+ parseO(&ver, "ver-1.2.3-beta.2");
+ ck_assert(satisfiesO(&ver, "^1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.3");
+ ck_assert(satisfiesO(&ver, "^1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.1");
+ ck_assert(!satisfiesO(&ver, "^1.2.3-beta.2"));
+ parseO(&ver, "ver-1.3");
+ ck_assert(!satisfiesO(&ver, "^1.2.3-beta.2"));
+
+ // ^0.0.3-beta := >=0.0.3-beta <0.1.0 Note that prereleases in the 0.0.3 version only will be allowed, if they are greater than or equal to beta. So, 0.0.3-pr.2 would be allowed.
+ parseO(&ver, "ver-0.0.3-beta");
+ ck_assert(satisfiesO(&ver, "^0.0.3-beta"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.3-beta"));
+
+ // ^1.1.2.x := >=1.1.2.0- <1.2.0.0
+ parseO(&ver, "ver-1.1.2");
+ ck_assert(satisfiesO(&ver, "^1.1.2.x"));
+ parseO(&ver, "ver-1.2");
+ ck_assert(!satisfiesO(&ver, "^1.1.2.x"));
+
+ // ^0.0.0.x := >=0.0.0- <0.1.0
+ parseO(&ver, "ver-0");
+ ck_assert(satisfiesO(&ver, "^0.0.0.x"));
+ parseO(&ver, "ver-0-pre");
+ ck_assert(!satisfiesO(&ver, "^0.0.0.x"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.0.x"));
+
+ // ^0.0 := >=0.0.0- <0.1.0
+ parseO(&ver, "ver-0");
+ ck_assert(satisfiesO(&ver, "^0.0"));
+ parseO(&ver, "ver-0-pre");
+ ck_assert(!satisfiesO(&ver, "^0.0"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0"));
+
+ // ^1.1.x := >=1.1.0- <1.2.0
+ parseO(&ver, "ver-1.1.0");
+ ck_assert(satisfiesO(&ver, "^1.1.x"));
+ parseO(&ver, "ver-1.2");
+ ck_assert(!satisfiesO(&ver, "^1.1.x"));
+
+ // ^0.0.x := >=0.0.0- <0.1.0
+ parseO(&ver, "ver-0");
+ ck_assert(satisfiesO(&ver, "^0.0.x"));
+ parseO(&ver, "ver-0-pre");
+ ck_assert(!satisfiesO(&ver, "^0.0.x"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.x"));
+
+ freeO(&ver);
+
+}
+
+void toJsonT(void) {
+
+ createVersion(ver);
+
+ parseO(&ver, "1.0.0-pre+b012");
+
+ smallJsont ref;
+ initiateG(&ref);
+ parseG(&ref, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ var j = toJsonO(&ver);
+ ck_assert(eqG(j, &ref));
+
+ terminateG(j);
+
+ freeManyG(&ver, &ref);
+
+}
+
+void toJsonStrT(void) {
+
+ createVersion(ver);
+
+ parseO(&ver, "1.0.0-pre+b012");
+
+ char *js = toJsonStrO(&ver);
+ ck_assert_str_eq(js, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ free(js);
+ freeO(&ver);
+
+}
+
+void fromJsonT(void) {
+
+ createVersion(ver);
+
+ smallJsont ref;
+ initiateG(&ref);
+ parseG(&ref, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ fromJsonO(&ver, &ref);
+
+ var j = toJsonO(&ver);
+ ck_assert(eqG(j, &ref));
+
+ terminateG(j);
+
+ freeManyG(&ver, &ref);
+
+}
+
+void fromJsonStrT(void) {
+
+ createVersion(ver);
+
+ fromJsonStrO(&ver, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ char *js = toJsonStrO(&ver);
+ ck_assert_str_eq(js, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ free(js);
+ freeO(&ver);
+
+}
+
+
+int main(int n, char**v) {
+
+initLibsheepy(v[0]);
+setLogMode(LOG_FUNC);
+
+basetT();
+validT();
+parseT();
+parseStrictT();
+cleanT();
+equalT();
+equalST();
+equalSST();
+cmpT();
+cmpST();
+cmpSST();
+incT();
+sortT();
+satisfiesT();
+toJsonT();
+toJsonStrT();
+fromJsonT();
+fromJsonStrT();
+}
diff --git a/package.yml b/package.yml
@@ -0,0 +1,33 @@
+---
+ name: version
+ version: 0.0.1
+ description: "Versioning based on semver"
+ bin: ./version.c
+ #cflags: -DA -ggdb -std=gnu11 -fPIC -pipe
+ #lflags: -lpcre
+ repository:
+ type: git
+ url: git+https://github.com/RemyNoulin/version.git
+ keywords:
+ - library
+ - versioning
+ - version
+ author: Remy
+ license: MIT
+ bugs:
+ url: https://github.com/RemyNoulin/version/issues
+ homepage: https://github.com/RemyNoulin/version#readme
+ #compileHelp: # text displayed when there is a compilation error
+ dependencies:
+ short:
+ # Test configuration:
+ testBin: ./testVersion.c
+ testCflags: -ggdb -std=gnu11 -fPIC -pipe -fprofile-arcs -ftest-coverage -Wall -Wextra
+ testLflags: -lcheck_pic -lrt -lm -lsubunit -fprofile-arcs -ftest-coverage -rdynamic
+ # Memcheck configuration:
+ memcheckBin: ./memcheckVersion.c
+ memcheckCmd: valgrind --leak-check=full --show-leak-kinds=all
+ memcheckCflags: -ggdb -std=gnu11 -fPIC -pipe
+ memcheckLflags: -rdynamic
+ #documentationCmd: # command for generating the documentation with spm doc
+ private: false # true for private package
diff --git a/runMemtest.c b/runMemtest.c
@@ -0,0 +1,108 @@
+#! /usr/bin/env sheepy
+/* or direct path to sheepy: #! /usr/local/bin/sheepy */
+
+//
+// in unit test file, add line:
+// //START MEM TEST ANCHOR
+//
+//
+
+#include "libsheepyObject.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int argc; char **argv;
+
+enum {START, TEST, TESTEND, SEARCH};
+
+int main(int ARGC, char** ARGV) {
+ char **list = NULL;
+ char **tests = NULL;
+ char **functions = NULL;
+ char **result = NULL;
+
+ argc = ARGC; argv = ARGV;;//
+
+ initLibsheepy(argv[0]);
+
+ if (argc < 3) {
+ printf("Give a parameter: unit test c file and template file");
+ printf("\n");
+ XFAILURE;
+ }
+
+ // get function list from argv[1]
+ list = readText(argv[1]);
+
+ int status = START;;
+ forEachCharP(list, e) {
+ if (status != START) {
+ if (findS(*e, "#include")) {
+ listPushS(&tests, *e);
+ continue;
+ }
+ if (findS(*e, "START_TEST(")) {
+ char **l = split(*e, "(");
+ char **l2 = split(l[1], ")");;
+ iAppendS(&l2[0], "();");
+ listPushS(&functions, l2[0]);
+ listFreeManyS(l,l2);
+ iReplaceManyS(e, "START_TEST(", "void ", ")", "(void) {");
+ status = TEST;
+ }
+ if (findS(*e, "END_TEST")) {
+ iReplaceS(e, "END_TEST", "}",0);
+ status = TESTEND;
+ }
+ if (status == SEARCH) {
+ char *s = sliceS(*e, 0, 5);;
+ if (strEq(s, "Suite")) {
+ break;
+ }
+ free(s);
+ listPushS(&tests, *e);
+ continue;
+ }
+ if ((status == TEST) || (status == TESTEND)) {
+ listPushS(&tests, *e);
+ if (status == TESTEND) {
+ status = SEARCH;
+ }
+ }
+ }
+ else if (findS(*e, "START MEM TEST ANCHOR")) {
+ status = SEARCH;
+ }
+ }
+
+ listFreeS(list);
+
+ //listPrintS(tests);
+ //listPrintS(functions);
+
+ // read template
+ char **template = readText(argv[2]);
+
+ // process template
+ forEachCharP(template, e) {
+ if (findS(*e, "__tests")) {
+ listAppendS(&result, tests);
+ }
+ else if (findS(*e, "__calls")) {
+ listAppendS(&result, functions);
+ }
+ else {
+ listPushS(&result, *e);
+ }
+ }
+
+ // save result
+ putsG("./memcheckVersion.c");
+ writeText("./memcheckVersion.c", result);
+
+ listFreeManyS(tests, functions, result, template);
+
+ XSUCCESS;
+}
+// vim: set expandtab ts=2 sw=2:+
\ No newline at end of file
diff --git a/testVersion.c b/testVersion.c
@@ -0,0 +1,818 @@
+#! /usr/bin/env sheepy
+/* or direct path to sheepy: #! /usr/local/bin/sheepy */
+
+/** \file
+ * Each test must be independent and self contained
+ */
+
+#include <check.h>
+
+//START MEM TEST ANCHOR
+
+#include "libsheepyObject.h"
+#include "shpPackages/short/short.h"
+#include "version.h"
+
+int argc; char **argv;
+
+versiont ver;
+
+
+START_TEST(basetT)
+
+ // STEPS
+ // init
+ // init allocate
+ // terminate
+ // allocate
+ // string
+ // duplicate
+
+ // init
+ initiateVersion(&ver);
+ freeO(&ver);
+
+ // init allocate
+ versiont *v;
+ initiateAllocateVersion(&v);
+
+ // terminate
+ terminateO(v);
+
+ // allocate
+ v = allocVersion("");
+
+ // string
+ char *s = toStringO(v);
+
+ ck_assert_str_eq(s, "0.0.0");
+ free(s);
+
+ // duplicate
+ versiont *oDup = duplicateO(v);
+ terminateO(oDup);
+ terminateO(v);
+
+END_TEST
+
+
+START_TEST(validT)
+
+ createVersion(ver);
+
+ ck_assert(validO(&ver, "1.2.3.0"));
+ ck_assert(validO(&ver, "10.2.3"));
+ ck_assert(validO(&ver, "0.2.3"));
+ ck_assert(validO(&ver, "0.2"));
+ ck_assert(validO(&ver, "0-p"));
+ ck_assert(validO(&ver, "0-p+b"));
+ ck_assert(validO(&ver, "0+b"));
+ ck_assert(validO(&ver, "0.2.3-p"));
+ ck_assert(validO(&ver, "0.2.3.0-p+b"));
+ ck_assert(validO(&ver, "0.2.3+b"));
+ ck_assert(validO(&ver, "0.2-pre"));
+ ck_assert(validO(&ver, "0.2-pre-234"));
+ ck_assert(validO(&ver, "0.2-pre+r3"));
+ ck_assert(validO(&ver, "0.2-pre+3-r"));
+ ck_assert(validO(&ver, "0.2-pre-234+r3r"));
+ ck_assert(validO(&ver, "0.2-pre.exp34"));
+ ck_assert(validO(&ver, "0.2-pre.exp-wd3-0"));
+
+ ck_assert(!validO(&ver, "0.2.3-+b"));
+ ck_assert(!validO(&ver, "0.2.3-."));
+ ck_assert(!validO(&ver, "0.2.3--"));
+ ck_assert(!validO(&ver, "0.2.3.-p"));
+ ck_assert(!validO(&ver, "0.2.3.+b"));
+ ck_assert(!validO(&ver, "0.2.3+."));
+ ck_assert(!validO(&ver, "0.2.3+-"));
+ ck_assert(!validO(&ver, "0.2.3+b."));
+ ck_assert(!validO(&ver, "0.2.3+b-"));
+ ck_assert(!validO(&ver, "0.2.3+b+"));
+ ck_assert(!validO(&ver, "1.2-pre"));
+ ck_assert(!validO(&ver, "1.-pre"));
+ ck_assert(!validO(&ver, "1.2+b"));
+ ck_assert(!validO(&ver, "1.+b"));
+ ck_assert(!validO(&ver, "0.2-"));
+ ck_assert(!validO(&ver, "0.2-pre+"));
+ ck_assert(!validO(&ver, "0.2.3-"));
+ ck_assert(!validO(&ver, "0.2.3.0-+b"));
+ ck_assert(!validO(&ver, "0.2.3.0-p+"));
+ ck_assert(!validO(&ver, "0.2-pre+3r"));
+ ck_assert(!validO(&ver, "0.2-pre.exp-wd3-00"));
+ ck_assert(!validO(&ver, "0.2-0pre.exp-wd3"));
+ ck_assert(!validO(&ver, "0.2-pre.01-wd3"));
+ ck_assert(!validO(&ver, ".3.3"));
+ ck_assert(!validO(&ver, "3.3."));
+ ck_assert(!validO(&ver, "0..3"));
+ ck_assert(!validO(&ver, "1.2.3.00"));
+ ck_assert(!validO(&ver, "00.2.3"));
+ ck_assert(!validO(&ver, "a.b.c"));
+ ck_assert(!validO(&ver, "=1.3.3"));
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(parseT)
+
+ createVersion(ver);
+
+ ck_assert(parseO(&ver, "1.2.3.0"));
+ ck_assert(parseO(&ver, "10.2.3"));
+ ck_assert(parseO(&ver, "0.2.3"));
+ ck_assert(parseO(&ver, "0.2"));
+ ck_assert(parseO(&ver, "0-p"));
+ ck_assert(parseO(&ver, "0-p+b"));
+ ck_assert(parseO(&ver, "0+b"));
+ ck_assert(parseO(&ver, "0.2.3-p"));
+ ck_assert(parseO(&ver, "0.2.3.0-p+b"));
+ ck_assert(parseO(&ver, "0.2.3+b"));
+ ck_assert(parseO(&ver, "0.2-pre"));
+ ck_assert(parseO(&ver, "0.2-pre-234"));
+ ck_assert(parseO(&ver, "0.2-pre+r3"));
+ ck_assert(parseO(&ver, "0.2-pre+3-r"));
+ ck_assert(parseO(&ver, "0.2-pre-234+r3r"));
+ ck_assert(parseO(&ver, "0.2-pre.exp34"));
+ ck_assert(parseO(&ver, "0.2-pre.exp-wd3-0"));
+ ck_assert(parseO(&ver, "0.2.3+b-"));
+ ck_assert(parseO(&ver, "0.2.3+b+"));
+ ck_assert(parseO(&ver, "1.2-pre"));
+ ck_assert(parseO(&ver, "1.2+b"));
+ ck_assert(parseO(&ver, "0.2-"));
+ ck_assert(parseO(&ver, "0.2-pre+"));
+ ck_assert(parseO(&ver, "0.2.3-"));
+ ck_assert(parseO(&ver, "0.2.3.0-p+"));
+ ck_assert(parseO(&ver, ".3.3"));
+ ck_assert(parseO(&ver, "a.b.c"));
+ ck_assert(parseO(&ver, "=1.3.3"));
+
+ ck_assert(!parseO(&ver, "0.2-pre+3r"));
+ ck_assert(!parseO(&ver, "0.2.3-+b"));
+ ck_assert(!parseO(&ver, "0.2.3-."));
+ ck_assert(!parseO(&ver, "0.2.3--"));
+ ck_assert(!parseO(&ver, "0.2.3.-p"));
+ ck_assert(!parseO(&ver, "0.2.3.+b"));
+ ck_assert(!parseO(&ver, "0.2.3+."));
+ ck_assert(!parseO(&ver, "0.2.3+-"));
+ ck_assert(!parseO(&ver, "0.2.3+b."));
+ ck_assert(!parseO(&ver, "1.-pre"));
+ ck_assert(!parseO(&ver, "1.+b"));
+ ck_assert(!parseO(&ver, "0.2.3.0-+b"));
+ ck_assert(!parseO(&ver, "0.2-pre.exp-wd3-00"));
+ ck_assert(!parseO(&ver, "0.2-0pre.exp-wd3"));
+ ck_assert(!parseO(&ver, "0.2-pre.01-wd3"));
+ ck_assert(!parseO(&ver, "3.3."));
+ ck_assert(!parseO(&ver, "0..3"));
+ ck_assert(!parseO(&ver, "1.2.3.00"));
+ ck_assert(!parseO(&ver, "00.2.3"));
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(parseStrictT)
+
+ createVersion(ver);
+
+ ck_assert(parseStrictO(&ver, "1.2.3.0"));
+ ck_assert(parseStrictO(&ver, "10.2.3"));
+ ck_assert(parseStrictO(&ver, "0.2.3"));
+ ck_assert(parseStrictO(&ver, "0.2"));
+ ck_assert(parseStrictO(&ver, "0-p"));
+ ck_assert(parseStrictO(&ver, "0-p+b"));
+ ck_assert(parseStrictO(&ver, "0+b"));
+ ck_assert(parseStrictO(&ver, "0.2.3-p"));
+ ck_assert(parseStrictO(&ver, "0.2.3.0-p+b"));
+ ck_assert(parseStrictO(&ver, "0.2.3+b"));
+ ck_assert(parseStrictO(&ver, "0.2-pre"));
+ ck_assert(parseStrictO(&ver, "0.2-pre-234"));
+ ck_assert(parseStrictO(&ver, "0.2-pre+r3"));
+ ck_assert(parseStrictO(&ver, "0.2-pre+3-r"));
+ ck_assert(parseStrictO(&ver, "0.2-pre-234+r3r"));
+ ck_assert(parseStrictO(&ver, "0.2-pre.exp34"));
+ ck_assert(parseStrictO(&ver, "0.2-pre.exp-wd3-0"));
+ ck_assert(parseStrictO(&ver, "=1.3.3"));
+
+ ck_assert(!parseStrictO(&ver, "0.2.3-+b"));
+ ck_assert(!parseStrictO(&ver, "0.2.3-."));
+ ck_assert(!parseStrictO(&ver, "0.2.3--"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.-p"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.+b"));
+ ck_assert(!parseStrictO(&ver, "0.2.3+."));
+ ck_assert(!parseStrictO(&ver, "0.2.3+-"));
+ ck_assert(!parseStrictO(&ver, "0.2.3+b."));
+ ck_assert(!parseStrictO(&ver, "0.2.3+b-"));
+ ck_assert(!parseStrictO(&ver, "0.2.3+b+"));
+ ck_assert(!parseStrictO(&ver, "1.2-pre"));
+ ck_assert(!parseStrictO(&ver, "1.-pre"));
+ ck_assert(!parseStrictO(&ver, "1.2+b"));
+ ck_assert(!parseStrictO(&ver, "1.+b"));
+ ck_assert(!parseStrictO(&ver, "0.2-"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre+"));
+ ck_assert(!parseStrictO(&ver, "0.2.3-"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.0-+b"));
+ ck_assert(!parseStrictO(&ver, "0.2.3.0-p+"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre+3r"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre.exp-wd3-00"));
+ ck_assert(!parseStrictO(&ver, "0.2-0pre.exp-wd3"));
+ ck_assert(!parseStrictO(&ver, "0.2-pre.01-wd3"));
+ ck_assert(!parseStrictO(&ver, ".3.3"));
+ ck_assert(!parseStrictO(&ver, "3.3."));
+ ck_assert(!parseStrictO(&ver, "0..3"));
+ ck_assert(!parseStrictO(&ver, "1.2.3.00"));
+ ck_assert(!parseStrictO(&ver, "00.2.3"));
+ ck_assert(!parseStrictO(&ver, "a.b.c"));
+
+ freeO(&ver);
+
+END_TEST
+
+
+
+START_TEST(cleanT)
+
+ createVersion(ver);
+
+ char *v = strdup("#$%23.34#4.53");
+
+ ver.f->clean(&ver, v);
+
+ ck_assert_str_eq(v, "23.344.53");
+
+ free(v);
+ freeO(&ver);
+
+END_TEST
+
+
+START_TEST(equalT)
+
+ createVersion(ver);
+ createVersion(ver2);
+
+ parseO(&ver, "v1");
+ parseO(&ver2,"1.0.0");
+ ck_assert(eqO(&ver, &ver2));
+
+ incO(&ver, releaseVer);
+ ck_assert(!eqO(&ver, &ver2));
+
+ freeO(&ver2);
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(equalST)
+
+ createVersion(ver);
+
+ parseO(&ver, "v1");
+ ck_assert(eqSO(&ver, "1.0"));
+
+ incO(&ver, releaseVer);
+ ck_assert(!eqSO(&ver, "1.0"));
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(equalSST)
+
+ createVersion(ver);
+
+ ck_assert(eqSSO(&ver, "v1", "1.0"));
+
+ ck_assert(!eqSSO(&ver,"v1", "1.0-pre"));
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(cmpT)
+
+ createVersion(ver);
+ createVersion(ver2);
+
+ parseO(&ver, "v1");
+ parseO(&ver2,"1.0.0");
+ ck_assert_int_eq(cmpO(&ver, &ver2), 0);
+
+ incO(&ver, releaseVer);
+ ck_assert_int_eq(cmpO(&ver, &ver2), 1);
+
+ incO(&ver2, releaseVer);
+ incO(&ver2, releaseVer);
+ ck_assert_int_eq(cmpO(&ver, &ver2), -1);
+
+ freeO(&ver2);
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(cmpST)
+
+ createVersion(ver);
+
+ parseO(&ver, "v1");
+ ck_assert_int_eq(cmpSO(&ver, "1.0"), 0);
+
+ incO(&ver, releaseVer);
+ ck_assert_int_eq(cmpSO(&ver, "1.0"), 1);
+
+ ck_assert_int_eq(cmpSO(&ver, "3.1"), -1);
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(cmpSST)
+
+ createVersion(ver);
+
+ ck_assert_int_eq(cmpSSO(&ver, "v1", "1.0"), 0);
+
+ ck_assert_int_eq(cmpSSO(&ver, "1.1", "1.0"), 1);
+
+ ck_assert_int_eq(cmpSSO(&ver, "1.0", "1.1"), -1);
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(incT)
+
+ createVersion(ver);
+
+ parseO(&ver, "0.0.0");
+
+ incO(&ver, releaseVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 0);
+ ck_assert_int_eq(ver.minor, 0);
+ ck_assert_int_eq(ver.patch, 0);
+
+ incO(&ver, majorVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 1);
+ ck_assert_int_eq(ver.minor, 0);
+ ck_assert_int_eq(ver.patch, 0);
+
+ incO(&ver, minorVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 1);
+ ck_assert_int_eq(ver.minor, 1);
+ ck_assert_int_eq(ver.patch, 0);
+
+ incO(&ver, patchVer);
+ ck_assert_int_eq(ver.release, 1);
+ ck_assert_int_eq(ver.major, 1);
+ ck_assert_int_eq(ver.minor, 1);
+ ck_assert_int_eq(ver.patch, 1);
+
+ freeO(&ver);
+
+
+END_TEST
+
+START_TEST(sortT)
+
+ createVersion(ver);
+
+ var arr = createSA("1.1+b.1", "1.1+b", "1.1", "2.0", "1.0", "1.1.1", "1.1-pr", "1.1-pr.1");
+ var ref = createSA("1.0", "1.1-pr", "1.1-pr.1", "1.1", "1.1+b", "1.1+b.1", "1.1.1", "2.0");
+
+ var sorted = vsortO(&ver, arr);
+
+ ck_assert(eqG(sorted, ref));
+
+ terminateManyG(arr,sorted,ref);
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(satisfiesT)
+
+ createVersion(ver);
+
+ parseO(&ver, "ver-1.1");
+
+ ck_assert(satisfiesO(&ver, "1.1"));
+ ck_assert(satisfiesO(&ver, "=1.1"));
+
+ // the comparator >=1.2.7 would match the versions 1.2.7, 1.2.8, 2.5.3, and 1.3.9, but not the versions 1.2.6 or 1.1.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.2.8");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-2.5.3");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.3.9");
+ ck_assert(satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.2.6");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.1.0");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7"));
+ parseO(&ver, "ver-1.2.7-pre");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7"));
+
+ // the comparator >1.2.7- would match 1.2.7 and 1.2.7-alpha.1
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7-"));
+ parseO(&ver, "ver-1.2.7-alpha.1");
+ ck_assert(satisfiesO(&ver, ">=1.2.7-"));
+
+ // the comparator >=1.2.7+ would match 1.2.7+arch64.build-1 and 1.2.7 but not and 1.2.7-alpha.1
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7+"));
+ parseO(&ver, "ver-1.2.7+arch64.build-1");
+ ck_assert(satisfiesO(&ver, ">=1.2.7+"));
+ parseO(&ver, "ver-1.2.7-alpha.1");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7+"));
+
+ // the range >=1.2.7 <1.3.0 would match the versions 1.2.7, 1.2.8, and 1.2.99, but not the versions 1.2.6, 1.3.0, or 1.1.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.2.8");
+ ck_assert(satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.2.99");
+ ck_assert(satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.2.6");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+ parseO(&ver, "ver-1.3.0");
+ ck_assert(!satisfiesO(&ver, ">=1.2.7 <1.3.0"));
+
+ // the range 1.2.7 || >=1.2.9 <2.0.0 would match the versions 1.2.7, 1.2.9, and 1.4.6, but not the versions 1.2.8 or 2.0.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-1.2.9");
+ ck_assert(satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-1.4.6");
+ ck_assert(satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-1.2.8");
+ ck_assert(!satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+ parseO(&ver, "ver-2.0.0");
+ ck_assert(!satisfiesO(&ver, "1.2.7 || >=1.2.9 <2.0.0"));
+
+ // * := >= 0.0.0 (Any version)
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, "*"));
+ ck_assert(satisfiesO(&ver, "x"));
+ ck_assert(satisfiesO(&ver, "X"));
+
+ // x.1.2 := =0.1.2 || =1.1.2 || 2.1.2... (Any release version with specified major.minor)
+ ck_assert(satisfiesO(&ver, "X.2.7"));
+ parseO(&ver, "ver-2.2.7");
+ ck_assert(satisfiesO(&ver, "X.2.7"));
+
+ // 1.0.0.x.2 := 1.0.0.0.2 || 1.0.0.1.2 || 1.0.0.2.2... (Any patch version with Release.Major.minor equal to 1.0.0 and with other version equal to 2)
+ parseO(&ver, "ver-1.0.0.3.2");
+ ck_assert(satisfiesO(&ver, "1.0.0.x.2"));
+
+ // 1.2.3 - 2.3.4 := >=1.2.3 <=2.3.4
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.4");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-1.2.2");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.5");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+
+ // 1.2 - 2.3.4 := >=1.2.0 <=2.3.4
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.4");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+ parseO(&ver, "ver-2.3.5");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3.4"));
+
+ // 1.2.3 - 2.3 := >=1.2.3 <2.4.0
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3"));
+ parseO(&ver, "ver-2.3.30");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2.3"));
+ parseO(&ver, "ver-2.4");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3"));
+ parseO(&ver, "ver-1.2.2");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2.3"));
+
+ // 1.2.3 - 2 := >=1.2.3 <3.0.0
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-2.3.30");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-2.4");
+ ck_assert(satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-3.0.0");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2"));
+ parseO(&ver, "ver-1.2.2");
+ ck_assert(!satisfiesO(&ver, "1.2.3 - 2"));
+
+ // 1.x := >=1.0.0- <2.0.0 (Matching major version)
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.x"));
+ parseO(&ver, "ver-1.0.0-pre");
+ ck_assert(!satisfiesO(&ver, "1.x"));
+ parseO(&ver, "ver-2.0");
+ ck_assert(!satisfiesO(&ver, "1.x"));
+
+ // 1.2.x := >=1.2.0- <1.3.0 (Matching major and minor versions)
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "1.2.x"));
+ parseO(&ver, "ver-1.2.3-pre");
+ ck_assert(!satisfiesO(&ver, "1.2.x"));
+ parseO(&ver, "ver-1.3.0.1");
+ ck_assert(!satisfiesO(&ver, "1.2.x"));
+
+ // 1.*- := >=1.0.0 <2.0.0 (Matching major version and prereleases)
+ parseO(&ver, "ver-1.0");
+ ck_assert(satisfiesO(&ver, "1.*-"));
+ parseO(&ver, "ver-1.0-pre");
+ ck_assert(satisfiesO(&ver, "1.*-"));
+ parseO(&ver, "ver-2.0-pre");
+ ck_assert(!satisfiesO(&ver, "1.*-"));
+
+ // 1.X+ := >=1.0.0+ <2.0.0 (Matching major version and build version)
+ parseO(&ver, "ver-1.0+build1");
+ ck_assert(satisfiesO(&ver, "1.X+"));
+ parseO(&ver, "ver-1.6");
+ ck_assert(satisfiesO(&ver, "1.X+"));
+ parseO(&ver, "ver-1.6-pre");
+ ck_assert(!satisfiesO(&ver, "1.X+"));
+ parseO(&ver, "ver-2.0-pre");
+ ck_assert(!satisfiesO(&ver, "1.X+"));
+
+ // "" (empty string) := * := >=0.0.0
+ parseO(&ver, "ver-1.2.7");
+ ck_assert(satisfiesO(&ver, ""));
+
+ // ~1.1.2.3 := >=1.1.2.3- <1.1.3.0
+ parseO(&ver, "ver-1.1.2.3");
+ ck_assert(satisfiesO(&ver, "~1.1.2.3"));
+ parseO(&ver, "ver-1.1.2.3-pre");
+ ck_assert(!satisfiesO(&ver, "~1.1.2.3"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "~1.1.2.3"));
+
+ // ~1.1.2.3- := >=1.1.2.3 <1.1.3.0 (same as the line above, adds 1.1.2.3 prereleases)
+ parseO(&ver, "ver-1.1.2.3");
+ ck_assert(satisfiesO(&ver, "~1.1.2.3-"));
+ parseO(&ver, "ver-1.1.2.3-pre");
+ ck_assert(satisfiesO(&ver, "~1.1.2.3-"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "~1.1.2.3-"));
+
+ // ~1.1.2 := >=1.1.2.0- <1.1.3.0 (Same as 1.1.2.x)
+ parseO(&ver, "ver-1.1.2.0");
+ ck_assert(satisfiesO(&ver, "~1.1.2"));
+ parseO(&ver, "ver-1.1.2.0-pre");
+ ck_assert(!satisfiesO(&ver, "~1.1.2"));
+ parseO(&ver, "ver-1.1.3");
+ ck_assert(!satisfiesO(&ver, "~1.1.2"));
+
+ // ~1.1 := >=1.1.0.0- <1.2.0.0 (Same as 1.1.x)
+ parseO(&ver, "ver-1.1");
+ ck_assert(satisfiesO(&ver, "~1.1"));
+ parseO(&ver, "ver-1.2");
+ ck_assert(!satisfiesO(&ver, "~1.1"));
+
+ // ~1 := >=1.0.0- <2.0.0 (Same as 1.x)
+ parseO(&ver, "ver-1");
+ ck_assert(satisfiesO(&ver, "~1"));
+ parseO(&ver, "ver-2.0");
+ ck_assert(!satisfiesO(&ver, "~1"));
+
+ // ~0.2.3 >=0.2.3- <0.3.0
+ parseO(&ver, "ver-0.2.3");
+ ck_assert(satisfiesO(&ver, "~0.2.3"));
+ parseO(&ver, "ver-0.3");
+ ck_assert(!satisfiesO(&ver, "~0.2.3"));
+
+ // ~0.2 := >=0.2.0- <0.3.0 (Same as 0.2.x)
+ parseO(&ver, "ver-0.2");
+ ck_assert(satisfiesO(&ver, "~0.2"));
+ parseO(&ver, "ver-0.3");
+ ck_assert(!satisfiesO(&ver, "~0.2"));
+
+ // ~0 := >=0.0.0- <1.0.0 (same as 0.x)
+ parseO(&ver, "ver-0.0.1");
+ ck_assert(satisfiesO(&ver, "~0"));
+ parseO(&ver, "ver-1.0");
+ ck_assert(!satisfiesO(&ver, "~0"));
+
+ // ~0- := >=0.0.0 <1.0.0 (same as 0.x-, same as the line above, adds 0.0.0 prereleases)
+ parseO(&ver, "ver-0.0-pre");
+ ck_assert(satisfiesO(&ver, "~0-"));
+ parseO(&ver, "ver-1.0");
+ ck_assert(!satisfiesO(&ver, "~0-"));
+
+ // ~1.2.3-beta.2 := >=1.2.3-beta.2 <1.3.0 Note that prereleases in the 1.2.3 version will be allowed, if they are greater than or equal to beta.2. So, 1.2.3-beta.4 would be allowed, but 1.2.4-beta.2 would not, because it is a prerelease of a different [major, minor, patch] tuple.
+ parseO(&ver, "ver-1.2.3-beta.2");
+ ck_assert(satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.3");
+ ck_assert(satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3");
+ ck_assert(satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.1");
+ ck_assert(!satisfiesO(&ver, "~1.2.3-beta.2"));
+ parseO(&ver, "ver-1.3");
+ ck_assert(!satisfiesO(&ver, "~1.2.3-beta.2"));
+
+ // ^1.1.2.3 := >=1.1.2.3- <1.2.0.0
+ parseO(&ver, "ver-1.1.2.3");
+ ck_assert(satisfiesO(&ver, "^1.1.2.3"));
+ parseO(&ver, "ver-1.2.0");
+ ck_assert(!satisfiesO(&ver, "^1.1.2.3"));
+
+ // ^0.0.2.3 := >=0.0.2.3- <0.1.0.0
+ parseO(&ver, "ver-0.0.2.3");
+ ck_assert(satisfiesO(&ver, "^0.0.2.3"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.2.3"));
+
+ // ^0.0.0.3 := >=0.0.0.3- <0.1.0.0
+ parseO(&ver, "ver-0.0.2.3");
+ ck_assert(satisfiesO(&ver, "^0.0.0.3"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.0.3"));
+
+ // ^1.2.3-beta.2 := >=1.2.3-beta.2 <1.3.0 Note that prereleases in the 1.2.3 version will be allowed, if they are greater than or equal to beta.2. So, 1.2.3-beta.4 would be allowed, but 1.2.4-beta.2 would not, because it is a prerelease of a different [major, minor, patch] tuple.
+ parseO(&ver, "ver-1.2.3-beta.2");
+ ck_assert(satisfiesO(&ver, "^1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.3");
+ ck_assert(satisfiesO(&ver, "^1.2.3-beta.2"));
+ parseO(&ver, "ver-1.2.3-beta.1");
+ ck_assert(!satisfiesO(&ver, "^1.2.3-beta.2"));
+ parseO(&ver, "ver-1.3");
+ ck_assert(!satisfiesO(&ver, "^1.2.3-beta.2"));
+
+ // ^0.0.3-beta := >=0.0.3-beta <0.1.0 Note that prereleases in the 0.0.3 version only will be allowed, if they are greater than or equal to beta. So, 0.0.3-pr.2 would be allowed.
+ parseO(&ver, "ver-0.0.3-beta");
+ ck_assert(satisfiesO(&ver, "^0.0.3-beta"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.3-beta"));
+
+ // ^1.1.2.x := >=1.1.2.0- <1.2.0.0
+ parseO(&ver, "ver-1.1.2");
+ ck_assert(satisfiesO(&ver, "^1.1.2.x"));
+ parseO(&ver, "ver-1.2");
+ ck_assert(!satisfiesO(&ver, "^1.1.2.x"));
+
+ // ^0.0.0.x := >=0.0.0- <0.1.0
+ parseO(&ver, "ver-0");
+ ck_assert(satisfiesO(&ver, "^0.0.0.x"));
+ parseO(&ver, "ver-0-pre");
+ ck_assert(!satisfiesO(&ver, "^0.0.0.x"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.0.x"));
+
+ // ^0.0 := >=0.0.0- <0.1.0
+ parseO(&ver, "ver-0");
+ ck_assert(satisfiesO(&ver, "^0.0"));
+ parseO(&ver, "ver-0-pre");
+ ck_assert(!satisfiesO(&ver, "^0.0"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0"));
+
+ // ^1.1.x := >=1.1.0- <1.2.0
+ parseO(&ver, "ver-1.1.0");
+ ck_assert(satisfiesO(&ver, "^1.1.x"));
+ parseO(&ver, "ver-1.2");
+ ck_assert(!satisfiesO(&ver, "^1.1.x"));
+
+ // ^0.0.x := >=0.0.0- <0.1.0
+ parseO(&ver, "ver-0");
+ ck_assert(satisfiesO(&ver, "^0.0.x"));
+ parseO(&ver, "ver-0-pre");
+ ck_assert(!satisfiesO(&ver, "^0.0.x"));
+ parseO(&ver, "ver-0.1");
+ ck_assert(!satisfiesO(&ver, "^0.0.x"));
+
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(toJsonT)
+
+ createVersion(ver);
+
+ parseO(&ver, "1.0.0-pre+b012");
+
+ smallJsont ref;
+ initiateG(&ref);
+ parseG(&ref, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ var j = toJsonO(&ver);
+ ck_assert(eqG(j, &ref));
+
+ terminateG(j);
+
+ freeManyG(&ver, &ref);
+
+END_TEST
+
+START_TEST(toJsonStrT)
+
+ createVersion(ver);
+
+ parseO(&ver, "1.0.0-pre+b012");
+
+ char *js = toJsonStrO(&ver);
+ ck_assert_str_eq(js, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ free(js);
+ freeO(&ver);
+
+END_TEST
+
+START_TEST(fromJsonT)
+
+ createVersion(ver);
+
+ smallJsont ref;
+ initiateG(&ref);
+ parseG(&ref, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ fromJsonO(&ver, &ref);
+
+ var j = toJsonO(&ver);
+ ck_assert(eqG(j, &ref));
+
+ terminateG(j);
+
+ freeManyG(&ver, &ref);
+
+END_TEST
+
+START_TEST(fromJsonStrT)
+
+ createVersion(ver);
+
+ fromJsonStrO(&ver, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ char *js = toJsonStrO(&ver);
+ ck_assert_str_eq(js, "{\"release\":1,\"major\":0,\"minor\":0,\"patch\":0,\"others\":[],\"prerelease\":[\"pre\"],\"build\":[\"b012\"]}");
+
+ free(js);
+ freeO(&ver);
+
+END_TEST
+
+Suite * versionSuite(void) {
+ Suite *s;
+ TCase *tc_core;
+
+ s = suite_create("version");
+
+ /* Core test case */
+ tc_core = tcase_create("Core");
+
+
+ tcase_add_test(tc_core, basetT);
+ tcase_add_test(tc_core, validT);
+ tcase_add_test(tc_core, parseT);
+ tcase_add_test(tc_core, parseStrictT);
+ tcase_add_test(tc_core, cleanT);
+ tcase_add_test(tc_core, equalT);
+ tcase_add_test(tc_core, equalST);
+ tcase_add_test(tc_core, equalSST);
+ tcase_add_test(tc_core, cmpT);
+ tcase_add_test(tc_core, cmpST);
+ tcase_add_test(tc_core, cmpSST);
+ tcase_add_test(tc_core, incT);
+ tcase_add_test(tc_core, sortT);
+ tcase_add_test(tc_core, satisfiesT);
+ tcase_add_test(tc_core, toJsonT);
+ tcase_add_test(tc_core, toJsonStrT);
+ tcase_add_test(tc_core, fromJsonT);
+ tcase_add_test(tc_core, fromJsonStrT);
+
+ suite_add_tcase(s, tc_core);
+
+ ret s;
+}
+
+int main(int ARGC, char** ARGV) {
+
+ argc = ARGC; argv = ARGV;
+
+ //dont initialize libsheepy, it conflicts with libcheck - initLibsheepy(ARGV[0]);
+ setLogMode(LOG_FUNC);
+
+ int number_failed;
+ Suite *s;
+ SRunner *sr;
+
+ s = versionSuite();
+ sr = srunner_create(s);
+
+ srunner_run_all(sr, CK_NORMAL);
+ number_failed = srunner_ntests_failed(sr);
+ srunner_free(sr);
+
+ exit((number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
+}
+// vim: set expandtab ts=2 sw=2:
diff --git a/testVersionMem.sh b/testVersionMem.sh
@@ -0,0 +1,2 @@
+./runMemtest.c ./testVersion.c memTest.c.template
+spm memcheck+
\ No newline at end of file
diff --git a/version.c b/version.c
@@ -0,0 +1,1630 @@
+
+
+/* Libsheepy documentation: http://spartatek.se/libsheepy/ */
+
+#include "libsheepyObject.h"
+#include "version.h"
+#include "versionInternal.h"
+#include "shpPackages/short/short.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+void initiateVersion(versiont *self);
+void registerMethodsVersion(versionFunctionst *f);
+void initiateAllocateVersion(versiont **self);
+void finalizeVersion(void);
+versiont* allocVersion(const char *v);
+local void freeVersion(versiont *self);
+local void terminateVersion(versiont **self);
+local char* toStringVersion(versiont *self);
+local versiont* duplicateVersion(versiont *self);
+local void smashVersion(versiont **self);
+local void finishVersion(versiont **self);
+local const char* helpVersion(versiont *self);
+local void logVersion(versiont *self);
+local bool validVersion(versiont *self, const char *v);
+local bool parseVersion(versiont *self, const char *v);
+local bool parseStrictVersion(versiont *self, const char *v);
+local bool cleanVersion(versiont *self, char *v);
+local bool equalVersion(versiont *self, versiont *ver);
+local bool equalSVersion(versiont *self, const char *v);
+local bool equalSSVersion(versiont *self, const char *v1, const char *v2);
+local int cmpVersion(versiont *self, versiont *ver);
+local int cmpSVersion(versiont *self, const char *v);
+local int cmpSSVersion(versiont *self, const char *v1, const char *v2);
+local bool incVersion(versiont *self, u32 level);
+local smallArrayt* sortVersion(versiont *self, smallArrayt *vlist);
+local bool satisfiesVersion(versiont *self, const char *vrange);
+local smallJsont* toJsonVersion(versiont *self);
+local char* toJsonStrVersion(versiont *self);
+local bool fromJsonVersion(versiont *self, smallJsont *json);
+local bool fromJsonStrVersion(versiont *self, const char *json);
+
+/* enable/disable logging */
+#undef pLog
+#define pLog(...)
+
+// all valid characters in version strings
+#define DELIMITER "."
+#define PR_DELIMITER "-"
+#define BD_DELIMITER "+"
+#define NUMBERS "0123456789"
+#define ALPHA "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define DELIMITERS DELIMITER PR_DELIMITER BD_DELIMITER
+#define ANYTOKENS "xX*"
+#define VALID_CHARS NUMBERS ALPHA DELIMITERS ANYTOKENS
+
+// bitset used to strip invalid characters
+staticBitsetT(validt, u64 , 256);
+local validt validChars = {0};
+
+// parser states
+// STATE[START] to convert state value to string
+enum {START, REL, MAJOR, MINOR, PATCH, OTHERS, PRE, BUILD, CSTRING, NUMBER, ANY};
+local const char *STATE[] UNUSED = {"START", "REL", "MAJOR", "MINOR", "PATCH", "OTHERS", "PRE", "BUILD", "STRING", "NUMBER", "ANY xX*"};
+
+/**
+ * true when c is a valid character
+ */
+local inline bool isValidChar(char c) {
+ ret staticBitsetGet(&validChars, c);
+}
+
+void initiateVersion(versiont *self) {
+
+ self->type = "version";
+ if (!versionF) {
+ versionF = malloc(sizeof(versionFunctionst));
+ registerMethodsVersion(versionF);
+ pErrorNot0(atexit(finalizeVersion));
+
+ // initialize list of valid characters
+ range(i,strlen(VALID_CHARS)) {
+ staticBitset1(&validChars, VALID_CHARS[i]);
+ }
+ }
+ self->f = versionF;
+
+ #define setToZero\
+ self->originalVer = NULL;\
+ self->empty = true;\
+ self->mainComponentCount = 0;\
+ self->release = 0;\
+ self->major = 0;\
+ self->minor = 0;\
+ self->patch = 0
+ setToZero;
+ initiateG(&self->others);
+ initiateG(&self->prerelease);
+ initiateG(&self->build);
+
+}
+
+void registerMethodsVersion(versionFunctionst *f) {
+
+ f->free = freeVersion;
+ f->terminate = terminateVersion;
+ f->toString = toStringVersion;
+ f->duplicate = duplicateVersion;
+ f->smash = smashVersion;
+ f->finish = finishVersion;
+ f->help = helpVersion;
+ f->log = logVersion;
+ f->valid = validVersion;
+ f->parse = parseVersion;
+ f->parseStrict = parseStrictVersion;
+ f->clean = cleanVersion;
+ f->equal = equalVersion;
+ f->equalS = equalSVersion;
+ f->equalSS = equalSSVersion;
+ f->cmp = cmpVersion;
+ f->cmpS = cmpSVersion;
+ f->cmpSS = cmpSSVersion;
+ f->inc = incVersion;
+ f->sort = sortVersion;
+ f->satisfies = satisfiesVersion;
+ f->toJson = toJsonVersion;
+ f->toJsonStr = toJsonStrVersion;
+ f->fromJson = fromJsonVersion;
+ f->fromJsonStr = fromJsonStrVersion;
+}
+
+void initiateAllocateVersion(versiont **self) {
+
+ if (self) {
+ (*self) = malloc(sizeof(versiont));
+ if (*self) {
+ initiateVersion(*self);
+ }
+ }
+}
+
+void finalizeVersion(void) {
+
+ if (versionF) {
+ free(versionF);
+ versionF = NULL;
+ }
+}
+
+versiont* allocVersion(const char *v) {
+ versiont *r = NULL;
+
+ initiateAllocateVersion(&r);
+ parseVersion(r, v);
+ ret r;
+}
+
+
+local void freeVersion(versiont *self) {
+
+ free(self->originalVer);
+ setToZero;
+ freeG(&self->others);
+ freeG(&self->prerelease);
+ freeG(&self->build);
+}
+
+local void terminateVersion(versiont **self) {
+
+ freeVersion(*self);
+ finishVersion(self);
+}
+
+
+local char* toStringVersion(versiont *self) {
+
+ char *r = NULL;
+ r = formatS("%"PRIu64".%"PRIu64".%"PRIu64, self->release, self->major, self->minor);
+ if (self->patch) {
+ pushNFreeG(&r, formatS(".%"PRIu64, self->patch));
+ }
+ if (!isEmptyG(&self->others)) {
+ var o = joinSG(&self->others, '.');
+ pushNFreeG(&r, formatS(".%s", o));
+ free(o);
+ }
+ if (!isEmptyG(&self->prerelease)) {
+ #define labelString(label, delim) \
+ iter(&self->label, c) {\
+ if (isOSmallIntG(c) and iterIndexG(&self->label)) {\
+ /* the left delimiter for numbers is . (DELIMITER) */\
+ pushG(&r, DELIMITER);\
+ }\
+ else {\
+ pushG(&r, delim);\
+ }\
+ var cs = toStringO(c);\
+ pushNFreeG(&r, cs);\
+ }
+ labelString(prerelease, PR_DELIMITER);
+ }
+ if (!isEmptyG(&self->build)) {
+ labelString(build, BD_DELIMITER);
+ }
+ ret r;
+}
+
+local versiont* duplicateVersion(versiont *self) {
+
+ createAllocateVersion(dup);
+ dup->originalVer = dupG(self->originalVer);
+ dup->empty = self->empty;
+ dup->mainComponentCount = self->mainComponentCount;
+ dup->release = self->release;
+ dup->major = self->major;
+ dup->minor = self->minor;
+ dup->patch = self->patch;
+
+ smallArrayt *dp;
+ #define dupComponents(label)\
+ dp = dupG(&self->label);\
+ setsoG(&dup->label, getsoG(dp));\
+ finishG(dp)
+ dupComponents(others);
+ dupComponents(prerelease);
+ dupComponents(build);
+ ret dup;
+}
+
+local void smashVersion(versiont **self) {
+
+ finishVersion(self);
+}
+
+#if NFreeStackCheck
+local void finishVersion(versiont **self) {
+
+ register u64 rsp asm("rsp");
+ if ((u64)*self > rsp) {
+ logW("Probably trying to free a smallArray on stack: "BLD"%p"RST" sp: "BLD"%p"RST, *self, rsp);
+ logBtrace;
+ }
+ else {
+ free(*self);
+ *self = NULL;
+ }
+}
+#else
+// #if NFreeStackCheck
+local void finishVersion(versiont **self) {
+
+ free(*self);
+ *self = NULL;
+}
+#endif
+// #if NFreeStackCheck
+
+local const char* helpVersion(versiont UNUSED *self) {
+ ret "TODO - version help";
+}
+
+
+
+
+local void logVersion(versiont *self) {
+ var s = toStringVersion(self);
+ puts(s);
+ free(s);
+}
+
+
+/**
+ * internal function parsing a version string
+ *
+ * version string format is Release.Major.minor.patch.others-prerelease+build
+ *
+ * when validate is set, self is not updated
+ * when loose is set, incomplete version strings are accepted
+ * set isCmp to true when parsing version in comparators
+ */
+local bool parse(versiont *self UNUSED, const char *ver, bool validate, bool loose, bool isCmp) {
+ if (isBlankG(ver)) ret false;
+
+ // the code for the parser is in !validate blocks
+ // the code interpreting an invalid version string as much as possible is in loose blocks
+ // the code for version in compares is isCmp blocks (used in satisfiesVersion)
+
+ // remove spaces and duplicate the string
+ char *v = trimS(ver);
+
+ // main state
+ u8 state = START;
+ // state for parsing others, prerelease and build
+ u8 state2 = START;
+
+ // for detecting state transition and empty components
+ u8 prevState;
+
+ // leading 0 are not accepted for any version number
+ bool leading0 = false;
+ // allow prerelease and build anywhere (0-pre) when true
+ bool release0 = loose;
+
+ // curs is cursor in version string
+ // component is the start of a component string
+ char *curs, *component;
+ /* lv(isCmp); */
+ range(i, strlen(v)) {
+ curs = &v[i];
+ /* lv(i); */
+ /* lv(STATE[state]); */
+ /* lv(STATE[state2]); */
+ /* lv(leading0); */
+ /* putchar(v[i]); */
+ /* put */
+
+ // fail when a character is invalid
+ if (!isValidChar(v[i])) goto fail;
+ switch(state) {
+ case START:
+ // find the start of the version string
+ if (!isdigit(v[i]) and v[i] != 'x' and v[i] != 'X' and v[i] != '*') {
+ // ignore characters in front of release version when loose
+ if (loose) continue; else goto fail;
+ }
+ state = REL;
+ prevState = state;
+ leading0 = v[i] == '0' ? true : false;
+ // dont set self when validating
+ if (!validate) component = curs;
+ break;
+ case REL:
+ if (isCmp and (v[i-1] == 'x' or v[i-1] == 'X' or v[i-1] == '*')) {
+ // set component to -1 when an any character is detected in a comparator
+ #define validStrictNumIsCmp(comp, delimIndex, nstate)\
+ self->comp = -1;\
+ prevState = state;\
+ /* must be x. or x- or x+ or x */\
+ /* when delimiter is at the end of the string, parsing is finished */\
+ if (!v[i+delimIndex] /* avoid reading outside the buffer */ or (hasG(DELIMITERS, v[i+delimIndex]) and !v[i+delimIndex+1])) goto parsingFinish;\
+ if (!delimIndex) switch(v[i+delimIndex]) {\
+ case '.':\
+ state = nstate;\
+ break;\
+ case '-':\
+ state = PRE;\
+ break;\
+ case '+':\
+ state = BUILD;\
+ break;\
+ default:\
+ goto fail;\
+ }\
+ break;
+ validStrictNumIsCmp(release, 0/*delimIndex*/, MAJOR);
+ }
+ // any characters are not accepted in normal version strings
+ if (!isCmp and (v[i-1] == 'x' or v[i-1] == 'X' or v[i-1] == '*')) goto fail;
+ #define parseNumber(comp) \
+ /* state switch, point to next component */\
+ if (!validate) {\
+ char c = *curs;\
+ *curs = 0;\
+ if (!isCmp or !hasG(ANYTOKENS, v[i-1])) self->comp = parseI64(component);\
+ *curs = c;\
+ component = curs+1;\
+ self->mainComponentCount++;\
+ }
+ #define validStrictNum(comp, nextState, transCond, code, leadingCond)\
+ if (isCmp) {\
+ if (hasG(ANYTOKENS, v[i])) {\
+ /* multiple separator following each other is not accepted */\
+ if (v[i-1] != '.') goto fail;\
+ if (loose) {\
+ /* set component to -1 when an any character is detected in a comparator */\
+ validStrictNumIsCmp(comp, 1 /*delimIndex*/, nextState)\
+ }\
+ }\
+ }\
+ /* any characters are not accepted in normal version strings */\
+ elif (!isCmp and (v[i] == 'x' or v[i] == 'X' or v[i] == '*')) goto fail;\
+ u8 UNIQVAR(nextSte) = nextState;\
+ if (!isdigit(v[i])) {\
+ /* end of component detected */\
+ /* no empty components */\
+ if (i and hasG(DELIMITERS, v[i-1])) goto fail;\
+ if (i == 1 and leading0) {\
+ /* prerelease 0 allow prerelease and build components anywhere*/\
+ if (v[i] == PR_DELIMITER[0]) {\
+ release0 = true;\
+ state = PRE;\
+ parseNumber(comp);\
+ break;\
+ }\
+ elif (v[i] == BD_DELIMITER[0]) {\
+ release0 = true;\
+ state = BUILD;\
+ parseNumber(comp);\
+ break;\
+ }\
+ }\
+ if (release0) {\
+ /* prerelease 0 allow prerelease and build components anywhere*/\
+ if (v[i] == PR_DELIMITER[0]) {\
+ state = PRE;\
+ parseNumber(comp);\
+ break;\
+ }\
+ elif (v[i] == BD_DELIMITER[0]) {\
+ state = BUILD;\
+ parseNumber(comp);\
+ break;\
+ }\
+ }\
+ /* end of release version or invalid, must have one digit */\
+ if ((prevState != state) or (v[i] and (v[i] != DELIMITER[0] transCond))) goto fail;\
+ code;\
+ /* parse component and go to next state */\
+ prevState = state;\
+ state = UNIQVAR(nextSte);\
+ leading0 = v[i+1] == '0' ? true : false;\
+ /* parse numbers only, not any tokens "xX*" */\
+ parseNumber(comp);\
+ break;\
+ }\
+ /* search end of component */\
+ /* no leading 0 */\
+ if (leading0 and v[i-1] != DELIMITER[0] leadingCond) goto fail;\
+ /* not in state transition anymore */\
+ prevState = state;
+ // set release0 to true when loose to allow incomplete versions, the missing numbers are set to 0
+ validStrictNum(release, MAJOR,/*transCond*/,if (loose) release0 = true; else release0 = leading0 ? true : false,/*leadingCond*/);
+ break;
+ case MAJOR:
+ validStrictNum(major, MINOR,/*transCond*/,/*code*/,/*leadingCond*/);
+ break;
+ case MINOR:
+ validStrictNum(minor, PATCH, and v[i] != PR_DELIMITER[0] and v[i] != BD_DELIMITER[0] /*transCond*/, if (v[i] == PR_DELIMITER[0]) UNIQVAR(nextSte) = PRE; /*code*/, and v[i-1] != PR_DELIMITER[0] and v[i-1] != BD_DELIMITER[0] /*leadingCond*/);
+ break;
+ case PATCH:
+ // check if prerelease only when the state was changed
+ if (prevState != state and v[i-1] == PR_DELIMITER[0]) {
+ prevState = state;
+ state = PRE;
+ if (!validate) component = curs;
+ i--;
+ break;
+ }
+ validStrictNum(patch, OTHERS, and v[i] != PR_DELIMITER[0] and v[i] != BD_DELIMITER[0] /*transCond*/, if (v[i] == PR_DELIMITER[0]) UNIQVAR(nextSte) = PRE; /*code*/, and v[i-1] != PR_DELIMITER[0] and v[i-1] != BD_DELIMITER[0] /*leadingCond*/);
+ break;
+ case OTHERS:
+ // no empty components
+ if (hasG(DELIMITERS, v[i-1]) and hasG(DELIMITERS, v[i])) goto fail;
+ #define switchLabel(delim, nextState, label) \
+ if (v[i] == delim) {\
+ prevState = state;\
+ state = nextState;\
+ if (!validate) {\
+ /* parse number or string or any character */\
+ char c = *curs;\
+ *curs = 0;\
+ if (state2 == NUMBER) {\
+ pushG(&self->label, parseI64(component));\
+ }\
+ elif (state2 == CSTRING) {\
+ pushG(&self->label, component);\
+ }\
+ elif (state2 == ANY) {\
+ pushG(&self->label, -1);\
+ }\
+ *curs = c;\
+ state2 = START;\
+ component = curs+1;\
+ }\
+ break;\
+ }
+ #define validStrictLabel(label)\
+ /* after state transition, select prerelease state, stored in state2 */\
+ if (hasG(DELIMITERS, v[i-1])) {\
+ if (!validate and prevState == state) {\
+ char c = *(curs-1);\
+ /* dont parse just after a state switch since the component token doesn't exist */\
+ *(curs-1) = 0;\
+ if (state2 == NUMBER) {\
+ pushG(&self->label, parseI64(component));\
+ }\
+ elif (state2 == CSTRING) {\
+ pushG(&self->label, component);\
+ }\
+ elif (state2 == ANY) {\
+ pushG(&self->label, -1);\
+ }\
+ *(curs-1) = c;\
+ component = curs;\
+ }\
+ if (isCmp and (v[i] == 'x' or v[i] == 'X' or v[i] == '*')) {\
+ /* must be x. or x- or x+ or x */\
+ state2 = ANY;\
+ }\
+ else {\
+ state2 = !isdigit(v[i]) ? CSTRING : NUMBER;\
+ }\
+ leading0 = v[i] == '0' ? true : false;\
+ }\
+ else {\
+ /* in a component */\
+ if (state2 == NUMBER and !hasG(DELIMITERS, v[i])) {\
+ /* number must have only digit */\
+ if (!isdigit(v[i])) goto fail;\
+ /* no leading 0 in numbers */\
+ if (leading0) goto fail;\
+ }\
+ }\
+ prevState = state
+
+ switchLabel(PR_DELIMITER[0], PRE, others);
+ switchLabel(BD_DELIMITER[0], BUILD, others);
+ validStrictLabel(others);
+ break;
+ case PRE:
+ // no empty components
+ if (hasG(DELIMITERS, v[i-1]) and hasG(DELIMITERS, v[i])) goto fail;
+ switchLabel(BD_DELIMITER[0], BUILD, prerelease);
+ validStrictLabel(prerelease);
+ break;
+ case BUILD:
+ if (hasG(DELIMITERS, v[i-1]) and hasG(DELIMITERS, v[i])) goto fail;
+ validStrictLabel(build);
+ break;
+ }
+ }
+ parsingFinish:
+
+ /* the version string has been parsed */
+ self->empty = false;
+
+ /* lv(STATE[state]); */
+ /* lv(STATE[prevState]); */
+ /* lv(STATE[state2]); */
+ /* lv(leading0); */
+
+ // MUST NOT end with empty component
+ if (loose) {
+ if (hasG(DELIMITER, *curs)) goto fail;
+ prevState = state;
+
+ if (isCmp) {
+ // handle x alone "x" to match any version, signaled with self->empty=true
+ if (state == REL and (hasG(ANYTOKENS, *curs) or (curs != v and hasG(ANYTOKENS, *(curs-1))))) {
+ self->empty = true;
+ goto end;
+ }
+ // handle x in components
+ if (state == MAJOR and hasG(DELIMITERS, *(curs+1)) and hasG(ANYTOKENS, *curs)) {
+ // ignore last - or + for compares
+ self->major = -1;
+ goto end;
+ }
+ // if last component has an any token, it doesn't need to be parsed
+ if (hasG(ANYTOKENS, component) and state < OTHERS) goto end;
+ }
+ }
+ else {
+ if (hasG(DELIMITERS, curs)) goto fail;
+ }
+
+ // check for incomplete components
+ if (prevState != state) goto fail;
+
+ // versions must have 3 components (except when loose is set) Release.Major.minor
+ if (state < MINOR and !release0) goto fail;
+
+ if (!validate) {
+ // parse the last component
+ switch(state) {
+ case REL:
+ self->release = parseI64(component);
+ self->mainComponentCount++;
+ break;
+ case MAJOR:
+ self->major = parseI64(component);
+ self->mainComponentCount++;
+ break;
+ case MINOR:
+ self->minor = parseI64(component);
+ self->mainComponentCount++;
+ break;
+ case PATCH:
+ self->patch = parseI64(component);
+ self->mainComponentCount++;
+ break;
+ case OTHERS:
+ #define lastComponent(label)\
+ if (state2 == NUMBER) {\
+ pushG(&self->label, parseI64(component));\
+ }\
+ elif (state2 == CSTRING) {\
+ pushG(&self->label, component);\
+ }\
+ elif (state2 == ANY) {\
+ pushG(&self->label, -1);\
+ }
+ lastComponent(others);
+ break;
+ case PRE:
+ lastComponent(prerelease);
+ break;
+ case BUILD:
+ lastComponent(build);
+ break;
+ }
+ }
+
+ end:
+ free(v);
+ ret true;
+
+ fail:
+ free(v);
+ ret false;
+}
+
+local bool validVersion(versiont *self UNUSED, const char *v) {
+ ret parse(self, (char*)v, true /*validate*/, false /*loose*/, false /*isCmp*/);
+}
+
+local bool parseCmpVersion(versiont *self, const char *v, bool isCmp) {
+ if (!v) ret false;
+
+ freeVersion(self);
+ self->originalVer = strdup(v);
+
+ if (!cleanVersion(self, self->originalVer)) ret false;
+
+ ret parse(self, self->originalVer, false /*validate*/, true /*loose*/, isCmp);
+}
+
+local bool parseVersion(versiont *self, const char *v) {
+ ret parseCmpVersion(self, v, false /*isCmp*/);
+}
+
+local bool parseStrictVersion(versiont *self, const char *v) {
+
+ if (!v) ret false;
+
+ freeVersion(self);
+ self->originalVer = strdup(v);
+
+ if (!cleanVersion(self, self->originalVer) or !validVersion(self, self->originalVer)) ret false;
+
+ ret parse(self, self->originalVer, false /*validate*/, false /*loose*/, false /*isCmp*/);
+}
+
+local bool cleanVersion(versiont *self UNUSED, char *v) {
+ if (!v) ret false;
+
+ size_t dest = 0;
+ // keep only valid characters
+ range(i, strlen(v)) {
+ if (isValidChar(v[i])) {
+ if (dest < i) {
+ v[dest] = v[i];
+ }
+ dest++;
+ }
+ }
+
+ // terminate string
+ v[dest] = 0;
+
+ ret true;
+}
+
+local bool equalVersion(versiont *self, versiont *ver) {
+ if (!ver) ret false;
+
+ #define eqComp(comp) if (self->comp != ver->comp) ret false
+ eqComp(release);
+ eqComp(major);
+ eqComp(minor);
+ eqComp(patch);
+ #define eqLabel(label) if (!eqG(&self->label, &ver->label)) ret false
+ eqLabel(others);
+ eqLabel(prerelease);
+ eqLabel(build);
+
+ ret true;
+}
+
+local bool equalSVersion(versiont *self, const char *v) {
+ if (!v) ret false;
+
+ bool r = false;
+ createVersion(ver);
+ r = parseO(&ver, v);
+ if (!r) /* error parsing*/ goto end;
+
+ r = equalVersion(self, &ver);
+
+ end:
+ freeO(&ver);
+ ret r;
+}
+
+local bool equalSSVersion(versiont *self UNUSED, const char *v1, const char *v2) {
+ if (!v1 or !v2) ret false;
+
+ bool r = false;
+ createVersion(ver1);
+ r = parseO(&ver1, v1);
+ if (!r) /* error parsing*/ ret false;
+ createVersion(ver2);
+ r = parseO(&ver2, v2);
+ if (!r) /* error parsing*/ ret false;
+
+ r = eqO(&ver1, &ver2);
+
+ freeO(&ver1);
+ freeO(&ver2);
+ ret r;
+}
+
+local int cmpVersion(versiont *self, versiont *ver) {
+ if (!ver) ret 0;
+
+ int r = 0;
+
+ #define cmpComp(comp)\
+ r = CMP(self->comp, ver->comp);\
+ if (r) ret r;
+ cmpComp(release);
+ cmpComp(major);
+ cmpComp(minor);
+ cmpComp(patch);
+
+ if (lenG(&self->others) > lenG(&ver->others)) {
+ #define cmpLabel(label, x, y, returnSign)\
+ iter(&x->label, c) {\
+ if (isOSmallIntG(c) and isEIntG(&y->label, iterIndexG(&x->label))) {\
+ /* both ints */\
+ var a = getG(&y->label, rtI64, iterIndexG(&x->label));\
+ cast(smallIntt*, b, c);\
+ r = cmpOrder(a, getValG(b));\
+ if (r) ret r;\
+ }\
+ elif (!isOSmallIntG(c) and !isEIntG(&y->label, iterIndexG(&x->label))) {\
+ /* both strings */\
+ var a = getG(&y->label, rtChar, iterIndexG(&x->label));\
+ r = scmpOrder(a, ssGet(c));\
+ if (r) ret r;\
+ }\
+ else {\
+ /* one is int and the other is string */\
+ baset *ao = getG(&y->label, rtBaset, iterIndexG(&x->label));\
+ char *a = toStringO(ao);\
+ finishG(ao);\
+ char *b = toStringO(c);\
+ r = scmpOrder(a,b);\
+ freeManyS(a,b);\
+ if (r) ret r;\
+ }\
+ }\
+ /* y has components left, so it is greater than x */\
+ if (lenG(&y->label) > lenG(&x->label)) ret 1 * returnSign;\
+ if (lenG(&y->label) < lenG(&x->label)) ret -1 * returnSign
+ #define cmpOrder(a,b) CMP(a,b)
+ #define scmpOrder(a,b) strcmp(a,b)
+ cmpLabel(others, ver, self, 1 /*returnSign*/);
+ #undef cmpOrder
+ #undef scmpOrder
+ }
+ else {
+ #define cmpOrder(a,b) CMP(b,a)
+ #define scmpOrder(a,b) strcmp(b,a)
+ cmpLabel(others, self, ver, -1 /*returnSign*/);
+ #undef cmpOrder
+ #undef scmpOrder
+ }
+ // prereleases have lower precedence
+ if (!lenG(&self->prerelease) and lenG(&ver->prerelease)) ret 1;
+ if (lenG(&self->prerelease) and !lenG(&ver->prerelease)) ret -1;
+ // self and ver are both normal versions or both prereleases
+ if (lenG(&self->prerelease) > lenG(&ver->prerelease)) {
+ #define cmpOrder(a,b) CMP(a,b)
+ #define scmpOrder(a,b) strcmp(a,b)
+ cmpLabel(prerelease, ver, self, 1 /*returnSign*/);
+ #undef cmpOrder
+ #undef scmpOrder
+ }
+ else {
+ #define cmpOrder(a,b) CMP(b,a)
+ #define scmpOrder(a,b) strcmp(b,a)
+ cmpLabel(prerelease, self, ver, -1 /*returnSign*/);
+ #undef cmpOrder
+ #undef scmpOrder
+ }
+ if (lenG(&self->build) > lenG(&ver->build)) {
+ #define cmpOrder(a,b) CMP(a,b)
+ #define scmpOrder(a,b) strcmp(a,b)
+ cmpLabel(build, ver, self, 1 /*returnSign*/);
+ #undef cmpOrder
+ #undef scmpOrder
+ }
+ else {
+ #define cmpOrder(a,b) CMP(b,a)
+ #define scmpOrder(a,b) strcmp(b,a)
+ cmpLabel(build, self, ver, -1 /*returnSign*/);
+ #undef cmpOrder
+ #undef scmpOrder
+ }
+
+ ret r;
+}
+
+local int cmpSVersion(versiont *self, const char *v) {
+ if (!v) ret 0;
+
+ int r = 0;
+ createVersion(ver);
+ r = parseO(&ver, v);
+ if (!r) /* error parsing*/ ret 0;
+
+ r = cmpVersion(self, &ver);
+
+ freeO(&ver);
+ ret r;
+}
+
+local int cmpSSVersion(versiont *self UNUSED, const char *v1, const char *v2) {
+ if (!v1 or !v2) ret 0;
+
+ int r = 0;
+ createVersion(ver1);
+ r = parseO(&ver1, v1);
+ if (!r) /* error parsing*/ ret 0;
+ createVersion(ver2);
+ r = parseO(&ver2, v2);
+ if (!r) /* error parsing*/ ret 0;
+
+ r = cmpO(&ver1, &ver2);
+
+ freeO(&ver1);
+ freeO(&ver2);
+ ret r;
+}
+
+local bool incVersion(versiont *self, u32 level) {
+ switch(level) {
+ case releaseVer:
+ self->release++;
+ break;
+ case majorVer:
+ self->major++;
+ // Patch and minor version MUST be reset to 0 when major version is incremented
+ self->minor = 0;
+ self->patch = 0;
+ emptyG(&self->others);
+ emptyG(&self->prerelease);
+ emptyG(&self->build);
+ break;
+ case minorVer:
+ self->minor++;
+ // Patch version MUST be reset to 0 when major version is incremented
+ self->patch = 0;
+ emptyG(&self->others);
+ emptyG(&self->prerelease);
+ emptyG(&self->build);
+ break;
+ case patchVer:
+ self->patch++;
+ break;
+ default:
+ level -= 4;
+ if (lenG(&self->others)) {
+ baset *c = getG(&self->others, rtBaset, level);
+ if (!c) {
+ // out of range
+ level -= lenG(&self->others);
+ if (lenG(&self->prerelease)) goto prerel;
+ if (lenG(&self->build)) goto buildl;
+ ret false;
+ }
+ #define incC\
+ if (!isOSmallInt(c)) {\
+ finishG(c);\
+ ret false;\
+ }\
+ cast(smallIntt*, v, c);\
+ (*getPG(v))++;\
+ finishG(c)
+ incC;
+ }
+ elif (lenG(&self->prerelease)) {
+ prerel:;
+ baset *c = getG(&self->prerelease, rtBaset, level);
+ if (!c) {
+ // out of range
+ level -= lenG(&self->prerelease);
+ if (lenG(&self->build)) goto buildl;
+ ret false;
+ }
+ incC;
+ }
+ elif (lenG(&self->build)) {
+ buildl:;
+ baset *c = getG(&self->build, rtBaset, level);
+ if (!c) {
+ // out of range
+ ret false;
+ }
+ incC;
+ }
+ }
+ ret true;
+}
+
+local int sortVer(const void * A, const void * B) {
+ castS(a, A);
+ castS(b, B);
+ createVersion(va);
+ parseO(&va, ssGet(a));
+ createVersion(vb);
+ parseO(&vb, ssGet(b));
+
+ int r = cmpO(&va, &vb);
+
+ freeO(&va);
+ freeO(&vb);
+
+ ret r;
+}
+
+local smallArrayt* sortVersion(versiont *self UNUSED, smallArrayt *vlist) {
+ if (!vlist and !isOSmallArray(vlist)) ret NULL;
+
+ createAllocateSmallArray(r);
+ createVersion(v);
+
+ iter(vlist, VS) {
+ if (!isOSmallString(VS)) continue;
+ // keep only valid version string
+ if (!parseO(&v, ssGet(VS))) continue;
+ pushG(r, ssGet(VS));
+ }
+
+ freeO(&v);
+
+ sortFG(r, sortVer);
+ ret r;
+}
+
+
+
+local bool satisfiesVersion(versiont *self, const char *vrange) {
+ if (!vrange) ret false;
+
+ if (isBlankG(vrange)) {
+ /* range string is empty, match anything */
+ ret true;
+ }
+
+ bool r = false;
+
+ enum {SEARCH, SEARCH_OR, SEARCH_OR_END, EQ, GT, GTE, LT, LTE, CMP_LAST,
+ /*hyphen state*/ SPACE, HYPHEN, HYPHEN_CHAR, HYPHEN_SEARCH, HYPHEN_LAST,
+ TILDE,
+ CARET};
+ const char* STATE[] UNUSED = {"SEARCH", "SEARCH_OR", "SEARCH_OR_END", "EQ", "GT", "GTE", "LT", "LTE", "CMP_LAST",
+ /*hyphen state*/ "SPACE", "HYPHEN", "HYPHEN_CHAR", "HYPHEN_SEARCH", "HYPHEN_LAST",
+ "TILDE",
+ "CARET"};
+ u8 state = SEARCH;
+ // First or second comparator in range: >=ver1 <ver2
+ enum {FIRST, LAST, NONE};
+ const char*CMPTOR[] UNUSED = {"FIRST", "LAST", "NONE"};
+ u8 cmptor = NONE;
+ char *vr = dupG(vrange);
+ char *c = vr;
+ char *vers = NULL;
+
+ enum {NOP, CMP_EQ, CMP_LT, CMP_LTE, CMP_GT, CMP_GTE,
+ HYPHEN_GTE, HYPHEN_LT,
+ CMP_XRANGE,
+ CMP_TILDE,
+ CMP_CARET};
+ const char* OPTYPE[] UNUSED = {"NOP", "CMP_EQ", "CMP_LT", "CMP_LTE", "CMP_GT", "CMP_GTE",
+ "HYPHEN_GTE", "HYPHEN_LT",
+ "CMP_XRANGE",
+ "CMP_TILDE",
+ "CMP_CARET"};
+
+ // parsed comparator
+ struct {
+ u8 type;
+ versiont v;
+ } cmp;
+ // comparator results
+ bool res[2];
+
+ cmp.type = NOP;
+ initiateVersion(&cmp.v);
+
+ void doLT(void) {
+ logI("<");
+
+ #define parseCmpVer(str, freeV)\
+ if (!parseCmpVersion(&v, str, true /*isCmp*/)) {\
+ r = false;\
+ freeV;\
+ goto end;\
+ }
+ #define anyValue(comp) if ((i64)v.comp == -1) v.comp = self->comp;
+ #define anyLabel(label)\
+ iter(&v.label, o) {\
+ if (isOSmallInt(o)) {\
+ cast(smallIntt*, i, o);\
+ if (getValG(i) == -1) {\
+ baset *val = getG(&self->label, rtBaset, iterIndexG(&v.label));\
+ if (val) {\
+ setNFreeG(&v.label, iterIndexG(&v.label), dupG(val));\
+ }\
+ }\
+ }\
+ }
+ #define anyVer\
+ anyValue(release);\
+ anyValue(major);\
+ anyValue(minor);\
+ anyValue(patch);\
+ anyLabel(others);\
+ anyLabel(prerelease);\
+ anyLabel(build)
+
+ // TODO assign any in LT LTE GT GTE
+ #define doComp(comp) if (self->comp != v.comp) { res[cmptor] = false; freeO(&v); goto end;}
+ #define doLabel(label) if (!eqG(&self->label, &v.label)) { res[cmptor] = false; freeO(&v); goto end;}
+ #define genVerForCmp(compareResult, checkEqual, isLT)\
+ /* when there is -, prereleases are not matched */\
+ /* when there is no -, prereleases are matched */\
+ char *cver;\
+ char *sl = sliceS(vers, 0, -1);\
+ cver = strdup(vers);\
+ createVersion(v);\
+ if (!hasG(sl, '-') and *(c-1) != '-') {\
+ /* not selecting a prerelease and not - at the end */\
+ /* self MUST be a normal version */\
+ if (isLT and !isEmptyG(&self->prerelease)) { res[cmptor] = false; goto end;}\
+ if (checkEqual) {res[cmptor] = true; goto end;}\
+ if (isLT) pushG(&cver, "-0"); /* for GT: dont add -0 so that prereleases are not selected */\
+ if (!isLT and !isEmptyG(&self->prerelease)) {\
+ /* select normal versions only for GT ops */\
+ res[cmptor] = false; goto end;\
+ }\
+ parseCmpVer(cver,);\
+ anyVer;\
+ }\
+ else {\
+ if (!isEmptyG(&self->prerelease)) {\
+ /* consider prerelease of version in the compare only */\
+ parseCmpVer(cver,);\
+ anyVer;\
+ if (self->release != v.release) { res[cmptor] = false; freeO(&v); goto end;}\
+ doComp(release);\
+ doComp(major);\
+ doComp(minor);\
+ doComp(patch);\
+ doLabel(others);\
+ }\
+ if (!isLT and !hasG(sl, '-') and *(c-1) == '-') pushG(&cver, "0"); /* for GT: add -0 so that prereleases are selected */\
+ parseCmpVer(cver,);\
+ }\
+ int R = cmpVersion(self, &v);\
+ compareResult\
+ end:\
+ freeO(&v);\
+ free(sl);\
+ free(cver);
+ genVerForCmp(if (R < 0) res[cmptor] = true; else res[cmptor] = false;, false/*checkEqual*/, true/*isLT*/);
+ }
+
+ void doLTE(void) {
+ logI("<=");
+
+ genVerForCmp(if (R <= 0) res[cmptor] = true; else res[cmptor] = false;, equalSVersion(self, cver)/*checkEqual*/, true/*isLT*/);
+ }
+
+ void doGT(void) {
+ logI(">");
+
+ genVerForCmp(if (R > 0) res[cmptor] = true; else res[cmptor] = false;, false/*checkEqual*/, false/*isLT*/);
+ }
+
+ void doGTE(void) {
+ logI(">=");
+
+ genVerForCmp(if (R >= 0) res[cmptor] = true; else res[cmptor] = false;, equalSVersion(self, cver)/*checkEqual*/, false/*isLT*/);
+ }
+
+ void doEq(void) {
+ createVersion(v);
+ parseCmpVer(vers,);
+ if (v.empty) {
+ // v is any version, eq always matches self
+ r = true;
+ goto end;
+ }
+ // check if it is x range
+ // maybe any component is at the end
+ anyValue(release);
+ char c = getG(vers,unusedV,-1);
+ if (c == 'x' or c == 'X' or c == '*') {
+ #define xrange(high, relOrPreOrBuild)\
+ v.minor = 0;\
+ vers = toStringO(&v);\
+ relOrPreOrBuild;\
+ cmptor = FIRST;\
+ doGTE();\
+ free(vers);\
+ v.high++;\
+ vers = toStringO(&v);\
+ cmptor = LAST;\
+ doLT();\
+ free(vers)
+ #define xrangeRelOrPreOrBuild(relOrPreOrBuild)\
+ if ((i64)v.major != -1 and (i64)v.minor == -1) {\
+ xrange(major, relOrPreOrBuild);\
+ }\
+ elif ((v.minor == 0 or (i64)v.minor == -1) and (i64)v.major == -1) {\
+ v.major = 0;\
+ xrange(release, relOrPreOrBuild);\
+ }
+ xrangeRelOrPreOrBuild();
+
+ #define xrangeIsDetected\
+ cmp.type = CMP_XRANGE;\
+ cmptor = LAST;\
+ goto end
+ xrangeIsDetected;
+ }
+ elif (c == '-') {
+ c = getG(vers,unusedV,-2);
+ if (c == 'x' or c == 'X' or c == '*') {
+ xrangeRelOrPreOrBuild(pushG(&vers, '-'));
+ if (res[LAST] == false and res[FIRST] == true and lenG(&self->prerelease)) {
+ // prerelease on lower bound of xrange is accepted when - is at the end of comparator
+ res[LAST] = true;
+ }
+ xrangeIsDetected;
+ }
+ }
+ elif (c == '+') {
+ c = getG(vers,unusedV,-2);
+ if (c == 'x' or c == 'X' or c == '*') {
+ xrangeRelOrPreOrBuild();
+ xrangeIsDetected;
+ }
+ }
+ anyVer;
+ r = res[0] = res[1] = equalVersion(self, &v);
+ logP(BLD WHT"Cmptor result: %b"RST, r);
+ end:
+ freeO(&v);
+ }
+
+ i16 index = 0;
+ while(*c) {
+ /* lv(STATE[state]); */
+ /* lv(CMPTOR[cmptor]); */
+ /* lv(index); */
+ /* lv(res[cmptor]); */
+
+ if (*c == '|' and (*(c+1) == '|')) {
+ /* lv(STATE[state]); */
+ /* lv(CMPTOR[cmptor]); */
+ /* lv(OPTYPE[cmp.type]); */
+ if (cmptor == FIRST) {
+ r = res[0];
+ logP(BLD WHT"Cmptor result: %b"RST, r);
+ if (r) /* matching, stop. */ goto end;
+ cmptor = NONE;
+ }
+ state = SEARCH_OR_END;
+ }
+ switch(state) {
+ #define skipSpace if (isspace(*c)) break
+ #define switchCmptor\
+ if (cmptor == LAST) goto fail;\
+ if (cmptor == FIRST) cmptor = LAST;\
+ if (cmptor == NONE) {\
+ /* reset results */\
+ res[0] = res[1] = true;\
+ cmptor = FIRST;\
+ }
+ case EQ:
+ case TILDE:
+ case CARET:
+ cmp_eq:
+ if (isspace(*c)) {
+ state = CMP_LAST;
+ goto cmp_last;
+ }
+ break;
+ case LT:
+ case LTE:
+ case GT:
+ case GTE:
+ if (!vers) {
+ skipSpace;
+ if (isdigit(*c) or *c == 'x' or *c == 'X' or *c == '*') vers = c;
+ break;
+ }
+ if (isspace(*c)) {
+ state = CMP_LAST;
+ goto cmp_last;
+ }
+ break;
+ case HYPHEN_CHAR:
+ if (*c == '-') state = HYPHEN_SEARCH;
+ break;
+ case HYPHEN:
+ if (isspace(*c)) {
+ state = HYPHEN_LAST;
+ goto hyphen_last;
+ }
+ break;
+ case HYPHEN_SEARCH:
+ skipSpace;
+ if (isdigit(*c) or *c == 'x' or *c == 'X' or *c == '*') {
+ switchCmptor;
+ cmp.type = HYPHEN_LT;
+ vers = c;
+ state = HYPHEN;
+ break;
+ }
+ goto fail;
+ break;
+ case SEARCH:
+ skipSpace;
+ // any must be x, X or * in a component
+ if ((*c == 'x' or *c == 'X' or *c == '*') and (*(c+1) != '.' and *(c+1) != '-' and *(c+1) != '+') and *(c+1) != ' ' and *(c+1) != 0) goto fail;
+ if (*c == '=') {
+ cmp.type = CMP_EQ;
+ vers = c+1;
+ state = EQ;
+ //allow equal in comparators - if (cmptor != NONE) goto fail;
+ cmptor = LAST;
+ break;
+ }
+ if (isdigit(*c) or *c == 'x' or *c == 'X' or *c == '*') {
+ // scan further to distinguish between equal hyphen range
+ char *sc = c+1;
+ bool isHyphen = false;
+ int hyphenState = SEARCH;
+ do {
+ if (*sc == '|' and *(sc+1) == '|') /*end of comparator*/ break;
+ if (hyphenState == SPACE and *sc == '-') {
+ isHyphen = true;
+ break;
+ }
+ if (hyphenState == SEARCH and isspace(*sc)) hyphenState = SPACE;
+ } while(*(sc++));
+ if (isHyphen) {
+ cmp.type = HYPHEN_GTE;
+ vers = c;
+ state = HYPHEN;
+ /* reset results */
+ res[0] = res[1] = true;
+ cmptor = FIRST;
+ break;
+ }
+ else {
+ cmp.type = CMP_EQ;
+ vers = c;
+ state = EQ;
+ //allow equal in comparators - if (cmptor != NONE) goto fail;
+ cmptor = LAST;
+ goto cmp_eq;
+ }
+ }
+ if (*c == '>') {
+ switchCmptor;
+ vers = NULL;
+ if (*(c+1) == '=') {
+ cmp.type = CMP_GTE;
+ state = GTE;
+ }
+ else {
+ cmp.type = CMP_GT;
+ state = GT;
+ }
+ break;
+ }
+ if (*c == '<') {
+ switchCmptor;
+ vers = NULL;
+ if (*(c+1) == '=') {
+ cmp.type = CMP_LTE;
+ state = LTE;
+ }
+ else {
+ cmp.type = CMP_LT;
+ state = LT;
+ }
+ break;
+ }
+ if (*c == '~') {
+ cmp.type = CMP_TILDE;
+ vers = c+1;
+ state = TILDE;
+ cmptor = LAST;
+ break;
+ }
+ if (*c == '^') {
+ cmp.type = CMP_CARET;
+ vers = c+1;
+ state = CARET;
+ cmptor = LAST;
+ break;
+ }
+ goto fail;
+ break;
+ case SEARCH_OR:
+ // empty because the comparator has 1 or 2 compares, extra compares are ignored
+ break;
+ case SEARCH_OR_END:
+ if (*(c+1) != '|') state = SEARCH;
+ break;
+ case CMP_LAST:
+ cmp_last:
+ switch(cmp.type) {
+ case CMP_EQ:;
+ char cc = *c;
+ *c = 0;
+ doEq();
+ if (cmp.type == CMP_XRANGE) goto next;
+ if (r) /* matching, stop. */ goto end;
+ *c = cc;
+ break;
+ case CMP_LT:
+ #define you(op)\
+ cc = *c;\
+ *c = 0;\
+ op();\
+ *c = cc
+ you(doLT);
+ break;
+ case CMP_LTE:
+ you(doLTE);
+ break;
+ case CMP_GT:
+ you(doGT);
+ break;
+ case CMP_GTE:
+ you(doGTE);
+ break;
+ case CMP_TILDE:
+ // TODO any component
+ #define tilde(comp, zero)\
+ bool acceptPreRel = false;\
+ if (hasG(vers, '-')) {\
+ pushG(&v.prerelease, 0);\
+ acceptPreRel = true;\
+ }\
+ cmptor = FIRST;\
+ doGTE();\
+ v.comp++;\
+ zero;\
+ v.patch = 0;\
+ freeG(&v.others);\
+ freeG(&v.prerelease);\
+ freeG(&v.build);\
+ vers = toStringO(&v);\
+ cmptor = LAST;\
+ doLT();\
+ free(vers);\
+ if (acceptPreRel and res[LAST] == false and res[FIRST] == true and lenG(&self->prerelease)) {\
+ /* prerelease on lower bound of xrange is accepted when - is at the end of comparator */\
+ res[LAST] = true;\
+ }
+ #define tildeCmp(label)\
+ createVersion(v);\
+ parseCmpVer(vers, freeO(&v));\
+ if (v.mainComponentCount >= 3) {\
+ tilde(minor,);\
+ freeO(&v);\
+ goto label;\
+ }\
+ elif (v.mainComponentCount == 2) {\
+ tilde(major, v.minor = 0);\
+ freeO(&v);\
+ goto label;\
+ }\
+ elif (v.mainComponentCount == 1) {\
+ tilde(release, v.major = 0 ; v.minor = 0);\
+ freeO(&v);\
+ goto label;\
+ }\
+ freeO(&v)
+ tildeCmp(next);
+ break;
+ case CMP_CARET: {
+ // TODO any component
+ #define caret(comp, zero)\
+ bool acceptPreRel = false;\
+ if (hasG(vers, '-')) {\
+ pushG(&v.prerelease, 0);\
+ acceptPreRel = true;\
+ }\
+ cmptor = FIRST;\
+ doGTE();\
+ v.comp++;\
+ zero;\
+ v.minor = 0;\
+ v.patch = 0;\
+ freeG(&v.others);\
+ freeG(&v.prerelease);\
+ freeG(&v.build);\
+ vers = toStringO(&v);\
+ cmptor = LAST;\
+ doLT();\
+ free(vers);\
+ if (acceptPreRel and res[LAST] == false and res[FIRST] == true and lenG(&self->prerelease)) {\
+ /* prerelease on lower bound of xrange is accepted when - is at the end of comparator */\
+ res[LAST] = true;\
+ }
+ #define caretCmp(label)\
+ createVersion(v);\
+ parseCmpVer(vers, freeO(&v));\
+ if (v.mainComponentCount >= 2) {\
+ caret(major,);\
+ freeO(&v);\
+ goto label;\
+ }\
+ elif (v.mainComponentCount == 1) {\
+ caret(release, v.major = 0);\
+ freeO(&v);\
+ goto label;\
+ }\
+ freeO(&v)
+ caretCmp(next);
+ }
+ break;
+ }
+ next:
+ cmp.type = NOP;
+ switch(cmptor) {
+ case FIRST:
+ state = SEARCH;
+ break;
+ case LAST:
+ r = res[0] and res[1];
+ logP(BLD WHT"Cmptor result: %b"RST, r);
+ if (r) /* matching, stop. */ goto end;
+ cmptor = NONE;
+ state = SEARCH_OR;
+ break;
+ }
+ break;
+ case HYPHEN_LAST:
+ hyphen_last:
+ switch(cmp.type) {
+ char cc;
+ case HYPHEN_GTE:
+ you(doGTE);
+ state = HYPHEN_CHAR;
+ break;
+ case HYPHEN_LT:
+ #define hyphenLTVer\
+ char *cs = toStringO(&v);\
+ vers = cs;\
+ doLT();\
+ free(cs)
+ #define hyphenCmp\
+ /* LTE when there are a least 3 components
+ LT when there are less than 3 components */\
+ createVersion(v);\
+ parseCmpVer(vers, freeO(&v));\
+ if (v.minor) {\
+ UNIQVAR(atleast):\
+ /*at least 3 components: LTE*/\
+ doLTE();\
+ }\
+ else {\
+ if (v.patch or lenG(&v.others)) goto UNIQVAR(atleast);\
+ /*less than 3 components LT */\
+ if (v.major) {\
+ v.major++;\
+ hyphenLTVer;\
+ }\
+ elif (v.release) {\
+ v.release++;\
+ hyphenLTVer;\
+ }\
+ else doLT();\
+ }\
+ r = res[0] and res[1];\
+ logP(BLD WHT"Hyphen Cmptor result: %b"RST, r);\
+ if (r) /* matching, stop. */ { freeO(&v); goto end;}\
+ freeO(&v)
+ hyphenCmp;
+ cmptor = NONE;
+ state = SEARCH_OR;
+ break;
+ }
+ break;
+ }
+ c++;
+ index++;
+ }
+
+ // finish comparing
+ switch(state) {
+ case SEARCH_OR:
+ finalResult:
+ lv(res[0]);
+ lv(res[1]);
+ r = res[0] and res[1];
+ logP("Cmptor result: %b", r);
+ break;
+ case EQ:
+ doEq();
+ if (cmp.type == CMP_XRANGE) goto finalResult;
+ break;
+ case LT:
+ #define finalOp(op)\
+ if (!vers) goto fail;\
+ op();\
+ goto finalResult;\
+ break
+ finalOp(doLT);
+ case LTE:
+ finalOp(doLTE);
+ case GT:
+ finalOp(doGT);
+ case GTE:
+ finalOp(doGTE);
+ case HYPHEN:
+ if (cmp.type == HYPHEN_GTE) /*incomplete hyphen range*/ goto fail;
+ if (cmp.type == HYPHEN_LT) {
+ hyphenCmp;
+ }
+ break;
+ case HYPHEN_CHAR:
+ case HYPHEN_SEARCH:
+ /*incomplete hyphen range*/
+ goto fail;
+ break;
+ case TILDE:
+ tildeCmp(finalResult);
+ goto fail;
+ break;
+ case CARET: {
+ caretCmp(finalResult);
+ goto fail;
+ }
+ break;
+ }
+
+ end:
+ free(vr);
+ ret r;
+
+ fail:
+ free(vr);
+ ret false;
+}
+
+local smallJsont* toJsonVersion(versiont *self) {
+ createAllocateSmallJson(r);
+ setG(r, "release", self->release);
+ setG(r, "major", self->major);
+ setG(r, "minor", self->minor);
+ setG(r, "patch", self->patch);
+ setNFreeG(r, "others", dupG(&self->others));
+ setNFreeG(r, "prerelease", dupG(&self->prerelease));
+ setNFreeG(r, "build", dupG(&self->build));
+ ret r;
+}
+
+local char* toJsonStrVersion(versiont *self) {
+ var j = toJsonVersion(self);
+ char *r = toStringG(j);
+ terminateG(j);
+ ret r;
+}
+
+local bool fromJsonVersion(versiont *self, smallJsont *json) {
+ freeVersion(self);
+ if (!json or isEmptyG(json)) ret false;
+
+ if (!hasG(json, "release")) ret false;
+
+ self->release = getG(json, rtI64, "release");
+ self->major = getG(json, rtI64, "major");
+ self->minor = getG(json, rtI64, "minor");
+ self->patch = getG(json, rtI64, "patch");
+
+ smallArrayt *a;
+ a = getNDupG(json, rtSmallArrayt, "others");
+ if (a) {
+ setsoG(&self->others, getsoG(a));
+ finishG(a);
+ }
+ a = getNDupG(json, rtSmallArrayt, "prerelease");
+ if (a) {
+ setsoG(&self->prerelease, getsoG(a));
+ finishG(a);
+ }
+ a = getNDupG(json, rtSmallArrayt, "build");
+ if (a) {
+ setsoG(&self->build, getsoG(a));
+ finishG(a);
+ }
+
+ ret true;
+}
+
+local bool fromJsonStrVersion(versiont *self, const char *json) {
+ freeVersion(self);
+ if (!json) ret false;
+ createSmallJson(j);
+ parseG(&j, (char*)json);
+ bool r = fromJsonVersion(self, &j);
+ freeG(&j);
+ ret r;
+}
+
+// vim: set expandtab ts=2 sw=2:
diff --git a/version.h b/version.h
@@ -0,0 +1,226 @@
+#pragma once
+
+/* Libsheepy documentation: http://spartatek.se/libsheepy/ */
+
+#define validO(obj, versionString) (obj)->f->valid(obj, versionString)
+// parseO reused from libsheepyObject.h
+#define parseStrictO(obj, versionString) (obj)->f->parseStrict(obj, versionString)
+#define eqO equalO
+#define eqSO(obj, version) (obj)->f->equalS(obj, version)
+#define eqSSO(obj, v1, v2) (obj)->f->equalSS(obj, v1, v2)
+#define cmpO(obj, versionObj) (obj)->f->cmp(obj, versionObj)
+#define cmpSO(obj, version) (obj)->f->cmpS(obj, version)
+#define cmpSSO(obj, v1, v2) (obj)->f->cmpSS(obj, v1, v2)
+#define incO(obj, level) (obj)->f->inc(obj, level)
+#define vsortO(obj, varray) (obj)->f->sort(obj, varray)
+#define satisfiesO(obj, vrange) (obj)->f->satisfies(obj, vrange)
+#define toJsonO(obj) (obj)->f->toJson(obj)
+#define toJsonStrO(obj) (obj)->f->toJsonStr(obj)
+#define fromJsonO(obj, json) (obj)->f->fromJson(obj, json)
+#define fromJsonStrO(obj, json) (obj)->f->fromJsonStr(obj, json)
+
+// inc level parameter
+enum {releaseVer, majorVer, minorVer, patchVer};
+
+/* Class version */
+typ struct version versiont;
+
+/* for object inheriting version, cast to version to be able to use this class functions and generics*/
+#define cVersion(self) ( (versiont*) self )
+
+typ void (*freeVersionFt) (versiont *self);
+typ void (*terminateVersionFt) (versiont **self);
+typ char* (*toStringVersionFt) (versiont *self);
+typ versiont* (*duplicateVersionFt) (versiont *self);
+typ void (*smashVersionFt) (versiont **self);
+
+/**
+ * free version
+ */
+typ void (*finishVersionFt) (versiont **self);
+
+typ const char* (*helpVersionFt) (versiont *self);
+
+/**
+ * log version string
+ */
+typ void (*logVersionFt) (versiont *self);
+
+/**
+ * valid returns true when v is an incomplete version that can be made into a strictly valid version
+ */
+typ bool (*validVersionFt) (versiont *self, const char *v);
+
+/**
+ * parse the version string and store result in self
+ * Versions are in the format:
+ * Release.Major.minor.patch.others-prerelease+build
+ */
+typ bool (*parseVersionFt) (versiont *self, const char *v);
+/**
+ * true if v version string is strictly valid.
+ * - v starts with release number
+ * - all version numbers are correctly separated
+ * - v doesn't end with a separator
+ */
+typ bool (*parseStrictVersionFt)(versiont *self, const char *v);
+/**
+ * keep only characters in
+ * .-+0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ*
+ * Other characters are stripped
+ */
+typ bool (*cleanVersionFt) (versiont *self, char *v);
+/**
+ * true when ver is equal to self
+ */
+typ bool (*equalVersionFt) (versiont *self, versiont *ver);
+/**
+ * true when v version string is equal to self
+ */
+typ bool (*equalSVersionFt) (versiont *self, const char *v);
+/**
+ * true when v1 and v2 version strings are equal
+ */
+typ bool (*equalSSVersionFt) (versiont *self, const char *v1, const char *v2);
+/**
+ * compare versions
+ * \return
+ * -1 when self < ver
+ * 0 when self == ver
+ * 1 when self > ver
+ */
+typ int (*cmpVersionFt) (versiont *self, versiont *ver);
+/**
+ * compare versions
+ * \return
+ * -1 when self < v
+ * 0 when self == v
+ * 1 when self > v
+ */
+typ int (*cmpSVersionFt) (versiont *self, const char *v);
+/**
+ * compare versions
+ * \return
+ * -1 when v1 < v2
+ * 0 when v1 == v2
+ * 1 when v1 > v2
+ */
+typ int (*cmpSSVersionFt) (versiont *self, const char *v1, const char *v2);
+/**
+ * increase one of the main component
+ * level values are defined in the enum above: releaseVer, majorVer, minorVer, patchVer
+ * Example:
+ * incO(v, patchVer);
+ */
+typ bool (*incVersionFt) (versiont *self, u32 level);
+/**
+ * sort an array of version strings
+ * \return
+ * sorted version strings
+ */
+typ smallArrayt* (*sortVersionFt) (versiont *self, smallArrayt *vlist);
+/**
+ * true when self in the range defined by vrange
+ * vrange format is defined in the readme
+ */
+typ bool (*satisfiesVersionFt) (versiont *self, const char *vrange);
+/**
+ * return a json object representing self
+ */
+typ smallJsont* (*toJsonVersionFt) (versiont *self);
+/**
+ * return a json string representing self
+ */
+typ char* (*toJsonStrVersionFt) (versiont *self);
+/**
+ * set version from json object
+ */
+typ bool (*fromJsonVersionFt) (versiont *self, smallJsont *json);
+/**
+ * set version from json string
+ */
+typ bool (*fromJsonStrVersionFt)(versiont *self, const char *json);
+
+/**
+ * class functions
+ * allocated once for all objects
+ *
+ * freed with finalizeVersion
+ */
+
+/**
+ * use this define in child classes and add the new function after this class functions
+ *
+ * in this define, add the methods after <finishVersionFt finish;>
+ *
+ * Example:
+ * #define RINGFUNCTIONST \n * VERSIONFUNCTIONST; \n * setSizeRingFt setSize
+ */
+#define VERSIONFUNCTIONST \
+ helpVersionFt help;\
+ logVersionFt log;\
+ validVersionFt valid;\
+ parseVersionFt parse;\
+ parseStrictVersionFt parseStrict;\
+ cleanVersionFt clean;\
+ equalVersionFt equal;\
+ equalSVersionFt equalS;\
+ equalSSVersionFt equalSS;\
+ cmpVersionFt cmp;\
+ cmpSVersionFt cmpS;\
+ cmpSSVersionFt cmpSS;\
+ incVersionFt inc;\
+ sortVersionFt sort;\
+ satisfiesVersionFt satisfies;\
+ toJsonVersionFt toJson;\
+ toJsonStrVersionFt toJsonStr;\
+ fromJsonVersionFt fromJson;\
+ fromJsonStrVersionFt fromJsonStr
+
+typ struct {
+ freeVersionFt free;
+ terminateVersionFt terminate;
+ toStringVersionFt toString;
+ duplicateVersionFt duplicate;
+ smashVersionFt smash;
+ finishVersionFt finish;
+ VERSIONFUNCTIONST;
+} versionFunctionst;
+
+/**
+ * class
+ */
+struct version {
+ const char *type;
+ versionFunctionst *f;
+
+ char *originalVer;
+
+ bool empty;
+ /** main components are release.major.minor.patch. The parser sets the component count found in the given string */
+ u8 mainComponentCount;
+ u64 release;
+ u64 major;
+ u64 minor;
+ u64 patch;
+ smallArrayt others;
+ smallArrayt prerelease;
+ smallArrayt build;
+};
+
+/* version */
+
+#define createVersion(obj) ;versiont obj; initiateVersion(&obj)
+#define createAllocateVersion(obj) ;versiont *obj; initiateAllocateVersion(&obj)
+
+void initiateVersion(versiont *self);
+void initiateAllocateVersion(versiont **self);
+void finalizeVersion(void);
+
+/* initialize class methods, call registerMethodsVersion from classes inheriting this class */
+void registerMethodsVersion(versionFunctionst *f);
+
+versiont* allocVersion(const char *v);
+
+/* end class version*/
+// vim: set expandtab ts=2 sw=2:
diff --git a/versionInternal.h b/versionInternal.h
@@ -0,0 +1,7 @@
+#pragma once
+
+static versionFunctionst *versionF = NULL;
+
+/* TODO declare structs for private data and add a void pointer to the private data in the class declaration */
+
+// vim: set expandtab ts=2 sw=2:+
\ No newline at end of file
