azpect/MarkdownToHtmlTranspiler
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed coding style issues with watch dog, and began implementing CLI features

Browse Source
This commit is contained in:
Preston 2025-10-19 14:36:48 -07:00
parent 26aae7cf98
commit 616cf7260a
6 changed files with 228 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lib/commandLineParser.cpp Normal file
View File

@ -0,0 +1,28 @@
#include "commandLineParser.h"
#include <iostream>
CLI::CLI(int argc, char** argv){
if (argc > 0){
programName = argv[0];
}
for (int i = 1; i < argc; i++){
args.push_back(argv[i]);
}
}
void CLI::RunCommands(){
for (int i = 0; i < args.size(); i++){
}
}
void CLI::PrintHelp() const{
std::cout << "Usage:\n"
<< " " << programName << " <input_file>\n"
<< "Flags:\n"
<< " --o, --output <outputFile>, optional output filename\n"
<< " --w, --watch, enables watchdog\n"
<< " --s, --stop, stops watchdog\n";
}

69
lib/commandLineParser.h Normal file
View File

@ -0,0 +1,69 @@
/**
* @file commandLineParser.h
* @brief Parses command line
* @author Preston Shultz
* Sources:
*
*/
#ifndef COMMAND_LINE_PARSER_H
#define COMMAND_LINE_PARSER_H
#include <string>
#include <vector>
/**
* @brief CommandLine Helper class
*
* Parse input arguments, sets input and output files
* Lets user use commands with program
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
class CLI{
public:
/**
* @brief Takes in argc and argv and converts it to vector
*
* CLI constructor
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
CLI(int argc, char **argv);
/**
* @brief Runs Commands
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
void RunCommands();
/**
* @brief Prints a list of commands that can be used
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
void PrintHelp() const;
/**
* @brief Returns input file
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
std::string GetInputFile() const {return inputFile;}
/**
* @brief Returns output file
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
std::string GetOutputFile() const {return outputFile;}
private:
std::string programName;
std::vector<std::string> args;
std::string inputFile;
std::string outputFile;
};
#endif

118
lib/watchDog.cpp
View File

@ -1,64 +1,59 @@
/*
*I don't know how threads work, so I might come back to see how they work.
*Right now you have to manually call the checkfile function to see if any changes have occured
*/
#include "watchDog.h"
#include "watchdog.h"
namespace fs = std::filesystem; //makes it easier to read
void WatchDog::start()
void Watchdog::Start()
{
//checks if file exist
//Checks if file exist
if(!fs::exists(path))
{
//returns and sets parameters to false if file doesnt exist
//Returns and sets parameters to false if file doesnt exist
watching = false;
hasInitialTime = false;
has_initial_time = false;
std::cout << "WatchDog: File does not exists: " << path << std::endl;
return;
}
//grabs intial write time
lastWriteTime = fs::last_write_time(path);
//Grabs intial write time
last_write_time = fs::last_write_time(path);
//Sets watchdog
watching = true;
hasInitialTime = true;
has_initial_time = true;
std::cout << "WatchDog: Started" << std::endl;
}
void WatchDog::stop(){
watching = false;
}
bool WatchDog::checkFile(){
bool Watchdog::CheckFile(){
//If not watching returns false
if (!watching) return false;
//Checking if file was deleted
if(!fs::exists(path))
{
if (hasInitialTime) {
if (has_initial_time) {
std::cout << "WatchDog: File was delete: " << path << std::endl;
hasInitialTime = false;
has_initial_time = false;
return true;
}
return false;
}
//Built in function with file system to check last write tim
//Built in function with file system to check last write time
fs::file_time_type currentWriteTime = fs::last_write_time(path);
//File was just created
if(!hasInitialTime)
if(!has_initial_time)
{
lastWriteTime = currentWriteTime;
hasInitialTime = true;
last_write_time = currentWriteTime;
has_initial_time = true;
std::cout << "WatchDog: File created: " << path << std::endl;
return true;
}
//File modified
if (currentWriteTime != lastWriteTime)
if (currentWriteTime != last_write_time)
{
lastWriteTime = currentWriteTime;
last_write_time = currentWriteTime;
std::cout << "WatchDog: File modifed at "
<< timePointToString(lastWriteTime) << std::endl;
<< TimePointToString(last_write_time) << std::endl;
return true;
}
@ -66,62 +61,47 @@ bool WatchDog::checkFile(){
return false;
}
std::string WatchDog::timePointToString(const fs::file_time_type& timePoint){
/*
* https://en.cppreference.com/w/cpp/chrono.html
* std::chrono -> name space, system_clock -> c++ clock(computers clock),
* ime_point -> exact instant on system clock, used to cast
* Comments: I had to use a lot of sources and googling to get this work
* We can get rid of this or document my troubles, because tbh this time stuff confuses me
std::string Watchdog::TimePointToString(const fs::file_time_type& timePoint){
/**
* Step 1: timePoint
* - This is the last write time of the file, returned by std::filesystem.
* - Its clock is platform-dependent (filesystem clock).
*
* std::chrono::system_clock::time_point systemTimePoint =
* std::chrono::clock_cast<std::chrono::system_clock>(timePoint);
* This solutions doesn't work as it only works with C++ 20 only :(
* Step 2: fs::file_time_type::clock::now()
* - Current time according to the filesystem clock.
*
* Step 3: std::chrono::system_clock::now()
* - Current time according to the system clock (standard C++ clock).
*
* Conversion formula:
* timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
*
* Explanation:
* a) timePoint - fs::file_time_type::clock::now()
* - Calculates the duration between the file's last write time and "now"
* according to the filesystem clock.
* b) + std::chrono::system_clock::now()
* - Shifts that duration to align with the system clock timeline.
* c) std::chrono::time_point_cast<std::chrono::system_clock::duration>(...)
* - Ensures the resulting time_point uses the correct duration type
* for std::chrono::system_clock.
*
* Result:
* - systemTime is a std::chrono::system_clock::time_point representing
* the same instant as timePoint, but compatible with system_clock.
*/
//Convert std::filesystem::file_time_type (timePoint) to std::chrono::system_clock::time_point
/*
* Step 1: timePoint
* - This is the last write time of the file, returned by std::filesystem.
* - Its clock is platform-dependent (filesystem clock).
*
* Step 2: fs::file_time_type::clock::now()
* - Current time according to the filesystem clock.
*
* Step 3: std::chrono::system_clock::now()
* - Current time according to the system clock (standard C++ clock).
*
* Conversion formula:
* timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
*
* Explanation:
* a) timePoint - fs::file_time_type::clock::now()
* - Calculates the duration between the file's last write time and "now"
* according to the filesystem clock.
* b) + std::chrono::system_clock::now()
* - Shifts that duration to align with the system clock timeline.
* c) std::chrono::time_point_cast<std::chrono::system_clock::duration>(...)
* - Ensures the resulting time_point uses the correct duration type
* for std::chrono::system_clock.
*
* Result:
* - systemTime is a std::chrono::system_clock::time_point representing
* the same instant as timePoint, but compatible with system_clock.
*/
std::chrono::system_clock::time_point systemTimePoint =
std::chrono::time_point_cast<std::chrono::system_clock::duration>(
timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
);
//converts to seconds
//Converts to seconds
std::time_t timeInSeconds = std::chrono::system_clock::to_time_t(systemTimePoint);
//Converts to local time, built in function
std::tm localTime = *std::localtime(&timeInSeconds);
// Format the time into a string using strftime
//https://en.cppreference.com/w/cpp/chrono/c/strftime.html
char buffer[20];
std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &localTime);

150
lib/watchDog.h
View File

@ -1,19 +1,25 @@
/**
* @file watchdog.h
* @brief file watcher
* @author Preston Shultz
* Sources:
* https://en.cppreference.com/w/cpp/filesystem.html
* https://en.cppreference.com/w/cpp/chrono.html
* Format the time into a string using strftime
* https://en.cppreference.com/w/cpp/chrono/c/strftime.html
*/
#ifndef WATCHDOG_H
#define WATCHDOG_H
#include <iostream>
#include <string>
/*
*https://en.cppreference.com/w/cpp/filesystem.html
*allow access to files platform independent
*/
#include <filesystem>
/*
*https://en.cppreference.com/w/cpp/chrono.html
*makes timestamps easier
*how to do lots of research to get this to work
*/
#include <chrono>
#include <string>
#include <filesystem> //allow access to files platform independent
#include <chrono> //makes timestamps easier
#include <ctime> //Convert time_t to std::tm for local time
#include <iomanip> //Formats std::tim into "YYYY-MM-DD HH-MM-SS"
/**
* @brief watchdog class.
*
@ -21,74 +27,70 @@
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
#include <ctime> //Convert time_t to std::tm for local time
#include <iomanip> //Formats std::tim into "YYYY-MM-DD HH-MM-SS"
class Watchdog{
public:
Watchdog(const std::string& path) :
path(path), watching(false), has_initial_time(false) {}
/**
* @brief watchdog class.
*
* Starts the watchdog to check of a file is modified
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
void Start();
/**
* @brief watchdog class.
*
* Stops the watchdog
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
void Stop() {watching = false;} //Disable
class WatchDog{
public:
WatchDog(const std::string& path) :
path(path), watching(false), hasInitialTime(false) {}
/**
* @brief watchdog class.
*
* Checks if a file has been modified
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
bool CheckFile();
/**
* @brief watchdog class.
*
* Starts the watchdog to check of a file is modified
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
void start();
/**
* @brief watchdog class.
*
* Stops the watchdog
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
void stop(); //Disable
/**
* @brief watchdog class.
*
* Returns files last modified date
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
std::filesystem::file_time_type GetLastWriteTime()
const {return last_write_time;}
/**
* @brief watchdog class.
*
* Checks if a file has been modified
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
bool checkFile();
/**
* @brief watchdog class.
*
* Converts time point into a string
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
static std::string TimePointToString(const std::filesystem::file_time_type& timePoint);
/**
* @brief watchdog class.
*
* Returns files last modified date
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
std::filesystem::file_time_type getLastWriteTime()
const {return lastWriteTime;}
/**
* @brief watchdog class.
*
* Returns if the watchDog is on
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
bool IsWatching() const{return watching;}
/**
* @brief watchdog class.
*
* Converts time point into a string
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
static std::string timePointToString(const std::filesystem::file_time_type& timePoint);
/**
* @brief watchdog class.
*
* Returns if the watchDog is on
*
* @author Preston Shultz (shultzp1@my.erau.edu)
*/
bool isWatching() const{return watching;}
private:
std::string path; //file path
bool watching; //Is watchdog on?
std::filesystem::file_time_type lastWriteTime;
bool hasInitialTime; //checks if initial time is given
private:
std::string path; //file path
bool watching; //Is watchdog on?
std::filesystem::file_time_type last_write_time;
bool has_initial_time; //checks if initial time is given
};
#endif

10
src/main.cpp
View File

@ -39,18 +39,18 @@ void test_nodes() {
*Preston: Test to see if watchdog works :)
*/
void test_watchdog() {
WatchDog wd("test/input.md");
wd.start();
Watchdog wd("test/input.md");
wd.Start();
std::cout << "Initial check (should do nothing if file unchanged):\n";
wd.checkFile();
wd.CheckFile();
std::cout << "Now, modify or create the file 'example.txt' manually and "
"press Enter:\n";
std::cin.get(); // Wait for user to press Enter
// Check again after manual change
wd.checkFile();
wd.CheckFile();
std::cout << "Done testing.\n";
}
@ -78,4 +78,4 @@ void test_input(int argc, char **argv) {
std::cout << std::endl;
}
int main(int argc, char **argv) { test_nodes(); }
int main(int argc, char **argv) { test_watchdog(); }

2
test/input.md
View File

@ -1,6 +1,6 @@
# Hello world in a h1 tag
# Hello world in an h1 tag
## This is a h2 tag