decouple from clib-package

Makefile

@@ -1,5 +1,5 @@
 CC = cc
-CFLAGS := -g -Wall -Wextra -I deps -I src -l curl
+CFLAGS := -g -Wall -Wextra -I deps -I src
 TEST_SRC = $(shell find src tests deps -name '*.c')
 
 

package.json

@@ -1,11 +1,10 @@
 {
   "name": "clib-cache",
   "description": "Caching for clib packages",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "repo": "clibs/clib-cache",
   "dependencies": {
     "isty001/copy": "0.0.0",
-    "clib-package": "0.5.0",
     "jwerle/fs.c": "0.1.2",
     "stephenmathieson/mkdirp.c": "0.1.5",
     "stephenmathieson/rimraf.c": "0.1.0"

src/cache.c

@@ -1,16 +1,16 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include <limits.h>
 #include <unistd.h>
 #include <mkdirp/mkdirp.h>
 #include "rimraf/rimraf.h"
 #include "fs/fs.h"
 #include "copy/copy.h"
-#include "clib-package/clib-package.h"
 #include "cache.h"
 
 
-#define GET_PKG_CACHE(pkg) char pkg_cache[BUFSIZ]; \
-                      package_cache_path(pkg_cache, pkg);
+#define GET_PKG_CACHE(a, n, v) char pkg_cache[BUFSIZ]; \
+                      package_cache_path(pkg_cache, a, n, v);
 
 #define GET_JSON_CACHE(a, n, v) char json_cache[BUFSIZ]; \
                   json_cache_path(json_cache, a, n, v);
@@ -38,9 +38,9 @@ static void json_cache_path(char *pkg_cache, char *author, char *name, char *ver
     sprintf(pkg_cache, JSON_CACHE_PATTERN, json_cache_dir, author, name, version);
 }
 
-static void package_cache_path(char *json_cache, clib_package_t *pkg)
+static void package_cache_path(char *json_cache, char *author, char *name, char *version)
 {
-    sprintf(json_cache, PKG_CACHE_PATTERN, package_cache_dir, pkg->author, pkg->name, pkg->version);
+    sprintf(json_cache, PKG_CACHE_PATTERN, package_cache_dir, author, name, version);
 }
 
 const char *clib_cache_dir(void)
@@ -144,23 +144,23 @@ int clib_cache_delete_search(void)
     return unlink(search_cache);
 }
 
-int clib_cache_has_package(clib_package_t *pkg)
+int clib_cache_has_package(char *author, char *name, char *version)
 {
-    GET_PKG_CACHE(pkg);
+    GET_PKG_CACHE(author, name, version);
 
     return 0 == fs_exists(pkg_cache) && !is_expired(pkg_cache);
 }
 
-int clib_cache_is_expired_package(clib_package_t *pkg)
+int clib_cache_is_expired_package(char *author, char *name, char *version)
 {
-    GET_PKG_CACHE(pkg);
+    GET_PKG_CACHE(author, name, version);
 
     return is_expired(pkg_cache);
 }
 
-int clib_cache_save_package(clib_package_t *pkg, char *pkg_dir)
+int clib_cache_save_package(char *author, char *name, char *version, char *pkg_dir)
 {
-    GET_PKG_CACHE(pkg);
+    GET_PKG_CACHE(author, name, version);
 
     if (0 == fs_exists(pkg_cache)) {
         rimraf(pkg_cache);
@@ -169,9 +169,9 @@ int clib_cache_save_package(clib_package_t *pkg, char *pkg_dir)
     return copy_dir(pkg_dir, pkg_cache);
 }
 
-int clib_cache_load_package(clib_package_t *pkg, char *target_dir)
+int clib_cache_load_package(char *author, char *name, char *version, char *target_dir)
 {
-    GET_PKG_CACHE(pkg);
+    GET_PKG_CACHE(author, name, version);
 
     if (-1 == fs_exists(pkg_cache)) {
         return -1;
@@ -186,9 +186,9 @@ int clib_cache_load_package(clib_package_t *pkg, char *target_dir)
     return copy_dir(pkg_cache, target_dir);
 }
 
-int clib_cache_delete_package(clib_package_t *pkg)
+int clib_cache_delete_package(char *author, char *name, char *version)
 {
-    GET_PKG_CACHE(pkg);
+    GET_PKG_CACHE(author, name, version);
 
     return rimraf(pkg_cache);
 }

src/cache.h

@@ -5,7 +5,6 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <time.h>
-#include "clib-package/clib-package.h"
 
 
 /**
@@ -67,34 +66,34 @@ int clib_cache_delete_search(void);
 /**
  * @return 0/1 if the packe is cached
  */
-int clib_cache_has_package(clib_package_t *pkg);
+int clib_cache_has_package(char *author, char *name, char *version);
 
 /**
  * @return 0/1 if the cached package modified date is more or less then the given expiration.
  *         -1 if the package is not cached
  */
-int clib_cache_is_expired_package(clib_package_t *pkg);
+int clib_cache_is_expired_package(char *author, char *name, char *version);
 
 /**
  * @param target_dir Where the cached package should be copied
  *
  * @return 0 on success, -1 on error, if the package is not found in the cache.
  *         If the cached package is expired, it will be deleted, and -2 returned
  */
-int clib_cache_load_package(clib_package_t *pkg, char *target_dir);
+int clib_cache_load_package(char *author, char *name, char *version, char *target_dir);
 
 /**
  * @param pkg_dir The downloaded package (e.g. ./deps/my_package).
  *                If the package was already cached, it will be deleted first, then saved
  *
  * @return 0 on success, -1 on error
  */
-int clib_cache_save_package(clib_package_t *pkg, char *pkg_dir);
+int clib_cache_save_package(char *author, char *name, char *version, char *pkg_dir);
 
 /**
  * @return 0 on success, -1 on error
  */
-int clib_cache_delete_package(clib_package_t *pkg);
+int clib_cache_delete_package(char *author, char *name, char *version);
 
 
 #endif

tests/test.c

@@ -1,4 +1,4 @@
-#include "clib-package/clib-package.h"
+#include <stdlib.h>
 #include <limits.h>
 #include <string.h>
 #include "rimraf/rimraf.h"
@@ -32,11 +32,11 @@ static void assert_cached_files(char *pkg_dir)
     assert_cached_file(pkg_dir, "package.json");
 }
 
-static void test_save(clib_package_t *pkg, char *pkg_dir)
+static void test_save(char *author, char *name, char *version, char *pkg_dir)
 {
-    mu_assert_int_eq(0, clib_cache_save_package(pkg, "./deps/copy"));
-    mu_assert(1 == clib_cache_has_package(pkg), "Package should be cached");
-    mu_assert(0 == clib_cache_is_expired_package(pkg), "This shouldn't be expired yet");
+    mu_assert_int_eq(0, clib_cache_save_package(author, name, version, "./deps/copy"));
+    mu_assert(1 == clib_cache_has_package(author, name, version), "Package should be cached");
+    mu_assert(0 == clib_cache_is_expired_package(author, name, version), "This shouldn't be expired yet");
 
     assert_cached_dir(pkg_dir, 0);
     assert_cached_files(pkg_dir);
@@ -49,55 +49,55 @@ static void assert_loaded_files(void)
     assert_exists("./copy/package.json");
 }
 
-static void test_load(clib_package_t *pkg)
+static void test_load(char *author, char *name, char *version)
 {
-    mu_assert_int_eq(0, clib_cache_load_package(pkg, "./copy"));
+    mu_assert_int_eq(0, clib_cache_load_package(author, name, version, "./copy"));
     assert_loaded_files();
 }
 
-static void test_delete(clib_package_t *pkg, char *pkg_dir)
+static void test_delete(char *author, char *name, char *version, char *pkg_dir)
 {
-    mu_assert_int_eq(0, clib_cache_delete_package(pkg));
+    mu_assert_int_eq(0, clib_cache_delete_package(author, name, version));
     assert_cached_dir(pkg_dir, -1);
-    mu_assert(0 == clib_cache_has_package(pkg), "Package should be deleted from cached");
-    mu_assert(0 == clib_cache_has_json(pkg->author, pkg->name, pkg->version), "Package.json should be deleted from cached");
+    mu_assert(0 == clib_cache_has_package(author, name, version), "Package should be deleted from cached");
+    mu_assert(0 == clib_cache_has_json(author, name, version),
+              "Package.json should be deleted from cached");
 
-    mu_assert_int_eq(-1, clib_cache_load_package(pkg, "./copy"));
-    mu_assert(NULL == clib_cache_read_json(pkg->author, pkg->name, pkg->version), "Package.json should be deleted from cached");
+    mu_assert_int_eq(-1, clib_cache_load_package(author, name, version, "./copy"));
+    mu_assert(NULL == clib_cache_read_json(author, name, version),
+              "Package.json should be deleted from cached");
 }
 
-static void test_expiration(clib_package_t *pkg)
+static void test_expiration(char *author, char *name, char *version)
 {
-    mu_assert_int_eq(0, clib_cache_save_package(pkg, "./deps/copy"));
+    mu_assert_int_eq(0, clib_cache_save_package(author, name, version, "./deps/copy"));
     sleep(1);
 
-    mu_assert_int_eq(1, clib_cache_is_expired_package(pkg));
-    mu_assert_int_eq(0, clib_cache_has_package(pkg));
-    mu_assert_int_eq(-2, clib_cache_load_package(pkg, "./copy"));
+    mu_assert_int_eq(1, clib_cache_is_expired_package(author, name, version));
+    mu_assert_int_eq(0, clib_cache_has_package(author, name, version));
+    mu_assert_int_eq(-2, clib_cache_load_package(author, name, version, "./copy"));
 
-    mu_assert_int_eq(0, clib_cache_has_package(pkg));
-    mu_assert_int_eq(-1, clib_cache_load_package(pkg, "./copy"));
+    mu_assert_int_eq(0, clib_cache_has_package(author, name, version));
+    mu_assert_int_eq(-1, clib_cache_load_package(author, name, version, "./copy"));
 
-    mu_assert(0 == clib_cache_has_json(pkg->author, pkg->name, pkg->version), "Package.json should be expired");
-    mu_assert(NULL == clib_cache_read_json(pkg->author, pkg->name, pkg->version), "Package.json should be expired");
+    mu_assert(0 == clib_cache_has_json(author, name, version), "Package.json should be expired");
+    mu_assert(NULL == clib_cache_read_json(author, name, version), "Package.json should be expired");
 }
 
 MU_TEST(test_cache)
 {
-    clib_package_t pkg;
-    pkg.author = "author";
-    pkg.name = "pkg";
-    pkg.version = "1.2.0";
-    pkg.version = "1.2.0";
+    char *author = "author";
+    char *name = "pkg";
+    char *version = "1.2.0";
     mu_assert_int_eq(0, clib_cache_init(1));
 
     char pkg_dir[PATH_MAX];
     sprintf(pkg_dir, "%s/author_pkg_1.2.0", clib_cache_dir());
 
-    test_save(&pkg, pkg_dir);
-    test_load(&pkg);
-    test_delete(&pkg, pkg_dir);
-    test_expiration(&pkg);
+    test_save(author, name, version, pkg_dir);
+    test_load(author, name, version);
+    test_delete(author, name, version, pkg_dir);
+    test_expiration(author, name, version);
 
     rimraf("./copy");
 }