moka/lib/path.c

#include "path.h"

bool path_is_local(char const* path)
{
    assert(path);

    if (strlen(path) == 0)
    {
        return false;
    }

    return path[0] == '.';
}

void path_get_mod_name(char const* path, char* buffer, size_t size)
{
    assert(path);
    size_t sz = strlen(path);
    size_t k = 0;

    for (size_t i=0; i<sz; i++)
    {
        if (path[i] == '.' && i != 0)
        {
            bool at_end = true;
            for (size_t j=i+1; j<sz; j++)
            {
                if (path[j] == '/' && j != sz - 1)
                {
                    at_end = false;
                    break;
                }
            }

            if (at_end)
            {
                break;
            }
        }

        if (path[i] == '/' && i != sz - 1)
        {
            k = 0;
        }
        else if (path[i] != '/')
        {
            if (k >= size) { break; }
            buffer[k] = path[i];
            k++;
        }
    }

    buffer[k] = '\0';
}

bool path_exists(char const* path)
{
    FILE* file;

    if ( (file = fopen(path, "r")) )
    {
        fclose(file);
        return true;
    }

    return false;
}

size_t path_apply_ext(char const* path, 
                    char const* ext,
                    char* buffer, 
                    size_t size)
{
    assert(path); assert(ext); assert(buffer);
    
    ssize_t ext_idx = -1;
    size_t path_sz = strlen(path);

    char result[MK_STRLEN];
    memset(result, '\0', sizeof(char) * MK_STRLEN);
    memcpy(result, path, sizeof(char) * path_sz);

    for (size_t i=0; i<path_sz; i++)
    {
        size_t k = path_sz - i - 1;

        if (path[k] == '.')
        {
            ext_idx = k;
            break;
        }
    }

    if (ext_idx == -1 || (path[0] == '.' && ext_idx == 0))
    {
        return snprintf(buffer, size, "%s.%s", path, ext);
    }

    size_t sz = 0;
    for (ssize_t i=0; i<=ext_idx; i++)
    {
        sz += snprintf(buffer + sz, size - sz, "%c", path[i]);
    }

    size_t const ext_sz = strlen(ext);

    for (size_t i=0; i<ext_sz; i++)
    {
        sz += snprintf(buffer + sz, size - sz, "%c", ext[i]);
    }

    return sz;
}

size_t path_apply_prefix(char const* path, 
                         char const* prefix,
                         char* buffer, 
                         size_t size)
{
    assert(path); assert(prefix); assert(buffer);
    
    size_t const path_sz = strlen(path);
    char const* itr = strstr(path, prefix);
    size_t prefix_pos = 0;

    for (size_t i=0; i<path_sz; i++)
    {
        size_t k = path_sz - 1 - i;

        if (path[k] == '/')
        {
            prefix_pos = k + 1;
            break;
        }
    }
    
    if (path + prefix_pos == itr)
    {
        memcpy(buffer, path, sizeof(char) * path_sz);
        return 0;
    }

    size_t sz = 0;
    for (size_t i=0; i<prefix_pos; i++)
    {
        sz += snprintf(buffer + sz, size - sz, "%c", path[i]);
    }

    size_t const prefix_sz = strlen(prefix);

    for (size_t i=0; i<prefix_sz; i++)
    {
        sz += snprintf(buffer + sz, size - sz, "%c", prefix[i]);
    }

    for (size_t i=prefix_pos; i<path_sz; i++)
    {
        sz += snprintf(buffer + sz, size - sz, "%c", path[i]);
    }

    return sz;
}