Finally got renzoku 【れんぞく】 to work

After spending most of the day trying to hack away at this code to get it to
function in a most basic state, I have finally done it. :) renzoku is finally
working! :D I'm so excited! From here on out, the priorities have shifted from
"get it to work" to "get it to work well"! Yipee! My very first actual pet
project that hasn't fallen by the wayside.

Signed-off-by: Colton Wolkins (Ogre) <frostyfrog2@gmail.com>

Author: TheTechmage

Makefile

@@ -4,7 +4,7 @@ CXXFLAGS+= -Wall -g -Isrc/ -lyaml-cpp
 DEPS=
 BIN_DIR = bin
 OBJ_DIR = obj
-EXECUTABLE = builder
+EXECUTABLE = renzoku
 TEST_EXECUTABLE = TestCode
 
 SOURCES:=config.cpp main.cpp signals.cpp tokenizer.cpp log.cpp process.cpp util.cpp exceptions.cpp watcher.cpp

renzoku.conf

@@ -0,0 +1,14 @@
+watch:
+  Filter: ['*.cpp', '*.hpp', '*.c', '*.h', 'include/*.hxx']
+  Include: Makefile
+  Exclude: src/Config.cpp
+compile:
+  Command: make
+  Enabled: yes
+Test:
+  command: make test
+  IgnoreStatus: [2,3,4]
+  Enabled: no
+program:
+  command: ./bin/program -h
+  Enabled: false

src/config.cpp

@@ -41,6 +41,7 @@
 #include <cstdio>
 #include <stdexcept>
 #include "util.hpp"
+#include "log.hpp"
 
 Config::Config() :
 	mWatch(),
@@ -63,21 +64,27 @@ Config::Config(std::istream& file) :
 
 Config::~Config()
 {
+	size_t i;
 	if(mCompile.command != NULL) {
-		if(mCompile.command[0] != NULL)
-			delete [] mCompile.command[0];
+		for(i = 0; mCompile.command[i]; i++)
+			delete [] mCompile.command[i];
 		delete [] mCompile.command;
 	}
 	if(mTest.command != NULL) {
-		if(mTest.command[0] != NULL)
-			delete [] mTest.command[0];
+		for(i = 0; mTest.command[i]; i++)
+			delete [] mTest.command[i];
 		delete [] mTest.command;
 	}
 	if(mProgram.command != NULL) {
-		if(mProgram.command[0] != NULL)
-			delete [] mProgram.command[0];
+		for(i = 0; mProgram.command[i]; i++)
+			delete [] mProgram.command[i];
 		delete [] mProgram.command;
 	}
+	for(Process* proc : processes)
+	{
+		if(proc)
+			delete proc;
+	}
 }
 
 std::ifstream Config::findConfig()
@@ -102,7 +109,7 @@ void Config::parseConfig(std::istream& file)
 	// Tester
 	for (YAML::const_iterator it=config.begin();it!=config.end();++it) {
 		assert(it->second.Type() == YAML::NodeType::Map);
-		//std::cout << it->first << '-' << it->second << '\n';
+		//Logger::getLogger()->log(DEBUG, "%s - %s\n", it->first.as<std::string>().c_str(), it->second.as<std::string>().c_str());
 		std::string key = Util::lowercase_r(it->first.as<std::string>());
 		if(key == "watch")
 		{
@@ -111,17 +118,26 @@ void Config::parseConfig(std::istream& file)
 		else if(key == "program")
 		{
 			this->parseCommand(it->second, mProgram);
+			if(mProgram.command && mProgram.enabled)
+				processes.push_back(new Process(mProgram.command, true));
 		}
 		else if(key == "test")
 		{
 			this->parseCommand(it->second, mTest);
+			if(mTest.command && mTest.enabled)
+				processes.push_back(new Process(mTest.command, true));
 		}
 		else if(key == "compile")
 		{
 			this->parseCommand(it->second, mCompile);
+			if(mCompile.command && mCompile.enabled)
+				processes.push_back(new Process(mCompile.command, true));
 		}
 		else
+		{
 			std::cerr << "Found an error! -" << key << '\n';
+			throw std::runtime_error("Found a config error!");
+		}
 	}
 }
 
@@ -139,6 +155,9 @@ void Config::parseCommand(const YAML::Node& node, iCommandConfig& config)
 			{
 				if(value.IsScalar())
 				{
+					Logger::getLogger()->log(DEBUG, "Proc: %s", value.as<std::string>().c_str());
+					config.command = Util::parseCommand(value.as<std::string>());
+#if 0
 					// TODO: We need to take quotes from the user and send them all as
 					// a single argument instead of multiple arguments.
 					std::string cnfval = value.as<std::string>();
@@ -164,6 +183,7 @@ void Config::parseCommand(const YAML::Node& node, iCommandConfig& config)
 							}
 						}
 					}
+#endif
 				}
 			}
 			else if( key == "enabled" ) {
@@ -175,14 +195,27 @@ void Config::parseCommand(const YAML::Node& node, iCommandConfig& config)
 	//	std::cout << "==" << config.command[i] << '\n';
 	//}
 }
+
+void Config::restartProcesses()
+{
+	for(Process* proc : processes)
+	{
+		if(proc->kill())
+		if(proc != processes.back())
+			proc->runAndWait();
+		else
+			proc->run();
+	}
+}
+
 void Config::parseWatcher(const YAML::Node& node)
 {
+	size_t asterisk_count;
 	if(node.size() >= 1 && node.IsMap())
 		for (YAML::const_iterator iter=node.begin();iter!=node.end();++iter) {
 			std::string key = iter->first.as<std::string>();
 			YAML::Node value = iter->second;
 			Util::lowercase(key);
-			//std::cout << key << std::endl;
 			if(key == "filter")
 			{
 				if(!value.IsSequence())
@@ -191,8 +224,15 @@ void Config::parseWatcher(const YAML::Node& node)
 						filter_iter!=value.end();
 						++filter_iter)
 				{
-					//std::cout << "Filter: " << filter_iter->as<std::string>() << '\n';
-					mWatch.filters.push_back(filter_iter->as<std::string>());
+					asterisk_count = 0;
+					std::string val = filter_iter->as<std::string>();
+					for(size_t i = 0; i < val.length(); i++)
+						if(val[i] == '*')
+							asterisk_count++;
+					Logger::getLogger()->log(DEBUG, "Filter: %s", val.c_str());
+					if(asterisk_count > 1)
+						throw std::runtime_error("Could not open file");
+					mWatch.filters.push_back(val);
 				}
 			}
 			else if(key == "include")
@@ -205,13 +245,13 @@ void Config::parseWatcher(const YAML::Node& node)
 							filter_iter!=value.end();
 							++filter_iter)
 					{
-						//std::cout << "Include: " << filter_iter->as<std::string>() << '\n';
+						Logger::getLogger()->log(DEBUG, "Include: %s", filter_iter->as<std::string>().c_str());
 						mWatch.include.push_back(filter_iter->as<std::string>());
 					}
 				}
 				else if(value.IsScalar())
 				{
-					//std::cout << "Include: " << value.as<std::string>() << '\n';
+					Logger::getLogger()->log(DEBUG, "Include: %s", value.as<std::string>().c_str());
 					mWatch.include.push_back(value.as<std::string>());
 				}
 			}
@@ -225,18 +265,18 @@ void Config::parseWatcher(const YAML::Node& node)
 							filter_iter!=value.end();
 							++filter_iter)
 					{
-						//std::cout << "Exclude: " << filter_iter->as<std::string>() << '\n';
+						Logger::getLogger()->log(DEBUG, "Exclude: %s", filter_iter->as<std::string>().c_str());
 						mWatch.exclude.push_back(filter_iter->as<std::string>());
 					}
 				}
 				else if(value.IsScalar())
 				{
-					//std::cout << "Exclude: " << value.as<std::string>() << '\n';
+					Logger::getLogger()->log(DEBUG, "Exclude: %s", value.as<std::string>().c_str());
 					mWatch.exclude.push_back(value.as<std::string>());
 				}
 			}
 			else
-				std::cout << "Value: " << value.as<std::string>() << '\n';
+				Logger::getLogger()->log(DEBUG, "Value: %s\n", value.as<std::string>().c_str());
 		}
 }
 

src/config.hpp

@@ -38,15 +38,20 @@
 #include <string>
 #include <istream>
 #include <yaml-cpp/yaml.h>
+#include "process.hpp"
 
 #define CONFIG_NAME "renzoku.conf"
 
-struct WatchConfig {
+struct iConfig {
+	virtual ~iConfig() {}
+};
+
+struct WatchConfig : public iConfig {
 	std::vector<std::string> filters;
 	std::vector<std::string> include;
 	std::vector<std::string> exclude;
 };
-struct iCommandConfig {
+struct iCommandConfig : public iConfig {
 	bool enabled = true;
 	char** command = NULL;
 };
@@ -68,18 +73,17 @@ class Config {
 	 */
 	private:
 		YAML::Node config;
-		WatchConfig mWatch;
-		CompileConfig mCompile;
-		TestConfig mTest;
-		ProgramConfig mProgram;
+#define CONFIG_SECTION(X) X##Config m##X;
+#include "config_sections.hpp"
+#undef CONFIG_SECTION
+		std::vector<Process*> processes;
 		void parseWatcher(const YAML::Node&);
 		void parseCommand(const YAML::Node&, iCommandConfig&);
 		void parseConfig(std::istream&);
 		std::ifstream findConfig();
 	public:
-		std::vector<std::string> sections = {
-			"test",
-#define CONFIG_SECTION(X) #X,
+		std::vector<iConfig> sections = {
+#define CONFIG_SECTION(X) m##X,
 #include "config_sections.hpp"
 #undef CONFIG_SECTION
 		};
@@ -90,4 +94,6 @@ class Config {
 		inline CompileConfig getCompileConfig() { return mCompile; };
 		inline TestConfig getTestConfig() { return mTest; };
 		inline ProgramConfig getProgramConfig() { return mProgram; };
+		inline std::vector<Process*> getProcesses() const { return processes; };
+		void restartProcesses();
 };

src/config_sections.hpp

@@ -5,9 +5,13 @@ the fact that it needs to be included multiple times.
 #ifndef CONFIG_SECTION
 	#error "CONFIG_SECTION macro hasn't been defined!"
 #endif
-CONFIG_SECTION(Watcher)
-CONFIG_SECTION(Compiler)
-CONFIG_SECTION(Tester)
+
+#ifndef COMPILE_STEP_POS
+#define COMPILE_STEP_POS 0
+#endif
+CONFIG_SECTION(Watch)
+CONFIG_SECTION(Compile)
+CONFIG_SECTION(Test)
 //CONFIG_SECTION(Coverage)
 //CONFIG_SECTION(BrowserRefresher)
-CONFIG_SECTION(Runner)
+CONFIG_SECTION(Program)

src/exceptions.cpp

@@ -1,6 +1,6 @@
 #include	"exceptions.hpp"
 
 CException::CException(const std::string& message) :
-	std::runtime_error(message + ": " + strerror(errno))
+	std::runtime_error(message + ": " + strerror(errno) + " (" + std::to_string(errno) + ")")
 {
 }

src/log.cpp

@@ -72,8 +72,10 @@ Logger* Logger::removeLogger()
 	return mLogger;
 }
 
-Logger::Logger()
+Logger::Logger() :
+		mMethod(STDHANDLE)
 {
+	this->log(DEBUG, "Starting logging service for renzoku　【れんぞく】。");
 }
 
 Logger::~Logger()

src/main.cpp

@@ -38,6 +38,7 @@
 #include "main.hpp"
 #include "signals.hpp"
 #include "config.hpp"
+#include "watcher.hpp"
 
 volatile sig_atomic_t gRunning = 1;
 
@@ -49,6 +50,9 @@ int main(int argc, char** argv) {
 	//watcher();
 	Config config;
 	printf("%s\n", config.getCompileConfig().command[0]);
+	Watcher w("./", config, true);
+	while(gRunning)
+		w.listen();
 	return EXIT_SUCCESS;
 }