path: root/booki.c

#include <getopt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#define EDIT_FILE "/tmp/booki-edit.toml"
#define FIXED_FILE "/tmp/booki-fixed.toml"

#define MAX_SEARCH_OPTS 5

/*** helpers ***/
char* load_file(char* filename) {
    // open the file
    FILE* fp = fopen(filename, "r");
    if (!fp) {
        printf("bad file\n");
        return NULL;
    }

    // seek to the end
    fseek(fp, 0, SEEK_END);
    int size = ftell(fp);
    rewind(fp);

    char* data = malloc(size + 1);
    if (!data) {
        printf("couldn't malloc\n");
        return NULL;
    }

    int read_size = fread(data, 1, size, fp);
    if (read_size != size) {
        printf("didn't read everything -- %d read of %d\n", read_size, size);
        return NULL;
    }

    data[size] = '\0';
    fclose(fp);

    return data;
}

void open_with_editor(char* filepath) {
    char* editor = getenv("EDITOR");
    if (!editor)
        editor = "nano";

    pid_t pid;
    int status;
    switch ((pid = fork())) {
        case -1:
            printf("fork has failed!\n");
            break;
        case 0:
            execlp(editor, editor, filepath, NULL);
            printf("child failed :(\n");
            break;
        default:
            // wait for the child to finish
            pid = wait(&status);
            break;
    }
}

bool copy(char* src, char* dest) {
    pid_t pid;
    int status;
    switch((pid = fork())) {
        case -1:
            printf("fork failed\n");
            return false;
        case 0:
            execl("/bin/cp", "/bin/cp", src, dest, NULL);
            printf("copy failed\n");
            return false;
        default:
            // wait for the chlid to finish
            pid = wait(&status);
            return true;
    }
}

/*** strings ***/
struct es {
    int len;
    char* ptr;
    struct es* next;
};

struct es default_es = { 0, NULL, NULL };

int concat_es_print(struct es* str, char* buf) {
    int size = sprintf(buf, "%.*s", str->len, str->ptr);
    struct es* next = str;
    while ((next = next->next) != NULL)
        size += sprintf(buf + size, ", %.*s", next->len, next->ptr);
    return size;
}

int concat_es_toml(struct es* str, char* buf) {
    if (str->next == NULL) {
        return sprintf(buf, "\"%.*s\"\n", str->len, str->ptr);
    }
    else {
        int size = sprintf(buf, "[ \"%.*s\"", str->len, str->ptr);
        struct es* next = str;
        while ((next = next->next) != NULL)
            size += sprintf(buf + size, ", \"%.*s\"", next->len, next->ptr);
        return size + sprintf(buf + size, " ]\n");
    }
}

void free_es(struct es* str) {
    if (str == NULL) return;
    struct es* tmp;
    while (str != NULL) {
        tmp = str->next;
        free(str);
        str = tmp;
    }
}

/*** books ***/
struct Book {
    int id;
    struct es title;
    struct es author;
    int pages;
    struct es isbn;
    struct es language;
    struct es translator;
    struct es on;
    int published;
};

void init_book(struct Book* book) {
    book->id = 0;
    book->title = default_es;
    book->author = default_es;
    book->pages = 0;
    book->isbn = default_es;
    struct es language = { 7, "English", NULL };  // default language
    book->language = language;
    book->translator = default_es;
    book->on = default_es;
    book->published = 0;
}

void print_book(struct Book book, bool all_fields) {
    char str[100];
    int size = concat_es_print(&(book.author), str);
    printf("%.*s by %.*s\n", book.title.len, book.title.ptr, size, str);
    if (all_fields) {
        char* esfmt = " - %s: %.*s\n";
        char* intfmt = " - %s: %d\n";
        if (book.isbn.ptr) {
            printf(esfmt, "isbn", book.isbn.len, book.isbn.ptr);
        }
        if (book.language.ptr) {
            size = concat_es_print(&(book.language), str);
            printf(esfmt, "language", size, str);
        }
        if (book.translator.ptr) {
            size = concat_es_print(&(book.translator), str);
            printf(esfmt, "translator", size, str);
        }
        if (book.pages) {
            printf(intfmt, "pages", book.pages);
        }
        if (book.published) {
            printf(intfmt, "published", book.published);
        }
        if (book.on.ptr) {
            size = concat_es_print(&(book.on), str);
            printf(esfmt, "on", size, str);
        }
    }
}

void write_book(struct Book book, FILE *output) {
    fwrite("[[books]]\n", 1, 10, output);
    char str[100];
    int size;
    if (book.id) {
        size = sprintf(str, "id = %d\n", book.id);
        fwrite(str, 1, size, output);
    }
    if (book.isbn.ptr) {
        size = sprintf(str, "isbn = \"%.*s\"\n", book.isbn.len, book.isbn.ptr);
        fwrite(str, 1, size, output);
    }
    if (book.title.ptr) {
        size = sprintf(str, "title = \"%.*s\"\n", book.title.len, book.title.ptr);
        fwrite(str, 1, size, output);
    }
    if (book.author.ptr) {
        size = sprintf(str, "author = ");
        size += concat_es_toml(&(book.author), str + size);
        fwrite(str, 1, size, output);
    }
    if (book.pages) {
        size = sprintf(str, "pages = %d\n", book.pages);
        fwrite(str, 1, size, output);
    }
    if (book.published) {
        size = sprintf(str, "published = %d\n", book.published);
        fwrite(str, 1, size, output);
    }
    if (book.language.ptr) {
        size = sprintf(str, "language = ");
        size += concat_es_toml(&(book.language), str + size);
        fwrite(str, 1, size, output);
    }
    if (book.translator.ptr) {
        size = sprintf(str, "translator = ");
        size += concat_es_toml(&(book.translator), str + size);
        fwrite(str, 1, size, output);
    }
    if (book.on.ptr) {
        size = sprintf(str, "on = ");
        size += concat_es_toml(&(book.on), str + size);
        fwrite(str, 1, size, output);
    }

    fwrite("\n", 1, 1, output); // trailing newline between books
}

void free_book(struct Book book) {
    // any string can be a list of strings
    free_es(book.author.next);
    free_es(book.translator.next);
    free_es(book.language.next);
    free_es(book.on.next);
}

/*** parse toml-ish ***/

const char* get_last_word(const char* str) {
    const char* last_space = strrchr(str, ' ');
    if ((last_space - str) > 0)
        return last_space + 1;
    else
        return 0;
}

long parse_int(char* current_pos, char** new_pos) {
    char c;
    char* value;

    // strtol can handle leading spaces
    // will put the first non-digit into endptr
    char* endptr;
    long ret = strtol(current_pos, &endptr, 10);
    bool valid;
    switch(*endptr) {
        case ' ':
        case '\n':
        case ']':
        case ',':
            valid = true;
            break;

        default:
            valid = false;
            break;
    }


    *new_pos = endptr;

    if (valid) return ret;
    else return 0;
}

#define SEEK_UNTIL(ptr, ch) while (*ptr != ch) ptr++;
#define SEEK_WHILE(ptr, ch) while (*ptr == ch) ptr++;

struct es parse_string(char* current_pos, char** new_pos) {
    // TODO handle failure

    char c;
    char* value;

    // leading spaces
    SEEK_UNTIL(current_pos, '"');

    // go past the quote and set the position of the start of value
    current_pos++;
    value = current_pos;

    // until the next quote
    SEEK_UNTIL(current_pos, '"');

    struct es output;
    output.len = current_pos - value;
    output.ptr = value;
    output.next = NULL;

    // go past the quote
    current_pos++;

    // update position
    *new_pos = current_pos;

    return output;
}

struct es parse_strings(char* current_pos, char** new_pos) {
    // loop until we know what we have
    SEEK_WHILE(current_pos, ' ');
    if (*current_pos == '"') {
        return parse_string(current_pos, new_pos);
    } else if (*current_pos == '[') {
        // get the first one
        char* my_new_pos;
        struct es head = parse_string(current_pos, &my_new_pos);
        current_pos = my_new_pos;

        struct es* prev = &head;
        while (*current_pos == ',') {
            prev->next = (struct es*)malloc(sizeof(struct es));
            struct es str = parse_string(current_pos, &my_new_pos);
            prev->next->ptr = str.ptr;
            prev->next->len = str.len;
            prev->next->next = NULL;
            prev = prev->next;
            current_pos = my_new_pos;
        }

        SEEK_UNTIL(current_pos, ']');
        current_pos++;
        *new_pos = current_pos;
        return head;
    } else {
        printf("error at %x\n", current_pos);
        SEEK_UNTIL(current_pos, '\n');
        *new_pos = current_pos;
        return default_es;
    }
}

#define ATTR_MATCH(cand, attr) (strncmp(cand, attr, strlen(attr)) == 0)

void parse_book(char* current_pos, struct Book* book) {
    char* attr;
    char c = *current_pos;
    char* new_pos;
    // loop until we hit the extra newline
    while (c != '\n') {
        // we start at the beginning of a line
        attr = current_pos;
        SEEK_UNTIL(current_pos, '=');

        // go past the equals sign
        current_pos++;

        // attr should be the name of the attribute, with (possibly) trailing spaces
        if (ATTR_MATCH(attr, "title")) {
            struct es title = parse_string(current_pos, &new_pos);
            book->title = title;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "author")) {
            struct es author = parse_strings(current_pos, &new_pos);
            book->author = author;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "language")) {
            struct es language = parse_strings(current_pos, &new_pos);
            book->language = language;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "isbn")) {
            struct es isbn = parse_string(current_pos, &new_pos);
            book->isbn = isbn;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "translator")) {
            struct es translator = parse_strings(current_pos, &new_pos);
            book->translator = translator;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "pages")) {
            int pages = parse_int(current_pos, &new_pos);
            book->pages = pages;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "published")) {
            int published = parse_int(current_pos, &new_pos);
            book->published = published;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "id")) {
            int id = parse_int(current_pos, &new_pos);
            book->id = id;
            current_pos = new_pos;
        } else if (ATTR_MATCH(attr, "on")) {
            struct es on = parse_strings(current_pos, &new_pos);
            book->on = on;
            current_pos = new_pos;
        }

        // go to (and then past) the newline
        SEEK_UNTIL(current_pos, '\n');
        c = *(++current_pos);
    }
}

char* next_book(char* current_pos) {
    while (!(ATTR_MATCH(current_pos, "[[books]]"))) {
        current_pos++;
        if (*current_pos == '\0')
            return NULL;
    }

    // current_pos is at the beginning of [[books]]
    // pass it, and any spaces/newlines, then return
    current_pos += 9;  // [[books]]
    SEEK_UNTIL(current_pos, '\n');

    // current_pos is '\n', go past then return
    current_pos++;
    return current_pos;
}

/*** search ***/
bool match_string(const char* pattern, const struct es text) {

    // empty pattern matches everything
    if (!*pattern) return true;

    // get lengths
    int pattern_length = strlen(pattern);

    bool head_match = *pattern == '^';
    bool tail_match = *(pattern + pattern_length - 1) == '$';

    // if we have either head or tail (or both), we only need to compare once
    bool valid = false;
    if (head_match && tail_match)
        // text must be identical to pattern (minus ^ and $)
        valid = text.len == (pattern_length - 2) && strncasecmp(pattern + 1, text.ptr, pattern_length - 2) == 0;
    else if (head_match)
        // text must match the pattern starting from pattern + 1
        valid = strncasecmp(pattern + 1, text.ptr, pattern_length - 1) == 0;
    else if (tail_match) {
        // text starting from (pattern + 1) from the end must match pattern (without $)
        valid = strncasecmp(pattern, text.ptr + (text.len - pattern_length + 1), pattern_length - 1) == 0;
    }

    // we only need to compare while remaining text is
    // as long or longer than pattern
    for (int i = 0; i <= (text.len - pattern_length); i++) {
        if (strncasecmp(pattern, text.ptr + i, pattern_length) == 0) {
            valid = true;
            break;
        }
    }

    if (valid)
        return valid;
    else if (text.next != NULL)
        return match_string(pattern, *(text.next));

    return valid;
}

bool match_int(char* pattern, int candidate) {
    // we don't want to match the zero value, unless the pattern is also 0
    if (candidate == 0 && strcmp(pattern, "0") != 0)
        return false;

    // check for leading signs
    char* current_pos = pattern;
    bool lt = false;
    bool gt = false;
    if (*current_pos == '+') {
        gt = true;
        current_pos++;
    } else if (*current_pos == ',') {
        lt = true;
        current_pos++;
    }

    // parse the string to an int
    char* endptr;
    long ret = strtol(current_pos, &endptr, 10);
    if (*endptr != '\0') {
        printf("couldn't parse pattern as int: '%s'\n", pattern);
        return false;
    }

    // do compares
    if (lt)
        return candidate < ret;
    else if (gt)
        return candidate > ret;
    else
        return ret == candidate;
}

static struct option search_options[] = {
    {"show", no_argument, 0, 's'},
    {"edit", no_argument, 0, 'e'},
    {0, 0, 0, 0}  // marks the end of the array
};

struct search_opt {
    int show;
    int edit;
    int count;
    char* opts[MAX_SEARCH_OPTS];
    char* args[MAX_SEARCH_OPTS];
};

struct search_opt parse_search_options(int argc, char* argv[]) {

    // return struct
    struct search_opt opt_out;
    int count = 0;
    int show = false;
    int edit = false;

    // opt options
    int opt;
    int opt_idx = 0;
    opterr = 0;  // turn off getopt error messages

    // look at each option
    while ((opt = getopt_long_only(argc, argv, "", search_options, &opt_idx)) != -1) {
        switch(opt) {
            case 's':
                show = true;
                break;
            case 'e':
                edit = true;
                break;
            case '?':
                // optind points at the argument (one past the option)
                opt_out.opts[count] = argv[optind-1] + 2;  // '--example' -> 'example'
                opt_out.args[count] = argv[optind];
                count++;
                break;
            default:
                printf("something went wrong with parsing!\n");
                break;
        }
    }

    // set the count/show values
    opt_out.count = count;
    opt_out.show = show;
    opt_out.edit = edit;

    return opt_out;
}

void search(int argc, char* argv[], char* booki_file) {
    struct search_opt search_opts = parse_search_options(argc, argv);

    // get the books array
    char* data = load_file(booki_file);
    if (!data) {
        printf("couldn't load data from %s\n", booki_file);
        return;
    }

    FILE *edit_file, *fixed_file = NULL;
    if (search_opts.edit) {
        edit_file = fopen(EDIT_FILE, "w");
        fixed_file = fopen(FIXED_FILE, "w");
    }

    // book loop
    int book_count = 0;
    struct Book book;
    char* cur_data = data;
    while ((cur_data = next_book(cur_data)) != NULL) {
        init_book(&book);
        parse_book(cur_data, &book);

        char* field;
        int i;
        bool match = true;
        for (i = 0; i < search_opts.count; i++) {
            field = search_opts.opts[i];

            // compare fields
            if (ATTR_MATCH(field, "title")) {
                if (!match_string(search_opts.args[i], book.title))
                    break;
            } else if (ATTR_MATCH(field, "author")) {
                if (!match_string(search_opts.args[i], book.author))
                    break;
            } else if (ATTR_MATCH(field, "language")) {
                if (!match_string(search_opts.args[i], book.language))
                    break;
            } else if (ATTR_MATCH(field, "on")) {
                if (!match_string(search_opts.args[i], book.on))
                    break;
            } else if (ATTR_MATCH(field, "pages")) {
                if (!match_int(search_opts.args[i], book.pages))
                    break;
            } else if (ATTR_MATCH(field, "published")) {
                if (!match_int(search_opts.args[i], book.published))
                    break;
            } else {
                printf("unsupported field: %s\n", field);
                break;
            }
        }
        match = i == search_opts.count;

        if (match) {
            if (search_opts.edit)
                write_book(book, edit_file);
            else
                print_book(book, search_opts.show);
            book_count++;
        } else if (search_opts.edit) {
            write_book(book, fixed_file);
        }
        free_book(book);
    }

    free(data);

    // if we're editing, both files are open at this point
    if (search_opts.edit) {
        // first, close and let the user edit
        fclose(edit_file);
        open_with_editor(EDIT_FILE);

        // after they've edited, read it in and add it to fixed_file
        data = load_file(EDIT_FILE);
        if (!data) {
            printf("can't open edit file\n");
            return;
        }
        cur_data = data;
        while ((cur_data = next_book(cur_data)) != NULL) {
            init_book(&book);
            parse_book(cur_data, &book);
            print_book(book, true);
            write_book(book, fixed_file);
            free_book(book);
        }

        fclose(fixed_file);
        free(data);

        // copy the fixed_file to booki file
        bool success = copy(FIXED_FILE, booki_file);
        if (!success) {
            printf("failed! fixed file is here: %s\n", FIXED_FILE);
        } else {
            unlink(EDIT_FILE);
            unlink(FIXED_FILE);
        }
    }
}

/*** add new books ***/
void add(char *booki_file) {
    FILE* edit_file = fopen(EDIT_FILE, "w");

    // load an empty book to the edit file
    fputs("[[books]]\n", edit_file);
    fputs("#isbn = \"\"\n", edit_file);
    fputs("title = \"\"\n", edit_file);
    fputs("author = \"\"\n", edit_file);
    fputs("#pages = 0\n", edit_file);
    fputs("#published = 0\n", edit_file);
    fputs("language = \"English\"\n", edit_file);
    fputs("#translator = \"\"\n", edit_file);
    fputs("#on = \"\"\n", edit_file);
    fputs("\n", edit_file);

    // open the file for editing
    fclose(edit_file);
    open_with_editor(EDIT_FILE);

    // read in file, add to booki file
    FILE* output = fopen(booki_file, "a");
    char* data = load_file(EDIT_FILE);
    char* cur_data = data;
    struct Book book;
    while ((cur_data = next_book(cur_data)) != NULL) {
        init_book(&book);
        parse_book(cur_data, &book);
        print_book(book, true);
        write_book(book, output);
        free_book(book);
    }
    free(data);
    fclose(output);
    unlink(EDIT_FILE);
}

void help(bool err) {
    printf("booki! it's a thing\n");
    if (err) {
        printf("you did something wrong\n");
    }
}

/*** the main event ***/
int main(int argc, char* argv[]) {

    char* booki_file = getenv("BOOKI_FILE");
    if (!booki_file) {
        printf("expecting BOOKI_FILE variable\n");
        return 1;
    }

    if (argc == 1) {
        help(false);
        return 0;
    } else if (strcmp(argv[1], "open") == 0) {
        open_with_editor(booki_file);
    } else if (strcmp(argv[1], "search") == 0) {
        search(argc - 1, argv + 1, booki_file);
    } else if (strcmp(argv[1], "add") == 0) {
        add(booki_file);
    } else {
        printf("unknown subcommand: '%s'\n", argv[1]);
        return 1;
    }

    return 0;
}