public/dehydrate
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 10 Wiki Activity

Compare commits

base: public:main
Branches Tags
public:main
public:v11
public:v10
public:v9
public:v8
public:v7
public:v6
public:v5
public:v4
public:v3
public:v2
..
compare: public:v3
Branches Tags
public:main
public:v11
public:v10
public:v9
public:v8
public:v7
public:v6
public:v5
public:v4
public:v3
public:v2

No commits in common. "main" and "v3" have entirely different histories.
main ... v3

6 changed files with 114 additions and 229 deletions
Show Stats Expand all files Collapse all files

4
README.md
View File

@ -4,11 +4,11 @@
Automated system-wide installation:
```
curl -fsSL https://gitea.jde.nz/public/dehydrate/releases/download/latest/install.sh | sudo bash
curl -fsSL https://gitea.jde.nz/public/dehydrate/releases/download/latest/install.sh | bash
```
To download just the dehydrate executable:
```
curl -fsSL -o dehydrate https://gitea.jde.nz/public/dehydrate/releases/download/latest/dehydrate.amd64 && chmod a+x dehydrate
curl -fsSL -o dehydrate https://gitea.jde.nz/public/dehydrate/releases/download/latest/dehydrate.amd64 && chmod a+x bb64
```
## How it Works

2
include/version.hpp
View File

@ -1 +1 @@
static const char *VERSION = "11";
static const char *VERSION = "3";

34
install.sh
View File

@ -3,23 +3,24 @@ set -e
PROJECT="dehydrate"
# RUN AS ROOT
if [[ $EUID -ne 0 ]]; then
echo "This script must be run as root" >&2
exit 1
fi
# 0. see if we were passed a folder to install to
# -----------------------------------------------------------------------------
INSTALL_DIR="$1"
if [[ -z "$INSTALL_DIR" ]]; then
INSTALL_DIR="/usr/local/bin"
else
echo "Installing $PROJECT to $INSTALL_DIR"
if [[ ! -d "$INSTALL_DIR" ]]; then
mkdir -p "$INSTALL_DIR"
fi
fi
echo "Installing $PROJECT to $INSTALL_DIR"
# 0. see if we were passed a user to chown to
# -----------------------------------------------------------------------------
CHOWN_USER="$2"
if [[ -z "$CHOWN_USER" ]]; then
CHOWN_USER=$(id -u)
fi
# 1. Determine architecture
# -----------------------------------------------------------------------------
@ -34,18 +35,27 @@ else
exit 1
fi
# 3. Download the appropriate binary
# 3. Download the appropriate binary to a temp directory
# -----------------------------------------------------------------------------
TMPDIR=$(mktemp -d)
trap 'rm -rf "$TMPDIR"' EXIT
URL="https://gitea.jde.nz/public/$PROJECT/releases/download/latest/$BIN"
echo "Downloading $BIN from $URL to $TMPDIR..."
echo "Downloading $BIN from $URL..."
curl -fsSL -o "$INSTALL_DIR/$PROJECT" "$URL"
curl -fsSL -o "$TMPDIR/$PROJECT" "$URL"
# 4. Make it executable
# -----------------------------------------------------------------------------
chmod +x "$INSTALL_DIR/$PROJECT"
chmod +x "$TMPDIR/$PROJECT"
# 5. Move to /usr/local/bin
# -----------------------------------------------------------------------------
docker run --rm -v "$TMPDIR:/tmp" -v "$INSTALL_DIR:/target" alpine sh -c "cp /tmp/$PROJECT /target/$PROJECT; chown $CHOWN_USER /target/$PROJECT"
rm "$TMPDIR/$PROJECT"
# 6. Print success message
# -----------------------------------------------------------------------------
echo "$PROJECT installed successfully to $INSTALL_DIR/$PROJECT (arch $ARCH)"
echo " "
echo "Update $PROJECT with:"
echo " $PROJECT -u"

2
src/argparse.cpp
View File

@ -1,5 +1,5 @@
#include "argparse.hpp"
#include "version.hpp"
#include <stdexcept>
static const std::string HELP_TEXT = R"(

297
src/generator.cpp
View File

@ -6,8 +6,6 @@
#include <sstream>
#include <vector>
#include "xxhash.hpp"
#include <sys/stat.h> // For file permissions
#include <cstring> // For strlen
namespace fs = std::filesystem;
@ -26,118 +24,6 @@ static uint64_t fnv1a_64(const void* data, size_t len) {
return h;
}
// Base64 encoding function - no dependencies
static std::string base64_encode(const unsigned char* data, size_t len) {
const char* base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
std::string result;
result.reserve((len + 2) / 3 * 4); // Reserve space for the full encoded size
int val = 0, valb = -6;
for (size_t i = 0; i < len; i++) {
val = (val << 8) + data[i];
valb += 8;
while (valb >= 0) {
result.push_back(base64_chars[(val >> valb) & 0x3F]);
valb -= 6;
}
}
if (valb > -6) {
result.push_back(base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
}
// Add padding
while (result.size() % 4) {
result.push_back('=');
}
return result;
}
// Helper function to output the _recreate_file_ utility function and Base64 decoder
static void output_recreate_file_utility(std::ofstream& cpp) {
cpp << R"cpp(
// Base64 decoding function - no dependencies
static void base64_decode(const char* encoded_data, size_t encoded_len, unsigned char* output, size_t* output_len) {
const char* base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
size_t out_pos = 0;
int val = 0, valb = -8;
for (size_t i = 0; i < encoded_len; i++) {
char c = encoded_data[i];
if (c == '=') break;
// Find position in base64_chars
const char* pos = strchr(base64_chars, c);
if (pos == nullptr) continue; // Skip invalid characters
val = (val << 6) + static_cast<int>(pos - base64_chars);
valb += 6;
if (valb >= 0) {
output[out_pos++] = static_cast<unsigned char>((val >> valb) & 0xFF);
valb -= 8;
}
}
*output_len = out_pos;
}
// Utility function to recreate a file with proper permissions
static bool _recreate_file_(const std::filesystem::path& outpath, uint64_t file_hash, std::filesystem::perms file_perms, const unsigned char* filedata, size_t filedata_len) {
namespace fs = std::filesystem;
bool needs_write = false;
// Check if file exists and has correct hash
if (fs::exists(outpath)) {
// Check content hash
std::ifstream in(outpath, std::ios::binary);
std::ostringstream oss;
oss << in.rdbuf();
std::string data = oss.str();
uint64_t existing_hash = fnv1a_64(data.data(), data.size());
needs_write = existing_hash != file_hash;
} else {
needs_write = true; // File doesn't exist, need to create it
}
bool needs_permission_update = true;
if (!needs_write) { // we always update permissions if the file is written or changed. Othewise we check.
fs::perms current_perms = fs::status(outpath).permissions();
needs_permission_update = current_perms != file_perms;
}
if (needs_write) {
bool existed = fs::exists(outpath);
fs::create_directories(outpath.parent_path());
std::ofstream out(outpath, std::ios::binary);
out.write(reinterpret_cast<const char*>(filedata), filedata_len);
out.close();
// Set the file permissions
fs::permissions(outpath, file_perms);
if (!existed) {
std::cout << "[dehydrate] " << outpath.filename() << ": created\n";
} else {
std::cout << "[dehydrate] " << outpath.filename() << ": updated (hash changed)\n";
}
return true;
}
if (needs_permission_update) {
// Update only permissions
fs::permissions(outpath, file_perms);
std::cout << "[dehydrate] " << outpath.filename() << ": updated (permissions changed)\n";
return true;
}
return false;
}
)cpp";
}
void generate_file_code(const std::string& source, const std::string& destfolder, bool silent) {
fs::path src(source);
@ -145,17 +31,12 @@ void generate_file_code(const std::string& source, const std::string& destfolder
std::string ns = "recreate_" + sanitize(src.stem().string());
std::string cppname = "_" + src.stem().string() + ".cpp";
std::string hppname = "_" + src.stem().string() + ".hpp";
std::string bothname = "_" + src.stem().string() + ".{cpp,hpp}";
fs::create_directories(dest);
std::ifstream in(source, std::ios::binary);
std::ostringstream oss;
oss << in.rdbuf();
std::string filedata = oss.str();
uint64_t hash = fnv1a_64(filedata.data(), filedata.size());
// Get source file permissions
fs::perms src_perms = fs::status(src).permissions();
// Write HPP
std::ofstream hpp(dest / hppname);
hpp << "#pragma once\n#include <string>\nnamespace " << ns << " {\nbool recreate_file(std::string destination_folder);\n}\n";
@ -165,7 +46,7 @@ void generate_file_code(const std::string& source, const std::string& destfolder
#include <filesystem>
#include <string>
#include <iostream>
#include <cstring>
#include <iomanip>
// Tiny dependency-free FNV-1a 64-bit hash
static uint64_t fnv1a_64(const void* data, size_t len) {
@ -178,51 +59,47 @@ static uint64_t fnv1a_64(const void* data, size_t len) {
)cpp";
cpp << "#include \"" << hppname << "\"\n";
cpp << "namespace " << ns << " {\n";
// Output the recreate_file utility function
output_recreate_file_utility(cpp);
// Write recreate_file function with embedded file data
// Embed file data
cpp << "static const unsigned char filedata[] = {";
for (size_t i = 0; i < filedata.size(); ++i) {
if (i % 16 == 0) cpp << "\n ";
cpp << "0x" << std::hex << std::setw(2) << std::setfill('0') << (int)(unsigned char)filedata[i];
if (i + 1 != filedata.size()) cpp << ", ";
}
cpp << "\n};\n";
// Reset to decimal format
cpp << std::dec;
cpp << "static const size_t filedata_len = " << filedata.size() << ";\n";
cpp << "static uint64_t file_hash = " << hash << "U;\n";
cpp << R"cpp(
bool recreate_file(std::string destination_folder) {
namespace fs = std::filesystem;
fs::path outpath = fs::path(destination_folder) / ")cpp" << src.filename().string() << R"cpp(";
// File data embedded as Base64
static const char filedata_base64[] = )cpp";
// Encode the file data to Base64
std::string base64 = base64_encode(reinterpret_cast<const unsigned char*>(filedata.data()), filedata.size());
// Split into 76-character chunks for readability
const size_t line_length = 76;
for (size_t i = 0; i < base64.length(); i += line_length) {
if (i > 0) cpp << "\n ";
cpp << "\"" << base64.substr(i, std::min(line_length, base64.length() - i)) << "\"";
if (i + line_length < base64.length()) cpp << "\\";
uint64_t existing_hash;
if (fs::exists(outpath)) {
std::ifstream in(outpath, std::ios::binary);
std::ostringstream oss;
oss << in.rdbuf();
std::string data = oss.str();
existing_hash = fnv1a_64(data.data(), data.size());
}
bool needs_write = !fs::exists(outpath) || existing_hash != file_hash;
if (needs_write) {
std::ofstream out(outpath, std::ios::binary);
out.write(reinterpret_cast<const char*>(filedata), filedata_len);
}
cpp << ";\n\n";
// Decode Base64 at runtime
cpp << " // Decode Base64 data\n";
cpp << " size_t decoded_size = (strlen(filedata_base64) * 3) / 4;\n";
cpp << " unsigned char* decoded_data = new unsigned char[decoded_size];\n";
cpp << " size_t actual_size;\n";
cpp << " base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);\n\n";
// Call _recreate_file_ with the decoded data
cpp << " bool result = _recreate_file_(outpath, " << hash << "ULL, "
<< "std::filesystem::perms(" << static_cast<unsigned>(src_perms) << "), "
<< "decoded_data, actual_size);\n";
// Clean up
cpp << " delete[] decoded_data;\n";
cpp << " return result;\n";
if (!fs::exists(outpath)) {
std::cout << "[dehydrate] " << outpath.filename() << ": created\n";
} else if (needs_write) {
std::cout << "[dehydrate] " << outpath.filename() << ": updated (hash changed)\n";
}
return needs_write;
}
)cpp";
cpp << "}\n";
cpp << "}\n";
if (!silent) {
std::cout << "[dehydrate] Generated: " << (dest / bothname) << std::endl;
std::cout << "[dehydrate] Generated: " << (dest / cppname) << ", " << (dest / hppname) << std::endl;
}
}
@ -241,7 +118,6 @@ void generate_folder_code(const std::string& source, const std::string& destfold
std::string ns = "recreate_" + sanitize(src.stem().string());
std::string cppname = "_" + src.stem().string() + ".cpp";
std::string hppname = "_" + src.stem().string() + ".hpp";
std::string bothname = "_" + src.stem().string() + ".{cpp,hpp}";
fs::create_directories(dest);
// Collect all files
std::vector<fs::path> files;
@ -276,7 +152,9 @@ namespace )hpp" << ns << R"hpp( {
#include <filesystem>
#include <string>
#include <iostream>
#include <cstring>
#include <iomanip>
/*
@ -303,70 +181,67 @@ static uint64_t fnv1a_64(const void* data, size_t len) {
)cpp";
// Output the recreate_file utility function
output_recreate_file_utility(cpp);
// Start writing recreate_tree - we'll embed file data directly in function
cpp << R"cpp(
bool recreate_tree(std::string destination_folder) {
namespace fs = std::filesystem;
bool any_written = false;
)cpp";
// Process each file
// Embed all files
for (const auto& file : files) {
std::ifstream in(file, std::ios::binary);
std::ostringstream oss;
oss << in.rdbuf();
std::string filedata = oss.str();
uint64_t hash = fnv1a_64(filedata.data(), filedata.size());
fs::perms file_perms = fs::status(file).permissions();
std::string rel = fs::relative(file, src).string();
std::string var = sanitize(rel);
// Start a scope to limit data's lifetime
cpp << " {\n";
cpp << " // File: " << rel << "\n";
cpp << " fs::path outpath = fs::path(destination_folder) / \"" << rel << "\";\n";
// Embed file data as Base64
cpp << " static const char filedata_base64[] = ";
// Encode the file data to Base64
std::string base64 = base64_encode(reinterpret_cast<const unsigned char*>(filedata.data()), filedata.size());
// Split into 76-character chunks for readability
const size_t line_length = 76;
for (size_t i = 0; i < base64.length(); i += line_length) {
if (i > 0) cpp << "\n ";
cpp << "\"" << base64.substr(i, std::min(line_length, base64.length() - i)) << "\"";
if (i + line_length < base64.length()) cpp << "\\";
cpp << "static const unsigned char data_" << var << "[] = {";
for (size_t i = 0; i < filedata.size(); ++i) {
if (i % 16 == 0) cpp << "\n ";
cpp << "0x" << std::hex << std::setw(2) << std::setfill('0') << (int)(unsigned char)filedata[i];
if (i + 1 != filedata.size()) cpp << ", ";
}
cpp << ";\n\n";
// Decode Base64 at runtime
cpp << " // Decode Base64 data\n";
cpp << " size_t decoded_size = (strlen(filedata_base64) * 3) / 4;\n";
cpp << " unsigned char* decoded_data = new unsigned char[decoded_size];\n";
cpp << " size_t actual_size;\n";
cpp << " base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);\n\n";
// Call _recreate_file_ with the decoded data
cpp << " bool file_written = _recreate_file_(outpath, "
<< hash << "ULL, std::filesystem::perms(" << static_cast<unsigned>(file_perms) << "), "
<< "decoded_data, actual_size);\n";
// Clean up and update flag
cpp << " delete[] decoded_data;\n";
cpp << " any_written = any_written || file_written;\n";
cpp << " }\n"; // Close scope to free memory
cpp << "\n};\n";
// Reset to decimal format
cpp << std::dec;
cpp << "static const size_t len_" << var << " = " << filedata.size() << ";\n";
cpp << "static uint64_t hash_" << var << " = " << hash << "U;\n";
cpp << "static const char* rel_" << var << " = \"" << rel << "\";\n";
}
// Write recreate_tree using heredoc style
cpp << R"cpp(
bool recreate_tree(std::string destination_folder) {
namespace fs = std::filesystem;
bool any_written = false;
)cpp";
for (const auto& file : files) {
std::string rel = fs::relative(file, src).string();
std::string var = sanitize(rel);
cpp << R"cpp( {
fs::path outpath = fs::path(destination_folder) / )cpp" << "rel_" << var << R"cpp(;
fs::create_directories(outpath.parent_path());
uint64_t existing_hash;
if (fs::exists(outpath)) {
std::ifstream in(outpath, std::ios::binary);
std::ostringstream oss; oss << in.rdbuf();
std::string data = oss.str();
existing_hash = fnv1a_64(data.data(), data.size());
}
bool needs_write = !fs::exists(outpath) || existing_hash != )cpp" << "hash_" << var << R"cpp(;
if (needs_write) {
std::ofstream out(outpath, std::ios::binary);
out.write(reinterpret_cast<const char*>()cpp" << "data_" << var << R"cpp(), )cpp" << "len_" << var << R"cpp();
}
cpp << " return any_written;\n";
if (!fs::exists(outpath)) {
std::cout << "[dehydrate] " << outpath.filename() << ": created\n";
} else if (needs_write) {
std::cout << "[dehydrate] " << outpath.filename() << ": updated (hash changed)\n";
}
any_written = any_written || needs_write;
}
)cpp";
}
cpp << R"cpp( return any_written;
}
)cpp";
cpp << "}\n";
cpp << "}\n";
if (!silent) {
std::cout << "[dehydrate] Generated: " << (dest / bothname) << std::endl;
std::cout << "[dehydrate] Generated: " << (dest / cppname) << ", " << (dest / hppname) << std::endl;
}
}

2
test.sh
View File

@ -38,7 +38,7 @@ $TEST_DIR/testexe
# third time just two files changed
echo "----------------------------------------"
echo "Should see: hash.cpp - updated, and generator.cpp - created."
echo "Should be two changes: generator.cpp and hash.cpp"
rm $TEST_DIR/temp/generator.cpp
echo "whee!" >> $TEST_DIR/temp/hash.cpp