{ +class document : public std::vector

{ public: /** * Check if a document has a specific section. @@ -479,9 +506,9 @@ * \param key the key * \return true if the document contains the section */ - inline bool contains(const std::string &key) const noexcept + inline bool contains(const std::string& key) const noexcept { - return std::find_if(begin(), end(), [&] (const auto &sc) { return sc.key() == key; }) != end(); + return find(key) != end(); } /** @@ -490,9 +517,9 @@ * \param key the key * \return the iterator or end() if not found */ - inline iterator find(const std::string &key) noexcept + inline iterator find(const std::string& key) noexcept { - return std::find_if(begin(), end(), [&] (const auto &o) { + return std::find_if(begin(), end(), [&] (const auto& o) { return o.key() == key; }); } @@ -503,9 +530,9 @@ * \param key the key * \return the iterator or end() if not found */ - inline const_iterator find(const std::string &key) const noexcept + inline const_iterator find(const std::string& key) const noexcept { - return std::find_if(cbegin(), cend(), [&] (const auto &o) { + return std::find_if(cbegin(), cend(), [&] (const auto& o) { return o.key() == key; }); } @@ -517,7 +544,7 @@ * \return the section * \pre contains(key) must return true */ - inline Section &operator[](const std::string &key) + inline section& operator[](const std::string& key) { assert(contains(key)); @@ -531,7 +558,7 @@ * \return the section * \pre contains(key) must return true */ - inline const Section &operator[](const std::string &key) const + inline const section& operator[](const std::string& key) const { assert(contains(key)); @@ -541,31 +568,31 @@ /** * Inherited operators. */ - using std::vector

::operator[]; + using std::vector

::operator[]; }; /** - * Analyse a stream and detect potential syntax errors. This does not parse the file like including other - * files in include statement. + * Analyse a stream and detect potential syntax errors. This does not parse the + * file like including other files in include statement. * - * It does only analysis, for example if an option is defined under no section, this does not trigger an - * error while it's invalid. + * It does only analysis, for example if an option is defined under no section, + * this does not trigger an exception while it's invalid. * * \param it the iterator * \param end where to stop * \return the list of tokens - * \throws Error on errors + * \throws exception on errors */ -IRCCD_EXPORT Tokens analyse(std::istreambuf_iterator it, std::istreambuf_iterator end); +IRCCD_EXPORT tokens analyse(std::istreambuf_iterator it, std::istreambuf_iterator end); /** * Overloaded function for stream. * * \param stream the stream * \return the list of tokens - * \throws Error on errors + * \throws exception on errors */ -IRCCD_EXPORT Tokens analyse(std::istream &stream); +IRCCD_EXPORT tokens analyse(std::istream& stream); /** * Parse the produced tokens. @@ -573,39 +600,40 @@ * \param tokens the tokens * \param path the parent path * \return the document - * \throw Error on errors + * \throw exception on errors */ -IRCCD_EXPORT Document parse(const Tokens &tokens, const std::string &path = "."); +IRCCD_EXPORT document parse(const tokens& tokens, const std::string& path = "."); /** * Parse a file. * * \param filename the file name * \return the document - * \throw Error on errors + * \throw exception on errors */ -IRCCD_EXPORT Document readFile(const std::string &filename); +IRCCD_EXPORT document read_file(const std::string& filename); /** * Parse a string. * - * If the string contains include statements, they are relative to the current working directory. + * If the string contains include statements, they are relative to the current + * working directory. * * \param buffer the buffer * \return the document - * \throw Error on errors + * \throw exception on exceptions */ -IRCCD_EXPORT Document readString(const std::string &buffer); +IRCCD_EXPORT document read_string(const std::string& buffer); /** * Show all tokens and their description. * * \param tokens the tokens */ -IRCCD_EXPORT void dump(const Tokens &tokens); +IRCCD_EXPORT void dump(const tokens& tokens); } // !ini } // !irccd -#endif // !IRCCD_INI_HPP +#endif // !INI_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libcommon/irccd/logger.cpp --- a/libcommon/irccd/logger.cpp Fri Aug 11 13:45:42 2017 +0200 +++ b/libcommon/irccd/logger.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -44,33 +44,33 @@ */ std::atomic verbose{false}; -std::unique_ptr iface{new ConsoleLogger}; -std::unique_ptr filter{new Filter}; +std::unique_ptr use_iface{new console_logger}; +std::unique_ptr use_filter{new filter}; /* - * Buffer -- output buffer. + * buffer -- output buffer. * ------------------------------------------------------------------ * * This class inherits from std::stringbuf and writes the messages to the * specified interface function which is one of info, warning and debug. */ -class Buffer : public std::stringbuf { +class buffer : public std::stringbuf { public: - enum Level { - Debug, - Info, - Warning + enum class level { + debug, + info, + warning }; private: - Level m_level; + level level_; void debug(std::string line) { // Print only in debug mode, the buffer is flushed anyway. #if !defined(NDEBUG) - iface->debug(filter->preDebug(std::move(line))); + use_iface->debug(use_filter->pre_debug(std::move(line))); #else (void)line; #endif @@ -80,19 +80,19 @@ { // Print only if verbose, the buffer will be flushed anyway. if (verbose) - iface->info(filter->preInfo(std::move(line))); + use_iface->info(use_filter->pre_info(std::move(line))); } void warning(std::string line) { - iface->warning(filter->preWarning(std::move(line))); + use_iface->warning(use_filter->pre_warning(std::move(line))); } public: - inline Buffer(Level level) noexcept - : m_level(level) + inline buffer(level level) noexcept + : level_(level) { - assert(level >= Debug && level <= Warning); + assert(level >= level::debug && level <= level::warning); } virtual int sync() override @@ -101,19 +101,19 @@ std::string::size_type pos; while ((pos = buffer.find("\n")) != std::string::npos) { - std::string line = buffer.substr(0, pos); + auto line = buffer.substr(0, pos); // Remove this line. buffer.erase(buffer.begin(), buffer.begin() + pos + 1); - switch (m_level) { - case Level::Debug: + switch (level_) { + case level::debug: debug(std::move(line)); break; - case Level::Info: + case level::info: info(std::move(line)); break; - case Level::Warning: + case level::warning: warning(std::move(line)); break; default: @@ -133,108 +133,108 @@ */ // Buffers. -Buffer bufferInfo{Buffer::Info}; -Buffer bufferWarning{Buffer::Warning}; -Buffer bufferDebug{Buffer::Debug}; +buffer buffer_info{buffer::level::info}; +buffer buffer_warning{buffer::level::warning}; +buffer buffer_debug{buffer::level::debug}; // Stream outputs. -std::ostream streamInfo(&bufferInfo); -std::ostream streamWarning(&bufferWarning); -std::ostream streamDebug(&bufferDebug); +std::ostream stream_info(&buffer_info); +std::ostream stream_warning(&buffer_warning); +std::ostream stream_debug(&buffer_debug); } // !namespace /* - * ConsoleLogger + * console_logger * ------------------------------------------------------------------ */ -void ConsoleLogger::info(const std::string &line) +void console_logger::info(const std::string& line) { std::cout << line << std::endl; } -void ConsoleLogger::warning(const std::string &line) +void console_logger::warning(const std::string& line) { std::cerr << line << std::endl; } -void ConsoleLogger::debug(const std::string &line) +void console_logger::debug(const std::string& line) { std::cout << line << std::endl; } /* - * FileLogger + * file_logger * ------------------------------------------------------------------ */ -FileLogger::FileLogger(std::string normal, std::string errors) - : m_outputNormal(std::move(normal)) - , m_outputError(std::move(errors)) +file_logger::file_logger(std::string normal, std::string errors) + : output_normal_(std::move(normal)) + , output_error_(std::move(errors)) { } -void FileLogger::info(const std::string &line) +void file_logger::info(const std::string& line) { - std::ofstream(m_outputNormal, std::ofstream::out | std::ofstream::app) << line << std::endl; + std::ofstream(output_normal_, std::ofstream::out | std::ofstream::app) << line << std::endl; } -void FileLogger::warning(const std::string &line) +void file_logger::warning(const std::string& line) { - std::ofstream(m_outputError, std::ofstream::out | std::ofstream::app) << line << std::endl; + std::ofstream(output_error_, std::ofstream::out | std::ofstream::app) << line << std::endl; } -void FileLogger::debug(const std::string &line) +void file_logger::debug(const std::string& line) { - std::ofstream(m_outputNormal, std::ofstream::out | std::ofstream::app) << line << std::endl; + std::ofstream(output_normal_, std::ofstream::out | std::ofstream::app) << line << std::endl; } /* - * SilentLogger + * silent_logger * ------------------------------------------------------------------ */ -void SilentLogger::info(const std::string &) +void silent_logger::info(const std::string&) { } -void SilentLogger::warning(const std::string &) +void silent_logger::warning(const std::string&) { } -void SilentLogger::debug(const std::string &) +void silent_logger::debug(const std::string&) { } /* - * SyslogLogger + * syslog_logger * ------------------------------------------------------------------ */ #if defined(HAVE_SYSLOG) -SyslogLogger::SyslogLogger() +syslog_logger::syslog_logger() { - openlog(sys::programName().c_str(), LOG_PID, LOG_DAEMON); + openlog(sys::program_name().c_str(), LOG_PID, LOG_DAEMON); } -SyslogLogger::~SyslogLogger() +syslog_logger::~syslog_logger() { closelog(); } -void SyslogLogger::info(const std::string &line) +void syslog_logger::info(const std::string& line) { syslog(LOG_INFO | LOG_USER, "%s", line.c_str()); } -void SyslogLogger::warning(const std::string &line) +void syslog_logger::warning(const std::string& line) { syslog(LOG_WARNING | LOG_USER, "%s", line.c_str()); } -void SyslogLogger::debug(const std::string &line) +void syslog_logger::debug(const std::string& line) { syslog(LOG_DEBUG | LOG_USER, "%s", line.c_str()); } @@ -246,50 +246,50 @@ * ------------------------------------------------------------------ */ -void setLogger(std::unique_ptr newiface) noexcept +void set_logger(std::unique_ptr new_iface) noexcept { - assert(newiface); + assert(new_iface); - iface = std::move(newiface); + use_iface = std::move(new_iface); } -void setFilter(std::unique_ptr newfilter) noexcept +void set_filter(std::unique_ptr newfilter) noexcept { - assert(filter); + assert(newfilter); - filter = std::move(newfilter); + use_filter = std::move(newfilter); } -std::ostream &info(const std::string &message) +std::ostream& info(const std::string& message) { if (!message.empty()) - streamInfo << message << std::endl; + stream_info << message << std::endl; - return streamInfo; + return stream_info; } -std::ostream &warning(const std::string &message) +std::ostream& warning(const std::string& message) { if (!message.empty()) - streamWarning << message << std::endl; + stream_warning << message << std::endl; - return streamWarning; + return stream_warning; } -std::ostream &debug(const std::string &message) +std::ostream& debug(const std::string& message) { if (!message.empty()) - streamDebug << message << std::endl; + stream_debug << message << std::endl; - return streamDebug; + return stream_debug; } -bool isVerbose() noexcept +bool is_verbose() noexcept { return verbose; } -void setVerbose(bool mode) noexcept +void set_verbose(bool mode) noexcept { verbose = mode; } diff -r beb6c638b841 -r 7e273b7f4f92 libcommon/irccd/logger.hpp --- a/libcommon/irccd/logger.hpp Fri Aug 11 13:45:42 2017 +0200 +++ b/libcommon/irccd/logger.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -35,26 +35,26 @@ namespace log { /* - * Logger -- abstract logging interface + * logger -- abstract logging interface * ------------------------------------------------------------------ */ /** * \brief Interface to implement new logger mechanisms. * - * Derive from this class and use log::setLogger() to change logging system. + * Derive from this class and use log::set_logger() to change logging system. * - * \see File - * \see Console - * \see Syslog - * \see Silent + * \see file_logger + * \see console_logger + * \see syslog_logger + * \see silent_logger */ -class Logger { +class logger { public: /** * Virtual destructor defaulted. */ - virtual ~Logger() = default; + virtual ~logger() = default; /** * Write a debug message. @@ -64,7 +64,7 @@ * \param line the data * \see log::debug */ - virtual void debug(const std::string &line) = 0; + virtual void debug(const std::string& line) = 0; /** * Write a information message. @@ -74,7 +74,7 @@ * \param line the data * \see log::info */ - virtual void info(const std::string &line) = 0; + virtual void info(const std::string& line) = 0; /** * Write an error message. @@ -84,11 +84,11 @@ * \param line the data * \see log::warning */ - virtual void warning(const std::string &line) = 0; + virtual void warning(const std::string& line) = 0; }; /* - * Filter -- modify messages before printing + * filter -- modify messages before printing * ------------------------------------------------------------------ */ @@ -97,12 +97,12 @@ * * Derive from this class and use log::setFilter. */ -class Filter { +class filter { public: /** * Virtual destructor defaulted. */ - virtual ~Filter() = default; + virtual ~filter() = default; /** * Update the debug message. @@ -110,7 +110,7 @@ * \param input the message * \return the updated message */ - virtual std::string preDebug(std::string input) const + virtual std::string pre_debug(std::string input) const { return input; } @@ -121,7 +121,7 @@ * \param input the message * \return the updated message */ - virtual std::string preInfo(std::string input) const + virtual std::string pre_info(std::string input) const { return input; } @@ -132,14 +132,14 @@ * \param input the message * \return the updated message */ - virtual std::string preWarning(std::string input) const + virtual std::string pre_warning(std::string input) const { return input; } }; /* - * Console -- logs to console + * console_logger -- logs to console * ------------------------------------------------------------------ */ @@ -147,36 +147,36 @@ * \brief Logger implementation for console output using std::cout and * std::cerr. */ -class ConsoleLogger : public Logger { +class console_logger : public logger { public: /** - * \copydoc Logger::debug + * \copydoc logger::debug */ - IRCCD_EXPORT void debug(const std::string &line) override; + void debug(const std::string& line) override; /** - * \copydoc Logger::info + * \copydoc logger::info */ - IRCCD_EXPORT void info(const std::string &line) override; + void info(const std::string& line) override; /** - * \copydoc Logger::warning + * \copydoc logger::warning */ - IRCCD_EXPORT void warning(const std::string &line) override; + void warning(const std::string& line) override; }; /* - * File -- logs to a file + * file_logger -- logs to a file * ------------------------------------------------------------------ */ /** * \brief Output to a files. */ -class FileLogger : public Logger { +class file_logger : public logger { private: - std::string m_outputNormal; - std::string m_outputError; + std::string output_normal_; + std::string output_error_; public: /** @@ -185,26 +185,26 @@ * \param normal the path to the normal logs * \param errors the path to the errors logs */ - IRCCD_EXPORT FileLogger(std::string normal, std::string errors); + file_logger(std::string normal, std::string errors); /** - * \copydoc Logger::debug + * \copydoc logger::debug */ - IRCCD_EXPORT void debug(const std::string &line) override; + void debug(const std::string& line) override; /** - * \copydoc Logger::info + * \copydoc logger::info */ - IRCCD_EXPORT void info(const std::string &line) override; + void info(const std::string& line) override; /** - * \copydoc Logger::warning + * \copydoc logger::warning */ - IRCCD_EXPORT void warning(const std::string &line) override; + void warning(const std::string& line) override; }; /* - * Silent -- disable all logs + * silent_logger -- disable all logs * ------------------------------------------------------------------ */ @@ -213,26 +213,26 @@ * * Useful for unit tests when some classes may emits log. */ -class SilentLogger : public Logger { +class silent_logger : public logger { public: /** - * \copydoc Logger::debug + * \copydoc logger::debug */ - IRCCD_EXPORT void debug(const std::string &line) override; + void debug(const std::string& line) override; /** - * \copydoc Logger::info + * \copydoc logger::info */ - IRCCD_EXPORT void info(const std::string &line) override; + void info(const std::string& line) override; /** - * \copydoc Logger::warning + * \copydoc logger::warning */ - IRCCD_EXPORT void warning(const std::string &line) override; + void warning(const std::string& line) override; }; /* - * Syslog -- system logger + * syslog_logger -- system logger * ------------------------------------------------------------------ */ @@ -241,32 +241,32 @@ /** * \brief Implements logger into syslog. */ -class SyslogLogger : public Logger { +class syslog_logger : public logger { public: /** * Open the syslog. */ - IRCCD_EXPORT SyslogLogger(); + syslog_logger(); /** * Close the syslog. */ - IRCCD_EXPORT ~SyslogLogger(); + ~syslog_logger(); /** - * \copydoc Logger::debug + * \copydoc logger::debug */ - IRCCD_EXPORT void debug(const std::string &line) override; + void debug(const std::string& line) override; /** - * \copydoc Logger::info + * \copydoc logger::info */ - IRCCD_EXPORT void info(const std::string &line) override; + void info(const std::string& line) override; /** - * \copydoc Logger::warning + * \copydoc logger::warning */ - IRCCD_EXPORT void warning(const std::string &line) override; + void warning(const std::string& line) override; }; #endif // !HAVE_SYSLOG @@ -282,7 +282,7 @@ * \pre iface must not be null * \param iface the new interface */ -IRCCD_EXPORT void setLogger(std::unique_ptr iface) noexcept; +IRCCD_EXPORT void set_logger(std::unique_ptr iface) noexcept; /** * Set an optional filter. @@ -290,7 +290,7 @@ * \pre filter must not be null * \param filter the filter */ -IRCCD_EXPORT void setFilter(std::unique_ptr filter) noexcept; +IRCCD_EXPORT void set_filter(std::unique_ptr filter) noexcept; /** * Get the stream for informational messages. @@ -301,7 +301,7 @@ * \return the stream * \note Has no effect if verbose is set to false. */ -IRCCD_EXPORT std::ostream &info(const std::string &message = ""); +IRCCD_EXPORT std::ostream& info(const std::string& message = ""); /** * Get the stream for warnings. @@ -311,7 +311,7 @@ * \param message the optional message to write * \return the stream */ -IRCCD_EXPORT std::ostream &warning(const std::string &message = ""); +IRCCD_EXPORT std::ostream& warning(const std::string& message = ""); /** * Get the stream for debug messages. @@ -322,21 +322,21 @@ * \return the stream * \note Has no effect if compiled in release mode. */ -IRCCD_EXPORT std::ostream &debug(const std::string &message = ""); +IRCCD_EXPORT std::ostream& debug(const std::string& message = ""); /** * Tells if verbose is enabled. * * \return true if enabled */ -IRCCD_EXPORT bool isVerbose() noexcept; +IRCCD_EXPORT bool is_verbose() noexcept; /** * Set the verbosity mode. * * \param mode the new mode */ -IRCCD_EXPORT void setVerbose(bool mode) noexcept; +IRCCD_EXPORT void set_verbose(bool mode) noexcept; } // !log diff -r beb6c638b841 -r 7e273b7f4f92 libcommon/irccd/system.cpp --- a/libcommon/irccd/system.cpp Fri Aug 11 13:45:42 2017 +0200 +++ b/libcommon/irccd/system.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -111,15 +111,15 @@ namespace { /* - * XXX: the setprogname() function keeps a pointer without copying it so when + * The setprogname() function keeps a pointer without copying it so when * main's argv is modified, we're not using the same name so create our own * copy. */ -std::string programNameCopy; +std::string program_name_value; /* - * setHelper. + * set_privileges. * ------------------------------------------------------------------ * * This is an helper for setting the uid or gid. It accepts both numeric and @@ -140,28 +140,32 @@ * - getter the function to get the id from the informal structure */ template -void setHelper(const std::string &typeName, const std::string &value, LookupFunc lookup, SetterFunc setter, FieldGetter getter) +void set_privileges(const std::string& type_name, + const std::string& value, + LookupFunc lookup, + SetterFunc setter, + FieldGetter getter) { - IntType id; + IntType id = 0; - if (util::isNumber(value)) + if (util::is_int(value)) id = std::stoi(value); else { auto info = lookup(value.c_str()); if (info == nullptr) { - log::warning() << "irccd: invalid " << typeName << ": " << std::strerror(errno) << std::endl; + log::warning() << "irccd: invalid " << type_name << ": " << std::strerror(errno) << std::endl; return; } else { id = getter(info); - log::debug() << "irccd: " << typeName << " " << value << " resolved to: " << id << std::endl; + log::debug() << "irccd: " << type_name << " " << value << " resolved to: " << id << std::endl; } } if (setter(id) < 0) - log::warning() << "irccd: could not set " << typeName << ": " << std::strerror(errno) << std::endl; + log::warning() << "irccd: could not set " << type_name << ": " << std::strerror(errno) << std::endl; else - log::info() << "irccd: setting " << typeName << " to " << value << std::endl; + log::info() << "irccd: setting " << type_name << " to " << value << std::endl; } /* @@ -397,18 +401,18 @@ } // !namespace -void setProgramName(std::string name) noexcept +void set_program_name(std::string name) noexcept { - programNameCopy = std::move(name); + program_name_value = std::move(name); #if defined(HAVE_SETPROGNAME) - setprogname(programNameCopy.c_str()); + setprogname(program_name_value.c_str()); #endif } -const std::string &programName() noexcept +const std::string& program_name() noexcept { - return programNameCopy; + return program_name_value; } std::string name() @@ -513,7 +517,7 @@ #endif } -std::string env(const std::string &var) +std::string env(const std::string& var) { auto value = std::getenv(var.c_str()); @@ -525,9 +529,9 @@ #if defined(HAVE_SETUID) -void setUid(const std::string &value) +void set_uid(const std::string& value) { - setHelper("uid", value, &getpwnam, &setuid, [] (const struct passwd *pw) { + set_privileges("uid", value, &getpwnam, &setuid, [] (auto pw) { return pw->pw_uid; }); } @@ -536,9 +540,9 @@ #if defined(HAVE_SETGID) -void setGid(const std::string &value) +void set_gid(const std::string& value) { - setHelper("gid", value, &getgrnam, &setgid, [] (const struct group *gr) { + set_privileges("gid", value, &getgrnam, &setgid, [] (auto gr) { return gr->gr_gid; }); } diff -r beb6c638b841 -r 7e273b7f4f92 libcommon/irccd/system.hpp --- a/libcommon/irccd/system.hpp Fri Aug 11 13:45:42 2017 +0200 +++ b/libcommon/irccd/system.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -44,14 +44,14 @@ * * \param name the program name */ -IRCCD_EXPORT void setProgramName(std::string name) noexcept; +IRCCD_EXPORT void set_program_name(std::string name) noexcept; /** * Get the program name. * * \return the program name */ -IRCCD_EXPORT const std::string &programName() noexcept; +IRCCD_EXPORT const std::string& program_name() noexcept; /** * Get the system name. @@ -72,7 +72,7 @@ * * \return the number of seconds */ -IRCCD_EXPORT uint64_t uptime(); +IRCCD_EXPORT std::uint64_t uptime(); /** * Get the milliseconds elapsed since the application @@ -80,14 +80,14 @@ * * \return the milliseconds */ -IRCCD_EXPORT uint64_t ticks(); +IRCCD_EXPORT std::uint64_t ticks(); /** * Get an environment variable. * * \return the value or empty string */ -IRCCD_EXPORT std::string env(const std::string &var); +IRCCD_EXPORT std::string env(const std::string& var); /** * Get home directory usually /home/foo @@ -103,7 +103,7 @@ * * \param value the value */ -IRCCD_EXPORT void setUid(const std::string &value); +IRCCD_EXPORT void set_uid(const std::string& value); #endif @@ -114,7 +114,7 @@ * * \param value the value */ -IRCCD_EXPORT void setGid(const std::string &value); +IRCCD_EXPORT void set_gid(const std::string& value); #endif diff -r beb6c638b841 -r 7e273b7f4f92 libcommon/irccd/util.cpp --- a/libcommon/irccd/util.cpp Fri Aug 11 13:45:42 2017 +0200 +++ b/libcommon/irccd/util.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -45,7 +45,7 @@ namespace { -const std::unordered_map colorTable{ +const std::unordered_map colors{ { "white", 0 }, { "black", 1 }, { "blue", 2 }, @@ -64,7 +64,7 @@ { "lightgrey", 15 } }; -const std::unordered_map attributesTable{ +const std::unordered_map attributes{ { "bold", '\x02' }, { "italic", '\x09' }, { "strike", '\x13' }, @@ -74,12 +74,12 @@ { "reverse", '\x16' } }; -inline bool isReserved(char token) noexcept +inline bool is_reserved(char token) noexcept { return token == '#' || token == '@' || token == '$' || token == '!'; } -std::string substituteDate(const std::string &text, const Substitution ¶ms) +std::string subst_date(const std::string& text, const subst& params) { std::ostringstream oss; @@ -87,7 +87,8 @@ oss << std::put_time(std::localtime(¶ms.time), text.c_str()); #else /* - * Quick and dirty hack because GCC does not have this function. + * Quick and dirty hack because old version of GCC does not have this + * function. */ char buffer[4096]; @@ -99,7 +100,7 @@ return oss.str(); } -std::string substituteKeywords(const std::string &content, const Substitution ¶ms) +std::string subst_keywords(const std::string& content, const subst& params) { auto value = params.keywords.find(content); @@ -109,7 +110,7 @@ return ""; } -std::string substituteEnv(const std::string &content) +std::string subst_env(const std::string& content) { auto value = std::getenv(content.c_str()); @@ -119,14 +120,14 @@ return ""; } -std::string substituteAttributes(const std::string &content) +std::string subst_attrs(const std::string& content) { std::stringstream oss; std::vector list = split(content, ","); // @{} means reset. if (list.empty()) - return std::string(1, attributesTable.at("reset")); + return std::string(1, attributes.at("reset")); // Remove useless spaces. std::transform(list.begin(), list.end(), list.begin(), strip); @@ -142,19 +143,19 @@ oss << '\x03'; // Foreground. - auto it = colorTable.find(foreground); - if (it != colorTable.end()) + auto it = colors.find(foreground); + if (it != colors.end()) oss << it->second; // Background. - if (list.size() >= 2 && (it = colorTable.find(list[1])) != colorTable.end()) + if (list.size() >= 2 && (it = colors.find(list[1])) != colors.end()) oss << "," << it->second; // Attributes. for (std::size_t i = 2; i < list.size(); ++i) { - auto attribute = attributesTable.find(list[i]); + auto attribute = attributes.find(list[i]); - if (attribute != attributesTable.end()) + if (attribute != attributes.end()) oss << attribute->second; } } @@ -162,10 +163,10 @@ return oss.str(); } -std::string substituteShell(const std::string &command) +std::string subst_shell(const std::string& command) { #if defined(HAVE_POPEN) - std::unique_ptr> fp(popen(command.c_str(), "r"), pclose); + std::unique_ptr> fp(popen(command.c_str(), "r"), pclose); if (fp == nullptr) throw std::runtime_error(std::strerror(errno)); @@ -190,9 +191,9 @@ #endif } -std::string substitute(std::string::const_iterator &it, std::string::const_iterator &end, char token, const Substitution ¶ms) +std::string substitute(std::string::const_iterator& it, std::string::const_iterator& end, char token, const subst& params) { - assert(isReserved(token)); + assert(is_reserved(token)); std::string content, value; @@ -212,20 +213,20 @@ switch (token) { case '#': - if (params.flags & Substitution::Keywords) - value = substituteKeywords(content, params); + if ((params.flags & subst_flags::keywords) == subst_flags::keywords) + value = subst_keywords(content, params); break; case '$': - if (params.flags & Substitution::Env) - value = substituteEnv(content); + if ((params.flags & subst_flags::env) == subst_flags::env) + value = subst_env(content); break; case '@': - if (params.flags & Substitution::IrcAttrs) - value = substituteAttributes(content); + if ((params.flags & subst_flags::irc_attrs) == subst_flags::irc_attrs) + value = subst_attrs(content); break; case '!': - if (params.flags & Substitution::Shell) - value = substituteShell(content); + if ((params.flags & subst_flags::shell) == subst_flags::shell) + value = subst_shell(content); break; default: break; @@ -236,33 +237,33 @@ } // !namespace -std::string format(std::string text, const Substitution ¶ms) +std::string format(std::string text, const subst& params) { /* * Change the date format before anything else to avoid interpolation with * keywords and user input. */ - if (params.flags & Substitution::Date) - text = substituteDate(text, params); + if ((params.flags & subst_flags::date) == subst_flags::date) + text = subst_date(text, params); std::ostringstream oss; for (auto it = text.cbegin(), end = text.cend(); it != end; ) { auto token = *it; - /* Is the current character a reserved token or not? */ - if (!isReserved(token)) { + // Is the current character a reserved token or not? + if (!is_reserved(token)) { oss << *it++; continue; } - /* The token was at the end, just write it and return now. */ + // The token was at the end, just write it and return now. if (++it == end) { oss << token; continue; } - /* The token is declaring a template variable, substitute it. */ + // The token is declaring a template variable, substitute it. if (*it == '{') { oss << substitute(++it, end, token, params); continue; @@ -307,7 +308,7 @@ return str; } -std::vector split(const std::string &list, const std::string &delimiters, int max) +std::vector split(const std::string& list, const std::string& delimiters, int max) { std::vector result; std::size_t next = -1, current; @@ -338,10 +339,10 @@ return result; } -MessagePair parseMessage(std::string message, const std::string &cc, const std::string &name) +message_pack parse_message(std::string message, const std::string& cc, const std::string& name) { - std::string result = message; - bool iscommand = false; + auto result = message; + auto iscommand = false; // handle special commands "! command" if (cc.length() > 0) { @@ -371,10 +372,13 @@ } } - return MessagePair(result, ((iscommand) ? MessageType::Command : MessageType::Message)); + return { + iscommand ? message_pack::type::command : message_pack::type::message, + result + }; } -bool isBoolean(std::string value) noexcept +bool is_boolean(std::string value) noexcept { std::transform(value.begin(), value.end(), value.begin(), [] (auto c) { return toupper(c); @@ -383,7 +387,7 @@ return value == "1" || value == "YES" || value == "TRUE" || value == "ON"; } -bool isInt(const std::string &str, int base) noexcept +bool is_int(const std::string &str, int base) noexcept { if (str.empty()) return false; @@ -395,7 +399,7 @@ return *ptr == 0; } -bool isReal(const std::string &str) noexcept +bool is_real(const std::string &str) noexcept { if (str.empty()) return false; @@ -407,7 +411,7 @@ return *ptr == 0; } -std::string nextNetwork(std::string &input) +std::string next_network(std::string& input) { std::string result; std::string::size_type pos = input.find("\r\n\r\n"); diff -r beb6c638b841 -r 7e273b7f4f92 libcommon/irccd/util.hpp --- a/libcommon/irccd/util.hpp Fri Aug 11 13:45:42 2017 +0200 +++ b/libcommon/irccd/util.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -51,8 +51,7 @@ namespace util { /** - * \enum MessageType - * \brief Describe which type of message has been received + * \brief Pack a message and its type * * On channels and queries, you may have a special command or a standard message * depending on the beginning of the message. @@ -60,36 +59,95 @@ * Example: `!reminder help' may invoke the command event if a plugin reminder * exists. */ -enum class MessageType { - Command, //!< special command - Message //!< standard message +struct message_pack { + /** + * \brief Describe which type of message has been received + */ + enum class type { + command, //!< special command + message //!< standard message + } type; + + /** + * Message content. + */ + std::string message; +}; + +/** + * \brief Disable or enable some features. + */ +enum class subst_flags : std::uint8_t { + date = (1 << 0), //!< date templates + keywords = (1 << 1), //!< keywords + env = (1 << 2), //!< environment variables + shell = (1 << 3), //!< command line command + irc_attrs = (1 << 4) //!< IRC escape codes }; /** - * \brief Combine the type of message and its content. + * \cond ENUM_HIDDEN_SYMBOLS */ -using MessagePair = std::pair; + +inline subst_flags operator^(subst_flags v1, subst_flags v2) noexcept +{ + return static_cast(static_cast(v1) ^ static_cast(v2)); +} + +inline subst_flags operator&(subst_flags v1, subst_flags v2) noexcept +{ + return static_cast(static_cast(v1)& static_cast(v2)); +} + +inline subst_flags operator|(subst_flags v1, subst_flags v2) noexcept +{ + return static_cast(static_cast(v1) | static_cast(v2)); +} + +inline subst_flags operator~(subst_flags v) noexcept +{ + return static_cast(~static_cast(v)); +} + +inline subst_flags& operator|=(subst_flags& v1, subst_flags v2) noexcept +{ + v1 = static_cast(static_cast(v1) | static_cast(v2)); + + return v1; +} + +inline subst_flags& operator&=(subst_flags& v1, subst_flags v2) noexcept +{ + v1 = static_cast(static_cast(v1)& static_cast(v2)); + + return v1; +} + +inline subst_flags& operator^=(subst_flags& v1, subst_flags v2) noexcept +{ + v1 = static_cast(static_cast(v1) ^ static_cast(v2)); + + return v1; +} + +/** + * \endcond + */ /** * \brief Used for format() function. */ -class Substitution { +class subst { public: /** - * \brief Disable or enable some features. - */ - enum Flags { - Date = (1 << 0), //!< date templates - Keywords = (1 << 1), //!< keywords - Env = (1 << 2), //!< environment variables - Shell = (1 << 3), //!< command line command - IrcAttrs = (1 << 4) //!< IRC escape codes - }; - - /** * Flags for selecting templates. */ - std::uint8_t flags{Date | Keywords | Env | IrcAttrs}; + subst_flags flags{ + subst_flags::date | + subst_flags::keywords | + subst_flags::env | + subst_flags::irc_attrs + }; /** * Fill that field if you want a date. @@ -156,7 +214,7 @@ * - \@{white,black,bold,underline}: will write white text on * black in both bold and underline. */ -IRCCD_EXPORT std::string format(std::string text, const Substitution ¶ms = {}); +IRCCD_EXPORT std::string format(std::string text, const subst& params = {}); /** * Remove leading and trailing spaces. @@ -174,7 +232,7 @@ * \param max max number of split * \return a list of string splitted */ -IRCCD_EXPORT std::vector split(const std::string &list, const std::string &delimiters, int max = -1); +IRCCD_EXPORT std::vector split(const std::string& list, const std::string& delimiters, int max = -1); /** * Join values by a separator and return a string. @@ -228,12 +286,17 @@ /** * Parse IRC message and determine if it's a command or a simple message. * + * If it's a command, the plugin invocation command is removed from the + * original message, otherwise it is copied verbatime. + * * \param message the message line - * \param commandChar the command char (e.g '!') + * \param cchar the command char (e.g '!') * \param plugin the plugin name * \return the pair */ -IRCCD_EXPORT MessagePair parseMessage(std::string message, const std::string &commandChar, const std::string &plugin); +IRCCD_EXPORT message_pack parse_message(std::string message, + const std::string& cchar, + const std::string& plugin); /** * Server and identities must have strict names. This function can @@ -242,7 +305,7 @@ * \param name the identifier name * \return true if is valid */ -inline bool isIdentifierValid(const std::string &name) +inline bool is_identifier(const std::string& name) { return std::regex_match(name, std::regex("[A-Za-z0-9-_]+")); } @@ -254,7 +317,7 @@ * \return true if is boolean * \note this function is case-insensitive */ -IRCCD_EXPORT bool isBoolean(std::string value) noexcept; +IRCCD_EXPORT bool is_boolean(std::string value) noexcept; /** * Check if the string is an integer. @@ -263,15 +326,15 @@ * \param base the optional base * \return true if integer */ -IRCCD_EXPORT bool isInt(const std::string &value, int base = 10) noexcept; - +IRCCD_EXPORT bool is_int(const std::string& value, int base = 10) noexcept; + /** * Check if the string is real. * * \param value the value * \return true if real */ -IRCCD_EXPORT bool isReal(const std::string &value) noexcept; +IRCCD_EXPORT bool is_real(const std::string& value) noexcept; /** * Check if the string is a number. @@ -279,23 +342,9 @@ * \param value the value * \return true if it is a number */ -inline bool isNumber(const std::string &value) noexcept +inline bool is_number(const std::string& value) noexcept { - return isInt(value) || isReal(value); -} - -/** - * Tells if a number is bound between the limits. - * - * \param value the value to check - * \param min the minimum - * \param max the maximum - * \return true if value is beyond the limits - */ -template -constexpr bool isBound(T value, T min = std::numeric_limits::min(), T max = std::numeric_limits::max()) noexcept -{ - return value >= min && value <= max; + return is_int(value) || is_real(value); } /** @@ -316,7 +365,9 @@ * \throw std::out_of_range if the number is not between min and max */ template -inline T toNumber(const std::string &number, T min = std::numeric_limits::min(), T max = std::numeric_limits::max()) +inline T to_number(const std::string& number, + T min = std::numeric_limits::min(), + T max = std::numeric_limits::max()) { static_assert(std::is_integral::value, "T must be integer type"); @@ -334,14 +385,6 @@ } /** - * Parse a network message from an input buffer and remove it from it. - * - * \param input the buffer, will be updated - * \return the message or empty string if there is nothing - */ -IRCCD_EXPORT std::string nextNetwork(std::string &input); - -/** * Use arguments to avoid compiler warnings about unused parameters. */ template @@ -350,6 +393,14 @@ } /** + * Parse a network message from an input buffer and remove it from it. + * + * \param input the buffer, will be updated + * \return the message or empty string if there is nothing + */ +IRCCD_EXPORT std::string next_network(std::string& input); + +/** * Utilities for nlohmann json. */ namespace json { @@ -363,7 +414,7 @@ * \return the value * \throw std::runtime_error if the property is missing */ -inline nlohmann::json require(const nlohmann::json &json, const std::string &key, nlohmann::json::value_t type) +inline nlohmann::json require(const nlohmann::json& json, const std::string& key, nlohmann::json::value_t type) { auto it = json.find(key); auto dummy = nlohmann::json(type); @@ -384,7 +435,7 @@ * \return the boolean * \throw std::runtime_error if the property is missing or not a boolean */ -inline bool requireBool(const nlohmann::json &json, const std::string &key) +inline bool require_bool(const nlohmann::json& json, const std::string& key) { return require(json, key, nlohmann::json::value_t::boolean); } @@ -397,7 +448,7 @@ * \return the int * \throw std::runtime_error if the property is missing or not ant int */ -inline std::int64_t requireInt(const nlohmann::json &json, const std::string &key) +inline std::int64_t require_int(const nlohmann::json& json, const std::string& key) { auto it = json.find(key); @@ -420,7 +471,7 @@ * \return the unsigned int * \throw std::runtime_error if the property is missing or not ant int */ -inline std::uint64_t requireUint(const nlohmann::json &json, const std::string &key) +inline std::uint64_t require_uint(const nlohmann::json& json, const std::string& key) { auto it = json.find(key); @@ -443,7 +494,7 @@ * \return the string * \throw std::runtime_error if the property is missing or not a string */ -inline std::string requireString(const nlohmann::json &json, const std::string &key) +inline std::string require_string(const nlohmann::json& json, const std::string& key) { return require(json, key, nlohmann::json::value_t::string); } @@ -456,11 +507,11 @@ * \return the identifier * \throw std::runtime_error if the property is invalid */ -inline std::string requireIdentifier(const nlohmann::json &json, const std::string &key) +inline std::string require_identifier(const nlohmann::json& json, const std::string& key) { - auto id = requireString(json, key); + auto id = require_string(json, key); - if (!isIdentifierValid(id)) + if (!is_identifier(id)) throw std::runtime_error("invalid '{}' identifier property"); return id; @@ -473,7 +524,7 @@ * \param def the default value if not boolean * \return a boolean */ -inline bool toBool(const nlohmann::json &json, bool def = false) noexcept +inline bool to_bool(const nlohmann::json& json, bool def = false) noexcept { return json.is_boolean() ? json.get() : def; } @@ -485,7 +536,7 @@ * \param def the default value if not an int * \return an int */ -inline std::int64_t toInt(const nlohmann::json &json, std::int64_t def = 0) noexcept +inline std::int64_t to_int(const nlohmann::json& json, std::int64_t def = 0) noexcept { return json.is_number_integer() ? json.get() : def; } @@ -497,7 +548,7 @@ * \param def the default value if not a unsigned int * \return an unsigned int */ -inline std::uint64_t toUint(const nlohmann::json &json, std::uint64_t def = 0) noexcept +inline std::uint64_t to_uint(const nlohmann::json& json, std::uint64_t def = 0) noexcept { return json.is_number_unsigned() ? json.get() : def; } @@ -509,7 +560,7 @@ * \param def the default value if not a string * \return a string */ -inline std::string toString(const nlohmann::json &json, std::string def = "") noexcept +inline std::string to_string(const nlohmann::json& json, std::string def = "") noexcept { return json.is_string() ? json.get() : def; } @@ -521,7 +572,7 @@ * \param property the property key * \return the value or null one if not found */ -inline nlohmann::json get(const nlohmann::json &json, const std::string &property) noexcept +inline nlohmann::json get(const nlohmann::json& json, const std::string& property) noexcept { auto it = json.find(property); @@ -539,9 +590,11 @@ * \param def the default value * \return the boolean */ -inline bool getBool(const nlohmann::json &json, const std::string &key, bool def = false) noexcept +inline bool get_bool(const nlohmann::json& json, + const std::string& key, + bool def = false) noexcept { - return toBool(get(json, key), def); + return to_bool(get(json, key), def); } /** @@ -552,9 +605,11 @@ * \param def the default value * \return the int */ -inline std::int64_t getInt(const nlohmann::json &json, const std::string &key, std::int64_t def = 0) noexcept +inline std::int64_t get_int(const nlohmann::json& json, + const std::string& key, + std::int64_t def = 0) noexcept { - return toInt(get(json, key), def); + return to_int(get(json, key), def); } /** @@ -565,9 +620,11 @@ * \param def the default value * \return the unsigned int */ -inline std::uint64_t getUint(const nlohmann::json &json, const std::string &key, std::uint64_t def = 0) noexcept +inline std::uint64_t get_uint(const nlohmann::json& json, + const std::string& key, + std::uint64_t def = 0) noexcept { - return toUint(get(json, key), def); + return to_uint(get(json, key), def); } /** @@ -580,12 +637,12 @@ * \return the value */ template -inline T getIntRange(const nlohmann::json &json, - const std::string &key, - std::int64_t min = std::numeric_limits::min(), - std::int64_t max = std::numeric_limits::max()) noexcept +inline T get_int_range(const nlohmann::json& json, + const std::string& key, + std::int64_t min = std::numeric_limits::min(), + std::int64_t max = std::numeric_limits::max()) noexcept { - return clamp(getInt(json, key), min, max); + return clamp(get_int(json, key), min, max); } /** @@ -598,12 +655,12 @@ * \return value */ template -inline T getUintRange(const nlohmann::json &json, - const std::string &key, - std::uint64_t min = std::numeric_limits::min(), - std::uint64_t max = std::numeric_limits::max()) noexcept +inline T get_uint_range(const nlohmann::json& json, + const std::string& key, + std::uint64_t min = std::numeric_limits::min(), + std::uint64_t max = std::numeric_limits::max()) noexcept { - return clamp(getUint(json, key), min, max); + return clamp(get_uint(json, key), min, max); } /** @@ -614,9 +671,11 @@ * \param def the default value * \return the string */ -inline std::string getString(const nlohmann::json &json, const std::string &key, std::string def = "") noexcept +inline std::string get_string(const nlohmann::json& json, + const std::string& key, + std::string def = "") noexcept { - return toString(get(json, key), def); + return to_string(get(json, key), def); } /** @@ -625,7 +684,7 @@ * \param value the value * \return the string */ -inline std::string pretty(const nlohmann::json &value) +inline std::string pretty(const nlohmann::json& value) { switch (value.type()) { case nlohmann::json::value_t::boolean: @@ -644,7 +703,7 @@ * \param prop the property * \return the pretty value or empty if key does not exist */ -inline std::string pretty(const nlohmann::json &object, const std::string &prop) +inline std::string pretty(const nlohmann::json& object, const std::string& prop) { auto it = object.find(prop); diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/CMakeLists.txt --- a/libirccd-js/CMakeLists.txt Fri Aug 11 13:45:42 2017 +0200 +++ b/libirccd-js/CMakeLists.txt Tue Sep 26 17:18:47 2017 +0200 @@ -21,37 +21,37 @@ set( HEADERS ${libirccd-js_SOURCE_DIR}/irccd/duktape.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-directory.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-elapsed-timer.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-file.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-irccd.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-logger.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-plugin.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-server.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-system.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-timer.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_directory_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_elapsed_timer_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_file_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_irccd_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_logger_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_plugin_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_server_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_system_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_timer_module.hpp ${libirccd-js_SOURCE_DIR}/irccd/module.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-unicode.hpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-util.hpp - ${libirccd-js_SOURCE_DIR}/irccd/plugin-js.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_unicode_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_util_module.hpp + ${libirccd-js_SOURCE_DIR}/irccd/js_plugin.hpp ${libirccd-js_SOURCE_DIR}/irccd/timer.hpp ${libirccd-js_SOURCE_DIR}/irccd/unicode.hpp ) set( SOURCES - ${libirccd-js_SOURCE_DIR}/irccd/mod-directory.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-elapsed-timer.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-file.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-irccd.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-logger.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-plugin.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-server.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-system.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-timer.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-unicode.cpp - ${libirccd-js_SOURCE_DIR}/irccd/mod-util.cpp - ${libirccd-js_SOURCE_DIR}/irccd/plugin-js.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_directory_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_elapsed_timer_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_file_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_irccd_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_logger_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_plugin_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_server_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_system_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_timer_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_unicode_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_util_module.cpp + ${libirccd-js_SOURCE_DIR}/irccd/js_plugin.cpp ${libirccd-js_SOURCE_DIR}/irccd/timer.cpp ${libirccd-js_SOURCE_DIR}/irccd/unicode.cpp ) diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_directory_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_directory_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,384 @@ +/* + * js_directory_module.cpp -- irccd.Directory API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "duktape.hpp" +#include "fs.hpp" +#include "js_directory_module.hpp" +#include "js_irccd_module.hpp" +#include "js_plugin.hpp" +#include "sysconfig.hpp" + +namespace irccd { + +namespace { + +std::string path(duk_context *ctx) +{ + duk_push_this(ctx); + duk_get_prop_string(ctx, -1, "path"); + + if (duk_get_type(ctx, -1) != DUK_TYPE_STRING) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Directory object"); + + auto ret = dukx_get_std_string(ctx, -1); + + if (ret.empty()) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "directory object has empty path"); + + duk_pop_n(ctx, 2); + + return ret; +} + +/* + * Find an entry recursively (or not) in a directory using a predicate which can + * be used to test for regular expression, equality. + * + * Do not use this function directly, use: + * + * - find_name + * - find_regex + */ +template +std::string find_path(const std::string& base, bool recursive, Pred&& pred) +{ + /* + * For performance reason, we first iterate over all entries that are + * not directories to avoid going deeper recursively if the requested + * file is in the current directory. + */ + auto entries = fs::readdir(base); + + for (const auto& entry : entries) + if (entry.type != fs::Entry::Dir && pred(entry.name)) + return base + entry.name; + + if (!recursive) + return ""; + + for (const auto& entry : entries) { + if (entry.type == fs::Entry::Dir) { + std::string next = base + entry.name + fs::separator(); + std::string path = find_path(next, true, pred); + + if (!path.empty()) + return path; + } + } + + return ""; +} + +/* + * Helper for finding by equality. + */ +std::string find_name(std::string base, const std::string& pattern, bool recursive) +{ + return find_path(base, recursive, [&] (const auto& entryname) -> bool { + return pattern == entryname; + }); +} + +/* + * Helper for finding by regular expression + */ +std::string find_regex(const std::string& base, std::string pattern, bool recursive) +{ + std::regex regexp(pattern, std::regex::ECMAScript); + std::smatch smatch; + + return find_path(base, recursive, [&] (const auto& entryname) -> bool { + return std::regex_match(entryname, smatch, regexp); + }); +} + +/* + * Generic find function for: + * + * - Directory.find + * - Directory.prototype.find + * + * The patternIndex is the argument where to test if the argument is a regex or + * a string. + */ +duk_ret_t find(duk_context* ctx, std::string base, bool recursive, int pattern_index) +{ + try { + std::string path; + + if (duk_is_string(ctx, pattern_index)) + path = find_name(base, duk_get_string(ctx, pattern_index), recursive); + else { + // Check if it's a valid RegExp object. + duk_get_global_string(ctx, "RegExp"); + auto is_regex = duk_instanceof(ctx, pattern_index, -1); + duk_pop(ctx); + + if (is_regex) { + duk_get_prop_string(ctx, pattern_index, "source"); + auto pattern = duk_to_string(ctx, -1); + duk_pop(ctx); + + path = find_regex(base, pattern, recursive); + } else + duk_error(ctx, DUK_ERR_TYPE_ERROR, "pattern must be a string or a regex expression"); + } + + if (path.empty()) + return 0; + + dukx_push_std_string(ctx, path); + } catch (const std::exception& ex) { + duk_error(ctx, DUK_ERR_ERROR, "%s", ex.what()); + } + + return 1; +} + +/* + * Generic remove function for: + * + * - Directory.remove + * - Directory.prototype.remove + */ +duk_ret_t remove(duk_context* ctx, const std::string& path, bool recursive) +{ + boost::system::error_code ec; + + if (!boost::filesystem::is_directory(path, ec) || ec) + dukx_throw(ctx, system_error(EINVAL, "not a directory")); + + if (!recursive) + boost::filesystem::remove(path, ec); + else + boost::filesystem::remove_all(path, ec); + + return 0; +} + +/* + * Method: Directory.find(pattern, recursive) + * -------------------------------------------------------- + * + * Synonym of Directory.find(path, pattern, recursive) but the path is taken + * from the directory object. + * + * Arguments: + * - pattern, the regular expression or file name, + * - recursive, set to true to search recursively (default: false). + * Returns: + * The path to the file or undefined if not found. + * Throws: + * - Any exception on error. + */ +duk_ret_t method_find(duk_context* ctx) +{ + return find(ctx, path(ctx), duk_get_boolean(ctx, 1), 0); +} + +/* + * Method: Directory.remove(recursive) + * -------------------------------------------------------- + * + * Synonym of Directory.remove(recursive) but the path is taken from the + * directory object. + * + * Arguments: + * - recursive, recursively or not (default: false). + * Throws: + * - Any exception on error. + */ +duk_ret_t method_remove(duk_context* ctx) +{ + return remove(ctx, path(ctx), duk_get_boolean(ctx, 0)); +} + +const duk_function_list_entry methods[] = { + { "find", method_find, DUK_VARARGS }, + { "remove", method_remove, 1 }, + { nullptr, nullptr, 0 } +}; + +/* + * Directory "static" functions + * ------------------------------------------------------------------ + */ + +/* + * Function: irccd.Directory(path, flags) [constructor] + * -------------------------------------------------------- + * + * Opens and read the directory at the specified path. + * + * Arguments: + * - path, the path to the directory, + * - flags, the optional flags (default: 0). + * Throws: + * - Any exception on error + */ +duk_ret_t constructor(duk_context* ctx) +{ + if (!duk_is_constructor_call(ctx)) + return 0; + + try { + auto path = duk_require_string(ctx, 0); + auto flags = duk_get_uint(ctx, 1); + + if (!boost::filesystem::is_directory(path)) + dukx_throw(ctx, system_error(EINVAL, "not a directory")); + + auto list = fs::readdir(path, flags); + + duk_push_this(ctx); + duk_push_string(ctx, "count"); + duk_push_int(ctx, list.size()); + duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE); + duk_push_string(ctx, "path"); + dukx_push_std_string(ctx, path); + duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE); + duk_push_string(ctx, "entries"); + duk_push_array(ctx); + + for (unsigned i = 0; i < list.size(); ++i) { + duk_push_object(ctx); + dukx_push_std_string(ctx, list[i].name); + duk_put_prop_string(ctx, -2, "name"); + duk_push_int(ctx, list[i].type); + duk_put_prop_string(ctx, -2, "type"); + duk_put_prop_index(ctx, -2, i); + } + + duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE); + } catch (const std::exception& ex) { + dukx_throw(ctx, system_error(errno, ex.what())); + } + + return 0; +} + +/* + * Function: irccd.Directory.find(path, pattern, recursive) + * -------------------------------------------------------- + * + * Find an entry by a pattern or a regular expression. + * + * Arguments: + * - path, the base path, + * - pattern, the regular expression or file name, + * - recursive, set to true to search recursively (default: false). + * Returns: + * The path to the file or undefined on errors or not found. + */ +duk_ret_t func_find(duk_context* ctx) +{ + return find(ctx, duk_require_string(ctx, 0), duk_get_boolean(ctx, 2), 1); +} + +/* + * Function: irccd.Directory.remove(path, recursive) + * -------------------------------------------------------- + * + * Remove the directory optionally recursively. + * + * Arguments: + * - path, the path to the directory, + * - recursive, recursively or not (default: false). + * Throws: + * - Any exception on error. + */ +duk_ret_t func_remove(duk_context *ctx) +{ + return remove(ctx, duk_require_string(ctx, 0), duk_get_boolean(ctx, 1)); +} + +/* + * Function: irccd.Directory.mkdir(path, mode = 0700) + * -------------------------------------------------------- + * + * Create a directory specified by path. It will create needed subdirectories + * just like you have invoked mkdir -p. + * + * Arguments: + * - path, the path to the directory, + * Throws: + * - Any exception on error. + */ +duk_ret_t func_mkdir(duk_context *ctx) +{ + try { + boost::filesystem::create_directories(duk_require_string(ctx, 0)); + } catch (const std::exception &ex) { + dukx_throw(ctx, system_error(errno, ex.what())); + } + + return 0; +} + +const duk_function_list_entry functions[] = { + { "find", func_find, DUK_VARARGS }, + { "mkdir", func_mkdir, DUK_VARARGS }, + { "remove", func_remove, DUK_VARARGS }, + { nullptr, nullptr, 0 } +}; + +const duk_number_list_entry constants[] = { + { "Dot", static_cast(fs::Dot) }, + { "DotDot", static_cast(fs::DotDot) }, + { "TypeUnknown", static_cast(fs::Entry::Unknown) }, + { "TypeDir", static_cast(fs::Entry::Dir) }, + { "TypeFile", static_cast(fs::Entry::File) }, + { "TypeLink", static_cast(fs::Entry::Link) }, + { nullptr, 0 } +}; + +} // !namespace + +js_directory_module::js_directory_module() noexcept + : module("Irccd.Directory") +{ +} + +void js_directory_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_c_function(plugin->context(), constructor, 2); + duk_put_number_list(plugin->context(), -1, constants); + duk_put_function_list(plugin->context(), -1, functions); + dukx_push_std_string(plugin->context(), std::string{fs::separator()}); + duk_put_prop_string(plugin->context(), -2, "separator"); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, methods); + duk_put_prop_string(plugin->context(), -2, "prototype"); + duk_put_prop_string(plugin->context(), -2, "Directory"); + duk_pop(plugin->context()); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_directory_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_directory_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,50 @@ +/* + * js_directory_module.hpp -- irccd.Directory API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_DIRECTORY_MODULE_HPP +#define IRCCD_JS_DIRECTORY_MODULE_HPP + +/** + * \file mod-directory.hpp + * \brief irccd.Directory JavaScript API. + */ + +#include "module.hpp" + +namespace irccd { + +/** + * \brief irccd.Directory JavaScript API. + * \ingroup modules + */ +class js_directory_module : public module { +public: + /** + * Constructor. + */ + js_directory_module() noexcept; + + /** + * \copydoc Module::load + */ + void load(irccd &irccd, std::shared_ptr plugin) override; +}; + +} // !irccd + +#endif // !IRCCD_JS_DIRECTORY_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_elapsed_timer_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_elapsed_timer_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,162 @@ +/* + * js_elapsed_timer_module.cpp -- irccd.ElapsedTimer API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include + +#include "js_elapsed_timer_module.hpp" + +namespace irccd { + +namespace { + +const char* signature("\xff""\xff""irccd-elapsed-timer-ptr"); + +ElapsedTimer* self(duk_context* ctx) +{ + StackAssert sa(ctx); + + duk_push_this(ctx); + duk_get_prop_string(ctx, -1, signature); + auto ptr = static_cast(duk_to_pointer(ctx, -1)); + duk_pop_2(ctx); + + if (!ptr) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "not an ElapsedTimer object"); + + return ptr; +} + +/* + * Method: ElapsedTimer.pause + * ------------------------------------------------------------------ + * + * Pause the timer, without resetting the current elapsed time stored. + */ +duk_ret_t pause(duk_context* ctx) +{ + self(ctx)->pause(); + + return 0; +} + +/* + * Method: ElapsedTimer.reset + * ------------------------------------------------------------------ + * + * Reset the elapsed time to 0, the status is not modified. + */ +duk_ret_t reset(duk_context* ctx) +{ + self(ctx)->reset(); + + return 0; +} + +/* + * Method: ElapsedTimer.restart + * ------------------------------------------------------------------ + * + * Restart the timer without resetting the current elapsed time. + */ +duk_ret_t restart(duk_context* ctx) +{ + self(ctx)->restart(); + + return 0; +} + +/* + * Method: ElapsedTimer.elapsed + * ------------------------------------------------------------------ + * + * Get the number of elapsed milliseconds. + * + * Returns: + * The time elapsed. + */ +duk_ret_t elapsed(duk_context* ctx) +{ + duk_push_uint(ctx, self(ctx)->elapsed()); + + return 1; +} + +/* + * Function: Irccd.ElapsedTimer() [constructor] + * ------------------------------------------------------------------ + * + * Construct a new ElapsedTimer object. + */ +duk_ret_t constructor(duk_context* ctx) +{ + duk_push_this(ctx); + duk_push_pointer(ctx, new ElapsedTimer); + duk_put_prop_string(ctx, -2, signature); + duk_pop(ctx); + + return 0; +} + +/* + * Function: irccd.ElapsedTimer() [destructor] + * ------------------------------------------------------------------ + * + * Delete the property. + */ +duk_ret_t destructor(duk_context* ctx) +{ + duk_get_prop_string(ctx, 0, signature); + delete static_cast(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + duk_del_prop_string(ctx, 0, signature); + + return 0; +} + +const duk_function_list_entry methods[] = { + { "elapsed", elapsed, 0 }, + { "pause", pause, 0 }, + { "reset", reset, 0 }, + { "restart", restart, 0 }, + { nullptr, nullptr, 0 } +}; + +} // !namespace + +js_elapsed_timer_module::js_elapsed_timer_module() noexcept + : module("Irccd.ElapsedTimer") +{ +} + +void js_elapsed_timer_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_c_function(plugin->context(), constructor, 0); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, methods); + duk_push_c_function(plugin->context(), destructor, 1); + duk_set_finalizer(plugin->context(), -2); + duk_put_prop_string(plugin->context(), -2, "prototype"); + duk_put_prop_string(plugin->context(), -2, "ElapsedTimer"); + duk_pop(plugin->context()); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_elapsed_timer_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_elapsed_timer_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,50 @@ +/* + * js_elapsed_timer_module.hpp -- irccd.ElapsedTimer API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_ELAPSED_TIMER_MODULE_HPP +#define IRCCD_JS_ELAPSED_TIMER_MODULE_HPP + +/** + * \file js_elapsed_timer_module.hpp + * \brief irccd.ElapsedTimer JavaScript API. + */ + +#include "module.hpp" + +namespace irccd { + +/** + * \brief Irccd.ElapsedTimer JavaScript API. + * \ingroup Javascript modules + */ +class js_elapsed_timer_module : public module { +public: + /** + * Constructor. + */ + js_elapsed_timer_module() noexcept; + + /** + * \copydoc module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +} // !irccd + +#endif // !IRCCD_JS_ELAPSED_TIMER_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_file_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_file_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,700 @@ +/* + * js_file_module.cpp -- Irccd.File API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include + +#include + +#include + +#if defined(HAVE_STAT) +# include +# include +#endif + +#include +#include + +#include "js_file_module.hpp" +#include "js_irccd_module.hpp" + +namespace irccd { + +namespace { + +const char *signature("\xff""\xff""irccd-file-ptr"); +const char *prototype("\xff""\xff""irccd-file-prototype"); + +#if defined(HAVE_STAT) + +/* + * push_stat + * ------------------------------------------------------------------ + */ + +void push_stat(duk_context* ctx, const struct stat& st) +{ + StackAssert sa(ctx, 1); + + duk_push_object(ctx); + +#if defined(HAVE_STAT_ST_ATIME) + duk_push_int(ctx, st.st_atime); + duk_put_prop_string(ctx, -2, "atime"); +#endif +#if defined(HAVE_STAT_ST_BLKSIZE) + duk_push_int(ctx, st.st_blksize); + duk_put_prop_string(ctx, -2, "blksize"); +#endif +#if defined(HAVE_STAT_ST_BLOCKS) + duk_push_int(ctx, st.st_blocks); + duk_put_prop_string(ctx, -2, "blocks"); +#endif +#if defined(HAVE_STAT_ST_CTIME) + duk_push_int(ctx, st.st_ctime); + duk_put_prop_string(ctx, -2, "ctime"); +#endif +#if defined(HAVE_STAT_ST_DEV) + duk_push_int(ctx, st.st_dev); + duk_put_prop_string(ctx, -2, "dev"); +#endif +#if defined(HAVE_STAT_ST_GID) + duk_push_int(ctx, st.st_gid); + duk_put_prop_string(ctx, -2, "gid"); +#endif +#if defined(HAVE_STAT_ST_INO) + duk_push_int(ctx, st.st_ino); + duk_put_prop_string(ctx, -2, "ino"); +#endif +#if defined(HAVE_STAT_ST_MODE) + duk_push_int(ctx, st.st_mode); + duk_put_prop_string(ctx, -2, "mode"); +#endif +#if defined(HAVE_STAT_ST_MTIME) + duk_push_int(ctx, st.st_mtime); + duk_put_prop_string(ctx, -2, "mtime"); +#endif +#if defined(HAVE_STAT_ST_NLINK) + duk_push_int(ctx, st.st_nlink); + duk_put_prop_string(ctx, -2, "nlink"); +#endif +#if defined(HAVE_STAT_ST_RDEV) + duk_push_int(ctx, st.st_rdev); + duk_put_prop_string(ctx, -2, "rdev"); +#endif +#if defined(HAVE_STAT_ST_SIZE) + duk_push_int(ctx, st.st_size); + duk_put_prop_string(ctx, -2, "size"); +#endif +#if defined(HAVE_STAT_ST_UID) + duk_push_int(ctx, st.st_uid); + duk_put_prop_string(ctx, -2, "uid"); +#endif +} + +#endif // !HAVE_STAT + +// Remove trailing \r for CRLF line style. +inline std::string clear_crlf(std::string input) +{ + if (input.length() > 0 && input.back() == '\r') + input.pop_back(); + + return input; +} + +file* self(duk_context* ctx) +{ + StackAssert sa(ctx); + + duk_push_this(ctx); + duk_get_prop_string(ctx, -1, signature); + auto ptr = static_cast(duk_to_pointer(ctx, -1)); + duk_pop_2(ctx); + + if (!ptr) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a File object"); + + return ptr; +} + +/* + * File methods. + * ------------------------------------------------------------------ + */ + +/* + * Method: File.basename() + * -------------------------------------------------------- + * + * Synonym of `irccd.File.basename(path)` but with the path from the file. + * + * duk_ret_turns: + * The base name. + */ +duk_ret_t method_basename(duk_context* ctx) +{ + dukx_push_std_string(ctx, fs::baseName(self(ctx)->path())); + + return 1; +} + +/* + * Method: File.close() + * -------------------------------------------------------- + * + * Force close of the file, automatically called when object is collected. + */ +duk_ret_t method_close(duk_context* ctx) +{ + self(ctx)->close(); + + return 0; +} + +/* + * Method: File.dirname() + * -------------------------------------------------------- + * + * Synonym of `irccd.File.dirname(path)` but with the path from the file. + * + * duk_ret_turns: + * The directory name. + */ +duk_ret_t method_dirname(duk_context* ctx) +{ + dukx_push_std_string(ctx, fs::dirName(self(ctx)->path())); + + return 1; +} + +/* + * Method: File.lines() + * -------------------------------------------------------- + * + * Read all lines and return an array. + * + * duk_ret_turns: + * An array with all lines. + * Throws + * - Any exception on error. + */ +duk_ret_t method_lines(duk_context* ctx) +{ + duk_push_array(ctx); + + std::FILE* fp = self(ctx)->handle(); + std::string buffer; + std::array data; + std::int32_t i = 0; + + while (std::fgets(&data[0], data.size(), fp) != nullptr) { + buffer += data.data(); + + auto pos = buffer.find('\n'); + + if (pos != std::string::npos) { + dukx_push_std_string(ctx, clear_crlf(buffer.substr(0, pos))); + duk_put_prop_index(ctx, -2, i++); + + buffer.erase(0, pos + 1); + } + } + + // Maybe an error in the stream. + if (std::ferror(fp)) + dukx_throw(ctx, system_error()); + + // Missing '\n' in end of file. + if (!buffer.empty()) { + dukx_push_std_string(ctx, clear_crlf(buffer)); + duk_put_prop_index(ctx, -2, i++); + } + + return 1; +} + +/* + * Method: File.read(amount) + * -------------------------------------------------------- + * + * Read the specified amount of characters or the whole file. + * + * Arguments: + * - amount, the amount of characters or -1 to read all (Optional, default: -1). + * duk_ret_turns: + * The string. + * Throws: + * - Any exception on error. + */ +duk_ret_t method_read(duk_context* ctx) +{ + auto file = self(ctx); + auto amount = duk_is_number(ctx, 0) ? duk_get_int(ctx, 0) : -1; + + if (amount == 0 || file->handle() == nullptr) + return 0; + + try { + std::string data; + std::size_t total = 0; + + if (amount < 0) { + std::array buffer; + std::size_t nread; + + while ((nread = std::fread(&buffer[0], sizeof (buffer[0]), buffer.size(), file->handle())) > 0) { + if (std::ferror(file->handle())) + dukx_throw(ctx, system_error()); + + std::copy(buffer.begin(), buffer.begin() + nread, std::back_inserter(data)); + total += nread; + } + } else { + data.resize((std::size_t)amount); + total = std::fread(&data[0], sizeof (data[0]), (std::size_t)amount, file->handle()); + + if (std::ferror(file->handle())) + dukx_throw(ctx, system_error()); + + data.resize(total); + } + + dukx_push_std_string(ctx, data); + } catch (const std::exception&) { + dukx_throw(ctx, system_error()); + } + + return 1; +} + +/* + * Method: File.readline() + * -------------------------------------------------------- + * + * Read the next line available. + * + * duk_ret_turns: + * The next line or undefined if eof. + * Throws: + * - Any exception on error. + */ +duk_ret_t method_readline(duk_context* ctx) +{ + std::FILE* fp = self(ctx)->handle(); + std::string result; + + if (fp == nullptr || std::feof(fp)) + return 0; + for (int ch; (ch = std::fgetc(fp)) != EOF && ch != '\n'; ) + result += (char)ch; + if (std::ferror(fp)) + dukx_throw(ctx, system_error()); + + dukx_push_std_string(ctx, clear_crlf(result)); + + return 1; +} + +/* + * Method: File.remove() + * -------------------------------------------------------- + * + * Synonym of File.remove(path) but with the path from the file. + * + * Throws: + * - Any exception on error. + */ +duk_ret_t method_remove(duk_context* ctx) +{ + if (::remove(self(ctx)->path().c_str()) < 0) + dukx_throw(ctx, system_error()); + + return 0; +} + +/* + * Method: File.seek(type, amount) + * -------------------------------------------------------- + * + * Sets the position in the file. + * + * Arguments: + * - type, the type of setting (File.SeekSet, File.SeekCur, File.SeekSet), + * - amount, the new offset. + * Throws: + * - Any exception on error. + */ +duk_ret_t method_seek(duk_context* ctx) +{ + auto fp = self(ctx)->handle(); + auto type = duk_require_int(ctx, 0); + auto amount = duk_require_int(ctx, 1); + + if (fp != nullptr && std::fseek(fp, amount, type) != 0) + dukx_throw(ctx, system_error()); + + return 0; +} + +#if defined(HAVE_STAT) + +/* + * Method: File.stat() [optional] + * -------------------------------------------------------- + * + * Synonym of File.stat(path) but with the path from the file. + * + * duk_ret_turns: + * The stat information. + * Throws: + * - Any exception on error. + */ +duk_ret_t method_stat(duk_context* ctx) +{ + auto file = self(ctx); + struct stat st; + + if (file->handle() == nullptr && ::stat(file->path().c_str(), &st) < 0) + dukx_throw(ctx, system_error()); + else + push_stat(ctx, st); + + return 1; +} + +#endif // !HAVE_STAT + +/* + * Method: File.tell() + * -------------------------------------------------------- + * + * Get the actual position in the file. + * + * duk_ret_turns: + * The position. + * Throws: + * - Any exception on error. + */ +duk_ret_t method_tell(duk_context* ctx) +{ + auto fp = self(ctx)->handle(); + long pos; + + if (fp == nullptr) + return 0; + + if ((pos = std::ftell(fp)) == -1L) + dukx_throw(ctx, system_error()); + else + duk_push_int(ctx, pos); + + return 1; +} + +/* + * Method: File.write(data) + * -------------------------------------------------------- + * + * Write some characters to the file. + * + * Arguments: + * - data, the character to write. + * duk_ret_turns: + * The number of bytes written. + * Throws: + * - Any exception on error. + */ +duk_ret_t method_write(duk_context* ctx) +{ + std::FILE* fp = self(ctx)->handle(); + std::string data = duk_require_string(ctx, 0); + + if (fp == nullptr) + return 0; + + auto nwritten = std::fwrite(data.c_str(), 1, data.length(), fp); + + if (std::ferror(fp)) + dukx_throw(ctx, system_error()); + + duk_push_uint(ctx, nwritten); + + return 1; +} + +const duk_function_list_entry methods[] = { + { "basename", method_basename, 0 }, + { "close", method_close, 0 }, + { "dirname", method_dirname, 0 }, + { "lines", method_lines, 0 }, + { "read", method_read, 1 }, + { "readline", method_readline, 0 }, + { "remove", method_remove, 0 }, + { "seek", method_seek, 2 }, +#if defined(HAVE_STAT) + { "stat", method_stat, 0 }, +#endif + { "tell", method_tell, 0 }, + { "write", method_write, 1 }, + { nullptr, nullptr, 0 } +}; + +/* + * File "static" functions + * ------------------------------------------------------------------ + */ + +/* + * Function: Irccd.File(path, mode) [constructor] + * -------------------------------------------------------- + * + * Open a file specified by path with the specified mode. + * + * Arguments: + * - path, the path to the file, + * - mode, the mode string. + * Throws: + * - Any exception on error. + */ +duk_ret_t constructor(duk_context* ctx) +{ + if (!duk_is_constructor_call(ctx)) + return 0; + + try { + dukx_new_file(ctx, new file(duk_require_string(ctx, 0), duk_require_string(ctx, 1))); + } catch (const std::exception &) { + dukx_throw(ctx, system_error()); + } + + return 0; +} + +/* + * Function: Irccd.File() [destructor] + * ------------------------------------------------------------------ + * + * Delete the property. + */ +duk_ret_t destructor(duk_context* ctx) +{ + duk_get_prop_string(ctx, 0, signature); + delete static_cast(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + duk_del_prop_string(ctx, 0, signature); + + return 0; +} + +/* + * Function: Irccd.File.basename(path) + * -------------------------------------------------------- + * + * duk_ret_turn the file basename as specified in `basename(3)` C function. + * + * Arguments: + * - path, the path to the file. + * duk_ret_turns: + * The base name. + */ +duk_ret_t function_basename(duk_context* ctx) +{ + dukx_push_std_string(ctx, fs::baseName(duk_require_string(ctx, 0))); + + return 1; +} + +/* + * Function: Irccd.File.dirname(path) + * -------------------------------------------------------- + * + * duk_ret_turn the file directory name as specified in `dirname(3)` C function. + * + * Arguments: + * - path, the path to the file. + * duk_ret_turns: + * The directory name. + */ +duk_ret_t function_dirname(duk_context* ctx) +{ + dukx_push_std_string(ctx, fs::dirName(duk_require_string(ctx, 0))); + + return 1; +} + +/* + * Function: Irccd.File.exists(path) + * -------------------------------------------------------- + * + * Check if the file exists. + * + * Arguments: + * - path, the path to the file. + * duk_ret_turns: + * True if exists. + * Throws: + * - Any exception if we don't have access. + */ +duk_ret_t function_exists(duk_context* ctx) +{ + try { + duk_push_boolean(ctx, boost::filesystem::exists(duk_require_string(ctx, 0))); + } catch (...) { + duk_push_boolean(ctx, false); + } + + return 1; +} + +/* + * function Irccd.File.remove(path) + * -------------------------------------------------------- + * + * Remove the file at the specified path. + * + * Arguments: + * - path, the path to the file. + * Throws: + * - Any exception on error. + */ +duk_ret_t function_remove(duk_context* ctx) +{ + if (::remove(duk_require_string(ctx, 0)) < 0) + dukx_throw(ctx, system_error()); + + return 0; +} + +#if defined(HAVE_STAT) + +/* + * function Irccd.File.stat(path) [optional] + * -------------------------------------------------------- + * + * Get file information at the specified path. + * + * Arguments: + * - path, the path to the file. + * duk_ret_turns: + * The stat information. + * Throws: + * - Any exception on error. + */ +duk_ret_t function_stat(duk_context* ctx) +{ + struct stat st; + + if (::stat(duk_require_string(ctx, 0), &st) < 0) + dukx_throw(ctx, system_error()); + + push_stat(ctx, st); + + return 1; +} + +#endif // !HAVE_STAT + +const duk_function_list_entry functions[] = { + { "basename", function_basename, 1 }, + { "dirname", function_dirname, 1 }, + { "exists", function_exists, 1 }, + { "remove", function_remove, 1 }, +#if defined(HAVE_STAT) + { "stat", function_stat, 1 }, +#endif + { nullptr, nullptr, 0 } +}; + +const duk_number_list_entry constants[] = { + { "SeekCur", SEEK_CUR }, + { "SeekEnd", SEEK_END }, + { "SeekSet", SEEK_SET }, + { nullptr, 0 } +}; + +} // !namespace + +js_file_module::js_file_module() noexcept + : module("Irccd.File") +{ +} + +void js_file_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_c_function(plugin->context(), constructor, 2); + duk_put_number_list(plugin->context(), -1, constants); + duk_put_function_list(plugin->context(), -1, functions); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, methods); + duk_push_c_function(plugin->context(), destructor, 1); + duk_set_finalizer(plugin->context(), -2); + duk_dup(plugin->context(), -1); + duk_put_global_string(plugin->context(), prototype); + duk_put_prop_string(plugin->context(), -2, "prototype"); + duk_put_prop_string(plugin->context(), -2, "File"); + duk_pop(plugin->context()); +} + +void dukx_new_file(duk_context* ctx, file* fp) +{ + assert(ctx); + assert(fp); + + StackAssert sa(ctx); + + duk_push_this(ctx); + duk_push_pointer(ctx, fp); + duk_put_prop_string(ctx, -2, signature); + duk_pop(ctx); +} + +void dukx_push_file(duk_context* ctx, file* fp) +{ + assert(ctx); + assert(fp); + + StackAssert sa(ctx, 1); + + duk_push_object(ctx); + duk_push_pointer(ctx, fp); + duk_put_prop_string(ctx, -2, signature); + duk_get_global_string(ctx, prototype); + duk_set_prototype(ctx, -2); +} + +file* dukx_require_file(duk_context* ctx, duk_idx_t index) +{ + if (!duk_is_object(ctx, index) || !duk_has_prop_string(ctx, index, signature)) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a File object"); + + duk_get_prop_string(ctx, index, signature); + auto fp = static_cast(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + + return fp; +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_file_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_file_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,184 @@ +/* + * js_file_module.hpp -- Irccd.File API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_FILE_MODULE_HPP +#define IRCCD_JS_FILE_MODULE_HPP + +/** + * \file js_file_module.hpp + * \brief Irccd.File JavaScript API. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "duktape.hpp" +#include "module.hpp" + +namespace irccd { + +/** + * \brief Object for Javascript to perform I/O. + * + * This class can be constructed to Javascript. + * + * It is used in: + * + * - Irccd.File [constructor] + * - Irccd.System.popen (optional) + */ +class file { +private: + file(const file&) = delete; + file& operator=(const file&) = delete; + + file(file&&) = delete; + file& operator=(file&&) = delete; + +private: + std::string path_; + std::FILE *stream_; + std::function destructor_; + +public: + /** + * Construct a file specified by path + * + * \param path the path + * \param mode the mode string (for std::fopen) + * \throw std::runtime_error on failures + */ + inline file(std::string path, const std::string& mode) + : path_(std::move(path)) + , destructor_([] (std::FILE* fp) { std::fclose(fp); }) + { + if ((stream_ = std::fopen(path_.c_str(), mode.c_str())) == nullptr) + throw std::runtime_error(std::strerror(errno)); + } + + /** + * Construct a file from a already created FILE pointer (e.g. popen). + * + * The class takes ownership of fp and will close it. + * + * \pre destructor must not be null + * \param fp the file pointer + * \param destructor the function to close fp (e.g. std::fclose) + */ + inline file(std::FILE* fp, std::function destructor) noexcept + : stream_(fp) + , destructor_(std::move(destructor)) + { + assert(destructor_ != nullptr); + } + + /** + * Closes the file. + */ + virtual ~file() noexcept + { + close(); + } + + /** + * Get the path. + * + * \return the path + * \warning empty when constructed from the FILE constructor + */ + inline const std::string& path() const noexcept + { + return path_; + } + + /** + * Get the handle. + * + * \return the handle or nullptr if the stream was closed + */ + inline std::FILE* handle() noexcept + { + return stream_; + } + + /** + * Force close, can be safely called multiple times. + */ + inline void close() noexcept + { + if (stream_) { + destructor_(stream_); + stream_ = nullptr; + } + } +}; + +/** + * \brief Irccd.File JavaScript API. + * \ingroup modules + */ +class js_file_module : public module { +public: + /** + * Constructor. + */ + js_file_module() noexcept; + + /** + * \copydoc Module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +/** + * Construct the file as this. + * + * The object prototype takes ownership of fp and will be deleted once + * collected. + * + * \pre fp != nullptr + * \param ctx the the context + * \param fp the file + */ +IRCCD_EXPORT void dukx_new_file(duk_context* ctx, file* fp); + +/** + * Push a file. + * + * \pre fp != nullptr + * \param ctx the the context + * \param fp the file + */ +IRCCD_EXPORT void dukx_push_file(duk_context* ctx, file* fp); + +/** + * Require a file. Raises a JavaScript error if not a File. + * + * \param ctx the context + * \param index the index + */ +IRCCD_EXPORT file* dukx_require_file(duk_context* ctx, duk_idx_t index); + +} // !irccd + +#endif // !IRCCD_JS_FILE_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_irccd_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_irccd_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,232 @@ +/* + * js_irccd_module.cpp -- Irccd API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include + +#include +#include + +#include "js_irccd_module.hpp" + +namespace irccd { + +namespace { + +const std::unordered_map errors{ + { "E2BIG", E2BIG }, + { "EACCES", EACCES }, + { "EADDRINUSE", EADDRINUSE }, + { "EADDRNOTAVAIL", EADDRNOTAVAIL }, + { "EAFNOSUPPORT", EAFNOSUPPORT }, + { "EAGAIN", EAGAIN }, + { "EALREADY", EALREADY }, + { "EBADF", EBADF }, +#if defined(EBADMSG) + { "EBADMSG", EBADMSG }, +#endif + { "EBUSY", EBUSY }, + { "ECANCELED", ECANCELED }, + { "ECHILD", ECHILD }, + { "ECONNABORTED", ECONNABORTED }, + { "ECONNREFUSED", ECONNREFUSED }, + { "ECONNRESET", ECONNRESET }, + { "EDEADLK", EDEADLK }, + { "EDESTADDRREQ", EDESTADDRREQ }, + { "EDOM", EDOM }, + { "EEXIST", EEXIST }, + { "EFAULT", EFAULT }, + { "EFBIG", EFBIG }, + { "EHOSTUNREACH", EHOSTUNREACH }, +#if defined(EIDRM) + { "EIDRM", EIDRM }, +#endif + { "EILSEQ", EILSEQ }, + { "EINPROGRESS", EINPROGRESS }, + { "EINTR", EINTR }, + { "EINVAL", EINVAL }, + { "EIO", EIO }, + { "EISCONN", EISCONN }, + { "EISDIR", EISDIR }, + { "ELOOP", ELOOP }, + { "EMFILE", EMFILE }, + { "EMLINK", EMLINK }, + { "EMSGSIZE", EMSGSIZE }, + { "ENAMETOOLONG", ENAMETOOLONG }, + { "ENETDOWN", ENETDOWN }, + { "ENETRESET", ENETRESET }, + { "ENETUNREACH", ENETUNREACH }, + { "ENFILE", ENFILE }, + { "ENOBUFS", ENOBUFS }, +#if defined(ENODATA) + { "ENODATA", ENODATA }, +#endif + { "ENODEV", ENODEV }, + { "ENOENT", ENOENT }, + { "ENOEXEC", ENOEXEC }, + { "ENOLCK", ENOLCK }, +#if defined(ENOLINK) + { "ENOLINK", ENOLINK }, +#endif + { "ENOMEM", ENOMEM }, +#if defined(ENOMSG) + { "ENOMSG", ENOMSG }, +#endif + { "ENOPROTOOPT", ENOPROTOOPT }, + { "ENOSPC", ENOSPC }, +#if defined(ENOSR) + { "ENOSR", ENOSR }, +#endif +#if defined(ENOSTR) + { "ENOSTR", ENOSTR }, +#endif + { "ENOSYS", ENOSYS }, + { "ENOTCONN", ENOTCONN }, + { "ENOTDIR", ENOTDIR }, + { "ENOTEMPTY", ENOTEMPTY }, +#if defined(ENOTRECOVERABLE) + { "ENOTRECOVERABLE", ENOTRECOVERABLE }, +#endif + { "ENOTSOCK", ENOTSOCK }, + { "ENOTSUP", ENOTSUP }, + { "ENOTTY", ENOTTY }, + { "ENXIO", ENXIO }, + { "EOPNOTSUPP", EOPNOTSUPP }, + { "EOVERFLOW", EOVERFLOW }, + { "EOWNERDEAD", EOWNERDEAD }, + { "EPERM", EPERM }, + { "EPIPE", EPIPE }, + { "EPROTO", EPROTO }, + { "EPROTONOSUPPORT", EPROTONOSUPPORT }, + { "EPROTOTYPE", EPROTOTYPE }, + { "ERANGE", ERANGE }, + { "EROFS", EROFS }, + { "ESPIPE", ESPIPE }, + { "ESRCH", ESRCH }, +#if defined(ETIME) + { "ETIME", ETIME }, +#endif + { "ETIMEDOUT", ETIMEDOUT }, +#if defined(ETXTBSY) + { "ETXTBSY", ETXTBSY }, +#endif + { "EWOULDBLOCK", EWOULDBLOCK }, + { "EXDEV", EXDEV } +}; + +duk_ret_t constructor(duk_context* ctx) +{ + duk_push_this(ctx); + duk_push_int(ctx, duk_require_int(ctx, 0)); + duk_put_prop_string(ctx, -2, "errno"); + duk_push_string(ctx, duk_require_string(ctx, 1)); + duk_put_prop_string(ctx, -2, "message"); + duk_push_string(ctx, "SystemError"); + duk_put_prop_string(ctx, -2, "name"); + duk_pop(ctx); + + return 0; +} + +} // !namespace + +system_error::system_error() + : errno_(errno) + , message_(std::strerror(errno_)) +{ +} + +system_error::system_error(int e, std::string message) + : errno_(e) + , message_(std::move(message)) +{ +} + +void system_error::raise(duk_context *ctx) const +{ + StackAssert sa(ctx, 0); + + duk_get_global_string(ctx, "Irccd"); + duk_get_prop_string(ctx, -1, "SystemError"); + duk_remove(ctx, -2); + duk_push_int(ctx, errno_); + dukx_push_std_string(ctx, message_); + duk_new(ctx, 2); + duk_throw(ctx); +} + +js_irccd_module::js_irccd_module() noexcept + : module("Irccd") +{ +} + +void js_irccd_module::load(irccd& irccd, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + // irccd. + duk_push_object(plugin->context()); + + // Version. + duk_push_object(plugin->context()); + duk_push_int(plugin->context(), IRCCD_VERSION_MAJOR); + duk_put_prop_string(plugin->context(), -2, "major"); + duk_push_int(plugin->context(), IRCCD_VERSION_MINOR); + duk_put_prop_string(plugin->context(), -2, "minor"); + duk_push_int(plugin->context(), IRCCD_VERSION_PATCH); + duk_put_prop_string(plugin->context(), -2, "patch"); + duk_put_prop_string(plugin->context(), -2, "version"); + + // Create the system_error that inherits from Error. + duk_push_c_function(plugin->context(), constructor, 2); + + // Put errno codes into the irccd.system_error object. + for (const auto& pair : errors) { + duk_push_int(plugin->context(), pair.second); + duk_put_prop_string(plugin->context(), -2, pair.first.c_str()); + } + + duk_push_object(plugin->context()); + duk_get_global_string(plugin->context(), "Error"); + duk_get_prop_string(plugin->context(), -1, "prototype"); + duk_remove(plugin->context(), -2); + duk_set_prototype(plugin->context(), -2); + duk_put_prop_string(plugin->context(), -2, "prototype"); + duk_put_prop_string(plugin->context(), -2, "SystemError"); + + // Set irccd as global. + duk_put_global_string(plugin->context(), "Irccd"); + + // Store global instance. + duk_push_pointer(plugin->context(), &irccd); + duk_put_global_string(plugin->context(), "\xff""\xff""irccd-ref"); +} + +irccd& dukx_get_irccd(duk_context *ctx) +{ + StackAssert sa(ctx); + + duk_get_global_string(ctx, "\xff""\xff""irccd-ref"); + auto ptr = static_cast(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + + return *ptr; +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_irccd_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_irccd_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,93 @@ +/* + * js_irccd_module.hpp -- Irccd API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_IRCCD_MODULE_HPP +#define IRCCD_JS_IRCCD_MODULE_HPP + +/** + * \file js_irccd_module.hpp + * \brief irccd JavaScript API. + */ + +#include +#include +#include + +#include "duktape.hpp" +#include "module.hpp" + +namespace irccd { + +/** + * \brief Custom JavaScript exception for system error. + */ +class system_error { +private: + int errno_; + std::string message_; + +public: + /** + * Create a system error from the current errno value. + */ + system_error(); + + /** + * Create a system error with the given errno and message. + * + * \param e the errno number + * \param message the message + */ + system_error(int e, std::string message); + + /** + * Raise the SystemError Javascript exception. + * + * \param ctx the context + */ + void raise(duk_context* ctx) const; +}; + +/** + * \brief Irccd JavaScript API. + * \ingroup modules + */ +class js_irccd_module : public module { +public: + /** + * Constructor. + */ + js_irccd_module() noexcept; + + /** + * \copydoc module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +/** + * Get irccd instance stored in this context. + * + * \param ctx the context + * \return the irccd reference + */ +irccd& dukx_get_irccd(duk_context* ctx); + +} // !irccd + +#endif // !IRCCD_JS_IRCCD_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_logger_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_logger_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,103 @@ +/* + * js_logger_module.cpp -- Irccd.Logger API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include "js_plugin.hpp" +#include "js_logger_module.hpp" +#include "js_plugin_module.hpp" + +namespace irccd { + +namespace { + +duk_ret_t print(duk_context* ctx, std::ostream &out) +{ + out << "plugin " << dukx_get_plugin(ctx)->name() << ": " << duk_require_string(ctx, 0) << std::endl; + + return 0; +} + +/* + * Function: Irccd.Logger.info(message) + * -------------------------------------------------------- + * + * Write a verbose message. + * + * Arguments: + * - message, the message. + */ +duk_ret_t info(duk_context* ctx) +{ + return print(ctx, log::info()); +} + +/* + * Function: irccd.Logger.warning(message) + * -------------------------------------------------------- + * + * Write a warning message. + * + * Arguments: + * - message, the warning. + */ +duk_ret_t warning(duk_context* ctx) +{ + return print(ctx, log::warning()); +} + +/* + * Function: Logger.debug(message) + * -------------------------------------------------------- + * + * Write a debug message, only shown if irccd is compiled in debug. + * + * Arguments: + * - message, the message. + */ +duk_ret_t debug(duk_context* ctx) +{ + return print(ctx, log::debug()); +} + +const duk_function_list_entry functions[] = { + { "info", info, 1 }, + { "warning", warning, 1 }, + { "debug", debug, 1 }, + { nullptr, nullptr, 0 } +}; + +} // !namespace + +js_logger_module::js_logger_module() noexcept + : module("Irccd.Logger") +{ +} + +void js_logger_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, functions); + duk_put_prop_string(plugin->context(), -2, "Logger"); + duk_pop(plugin->context()); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_logger_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_logger_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,50 @@ +/* + * js_logger_module.hpp -- Irccd.Logger API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_LOGGER_MODULE_HPP +#define IRCCD_JS_LOGGER_MODULE_HPP + +/** + * \file js_logger_module.hpp + * \brief Irccd.Logger JavaScript API. + */ + +#include "module.hpp" + +namespace irccd { + +/** + * \brief irccd.Logger JavaScript API. + * \ingroup modules + */ +class js_logger_module : public module { +public: + /** + * Constructor. + */ + js_logger_module() noexcept; + + /** + * \copydoc Module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +} // !irccd + +#endif // !IRCCD_JS_LOGGER_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_plugin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_plugin.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,434 @@ +/* + * plugin-js.cpp -- JavaScript plugins for irccd + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include "sysconfig.hpp" + +#if defined(HAVE_STAT) +# include +# include +# include +#endif + +#include "fs.hpp" +#include "irccd.hpp" +#include "logger.hpp" +#include "js_plugin_module.hpp" +#include "js_server_module.hpp" +#include "js_plugin.hpp" +#include "service.hpp" +#include "timer.hpp" + +namespace irccd { + +const std::string js_plugin::config_property{"\xff""\xff""irccd-plugin-config"}; +const std::string js_plugin::format_property{"\xff""\xff""irccd-plugin-format"}; +const std::string js_plugin::paths_property{"\xff""\xff""irccd-plugin-paths"}; + +std::unordered_map js_plugin::get_table(const std::string& name) const +{ + StackAssert sa(context_); + std::unordered_map result; + + duk_get_global_string(context_, name.c_str()); + dukx_enumerate(context_, -1, 0, true, [&] (auto ctx) { + result.emplace(duk_to_string(ctx, -2), duk_to_string(ctx, -1)); + }); + duk_pop(context_); + + return result; +} + +void js_plugin::put_table(const std::string& name, const std::unordered_map& vars) +{ + StackAssert sa(context_); + + duk_get_global_string(context_, name.c_str()); + + for (const auto &pair : vars) { + dukx_push_std_string(context_, pair.second); + duk_put_prop_string(context_, -2, pair.first.c_str()); + } + + duk_pop(context_); +} + +void js_plugin::call(const std::string& name, unsigned nargs) +{ + duk_get_global_string(context_, name.c_str()); + + if (duk_get_type(context_, -1) == DUK_TYPE_UNDEFINED) + // Function not defined, remove the undefined value and all arguments. + duk_pop_n(context_, nargs + 1); + else { + // Call the function and discard the result. + duk_insert(context_, -nargs - 1); + + if (duk_pcall(context_, nargs) != 0) + throw dukx_exception(context_, -1, true); + + duk_pop(context_); + } +} + +void js_plugin::put_vars() +{ + StackAssert sa(context_); + + duk_push_pointer(context_, this); + duk_put_global_string(context_, "\xff""\xff""plugin"); + dukx_push_std_string(context_, name()); + duk_put_global_string(context_, "\xff""\xff""name"); + dukx_push_std_string(context_, path()); + duk_put_global_string(context_, "\xff""\xff""path"); +} + +js_plugin::js_plugin(std::string name, std::string path) + : plugin(name, path) +{ + /* + * Create two special tables for configuration and formats, they are + * referenced later as + * + * - irccd.Plugin.config + * - irccd.Plugin.format + * - irccd.Plugin.paths + * + * In js_plugin_module.cpp. + */ + duk_push_object(context_); + duk_put_global_string(context_, config_property.c_str()); + duk_push_object(context_); + duk_put_global_string(context_, format_property.c_str()); + duk_push_object(context_); + duk_put_global_string(context_, paths_property.c_str()); + + // Used by many Javascript APIs. + duk_push_object(context_); + duk_put_global_string(context_, "irccd"); +} + +void js_plugin::on_channel_mode(irccd &, const channel_mode_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.mode); + dukx_push_std_string(context_, event.argument); + call("onChannelMode", 5); +} + +void js_plugin::on_channel_notice(irccd &, const channel_notice_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.message); + call("onChannelNotice", 4); +} + +void js_plugin::on_command(irccd &, const message_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.message); + call("onCommand", 4); +} + +void js_plugin::on_connect(irccd &, const connect_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + call("onConnect", 1); +} + +void js_plugin::on_invite(irccd &, const invite_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + call("onInvite", 3); +} + +void js_plugin::on_join(irccd &, const join_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + call("onJoin", 3); +} + +void js_plugin::on_kick(irccd &, const kick_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.target); + dukx_push_std_string(context_, event.reason); + call("onKick", 5); +} + +void js_plugin::on_load(irccd &irccd) +{ + StackAssert sa(context_); + + /* + * Duktape currently emit useless warnings when a file do + * not exists so we do a homemade access. + */ +#if defined(HAVE_STAT) + struct stat st; + + if (::stat(path().c_str(), &st) < 0) + throw std::runtime_error(std::strerror(errno)); +#endif + + // Try to load the file (does not call onLoad yet). + dukx_peval_file(context_, path()); + duk_pop(context_); + + /* + * We put configuration and formats after loading the file and before + * calling onLoad to allow the plugin adding configuration to + * irccd.Plugin.(config|format) before the user. + */ + put_vars(); + set_config(irccd.plugins().config(name())); + set_formats(irccd.plugins().formats(name())); + set_paths(irccd.plugins().paths(name())); + + // Read metadata . + duk_get_global_string(context_, "info"); + + if (duk_get_type(context_, -1) == DUK_TYPE_OBJECT) { + // 'author' + duk_get_prop_string(context_, -1, "author"); + set_author(duk_is_string(context_, -1) ? duk_get_string(context_, -1) : author()); + duk_pop(context_); + + // 'license' + duk_get_prop_string(context_, -1, "license"); + set_license(duk_is_string(context_, -1) ? duk_get_string(context_, -1) : license()); + duk_pop(context_); + + // 'summary' + duk_get_prop_string(context_, -1, "summary"); + set_summary(duk_is_string(context_, -1) ? duk_get_string(context_, -1) : summary()); + duk_pop(context_); + + // 'version' + duk_get_prop_string(context_, -1, "version"); + set_version(duk_is_string(context_, -1) ? duk_get_string(context_, -1) : version()); + duk_pop(context_); + } + + duk_pop(context_); + call("onLoad", 0); +} + +void js_plugin::on_message(irccd &, const message_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.message); + call("onMessage", 4); +} + +void js_plugin::on_me(irccd &, const me_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.message); + call("onMe", 4); +} + +void js_plugin::on_mode(irccd &, const mode_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.mode); + call("onMode", 3); +} + +void js_plugin::on_names(irccd &, const names_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.channel); + dukx_push_array(context_, event.names, dukx_push_std_string); + call("onNames", 3); +} + +void js_plugin::on_nick(irccd &, const nick_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.nickname); + call("onNick", 3); +} + +void js_plugin::on_notice(irccd &, const notice_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.message); + call("onNotice", 3); +} + +void js_plugin::on_part(irccd &, const part_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.reason); + call("onPart", 4); +} + +void js_plugin::on_query(irccd &, const query_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.message); + call("onQuery", 3); +} + +void js_plugin::on_query_command(irccd &, const query_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.message); + call("onQueryCommand", 3); +} + +void js_plugin::on_reload(irccd &) +{ + StackAssert sa(context_); + + call("onReload"); +} + +void js_plugin::on_topic(irccd &, const topic_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + dukx_push_std_string(context_, event.origin); + dukx_push_std_string(context_, event.channel); + dukx_push_std_string(context_, event.topic); + call("onTopic", 4); +} + +void js_plugin::on_unload(irccd &) +{ + StackAssert sa(context_); + + call("onUnload"); +} + +void js_plugin::on_whois(irccd &, const whois_event &event) +{ + StackAssert sa(context_); + + dukx_push_server(context_, std::move(event.server)); + duk_push_object(context_); + dukx_push_std_string(context_, event.whois.nick); + duk_put_prop_string(context_, -2, "nickname"); + dukx_push_std_string(context_, event.whois.user); + duk_put_prop_string(context_, -2, "username"); + dukx_push_std_string(context_, event.whois.realname); + duk_put_prop_string(context_, -2, "realname"); + dukx_push_std_string(context_, event.whois.host); + duk_put_prop_string(context_, -2, "host"); + dukx_push_array(context_, event.whois.channels, dukx_push_std_string); + duk_put_prop_string(context_, -2, "channels"); + call("onWhois", 2); +} + +js_plugin_loader::js_plugin_loader(irccd &irccd) noexcept + : plugin_loader({}, { ".js" }) + , irccd_(irccd) +{ +} + +js_plugin_loader::~js_plugin_loader() noexcept = default; + +void js_plugin_loader::add_module(std::unique_ptr module) +{ + assert(module); + + modules_.push_back(std::move(module)); +} + +std::shared_ptr js_plugin_loader::open(const std::string& id, + const std::string& path) noexcept +{ + if (path.rfind(".js") == std::string::npos) + return nullptr; + + try { + auto plugin = std::make_shared(id, path); + + for (const auto& mod : modules_) { + log::debug() << "plugin " << plugin->name() << ": "; + log::debug() << "loading " << mod->name() << " Javascript API" << std::endl; + mod->load(irccd_, plugin); + } + + return plugin; + } catch (const std::exception &ex) { + log::warning() << "plugin " << id << ": " << ex.what() << std::endl; + } + + return nullptr; +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_plugin.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_plugin.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,277 @@ +/* + * js_plugin.hpp -- JavaScript plugins for irccd + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_PLUGIN_HPP +#define IRCCD_JS_PLUGIN_HPP + +/** + * \file js_plugin.hpp + * \brief JavaScript plugins for irccd. + */ + +#include + +#include "duktape.hpp" +#include "plugin.hpp" + +namespace irccd { + +class module; + +/** + * \brief JavaScript plugins for irccd. + * \ingroup plugins + */ +class js_plugin : public plugin { +public: + /** + * Global property where to read/write plugin configuration (object). + */ + static const std::string config_property; + + /** + * Global property where to read/write plugin formats (object). + */ + static const std::string format_property; + + /** + * Global property where paths are defined (object). + */ + static const std::string paths_property; + +private: + // JavaScript context + UniqueContext context_; + + // Private helpers. + std::unordered_map get_table(const std::string&) const; + void put_table(const std::string&, const std::unordered_map&); + void call(const std::string&, unsigned = 0); + void put_vars(); + +public: + /** + * Constructor. + * + * \param name the plugin name + * \param path the path to the plugin + */ + js_plugin(std::string name, std::string path); + + /** + * Access the Duktape context. + * + * \return the context + */ + inline UniqueContext& context() noexcept + { + return context_; + } + + /** + * \copydoc Plugin::config + */ + plugin_config config() override + { + return get_table(config_property); + } + + /** + * \copydoc Plugin::setConfig + */ + void set_config(plugin_config config) override + { + put_table(config_property, config); + } + + /** + * \copydoc Plugin::formats + */ + plugin_formats formats() override + { + return get_table(format_property); + } + + /** + * \copydoc Plugin::setFormats + */ + void set_formats(plugin_formats formats) override + { + put_table(format_property, formats); + } + + /** + * \copydoc Plugin::paths + */ + plugin_paths paths() override + { + return get_table(paths_property); + } + + /** + * \copydoc Plugin::set_paths + */ + void set_paths(plugin_paths paths) override + { + put_table(paths_property, std::move(paths)); + } + + /** + * \copydoc Plugin::on_command + */ + void on_command(irccd& irccd, const message_event& event) override; + + /** + * \copydoc Plugin::on_connect + */ + void on_connect(irccd& irccd, const connect_event& event) override; + + /** + * \copydoc Plugin::on_channel_mode + */ + void on_channel_mode(irccd& irccd, const channel_mode_event& event) override; + + /** + * \copydoc Plugin::on_channel_notice + */ + void on_channel_notice(irccd& irccd, const channel_notice_event& event) override; + + /** + * \copydoc Plugin::on_invite + */ + void on_invite(irccd& irccd, const invite_event& event) override; + + /** + * \copydoc Plugin::on_join + */ + void on_join(irccd& irccd, const join_event& event) override; + + /** + * \copydoc Plugin::on_kick + */ + void on_kick(irccd& irccd, const kick_event& event) override; + + /** + * \copydoc Plugin::on_load + */ + void on_load(irccd& irccd) override; + + /** + * \copydoc Plugin::on_message + */ + void on_message(irccd& irccd, const message_event& event) override; + + /** + * \copydoc Plugin::on_me + */ + void on_me(irccd& irccd, const me_event& event) override; + + /** + * \copydoc Plugin::on_mode + */ + void on_mode(irccd& irccd, const mode_event& event) override; + + /** + * \copydoc Plugin::on_names + */ + void on_names(irccd& irccd, const names_event& event) override; + + /** + * \copydoc Plugin::on_nick + */ + void on_nick(irccd& irccd, const nick_event& event) override; + + /** + * \copydoc Plugin::on_notice + */ + void on_notice(irccd& irccd, const notice_event& event) override; + + /** + * \copydoc Plugin::on_part + */ + void on_part(irccd& irccd, const part_event& event) override; + + /** + * \copydoc Plugin::on_query + */ + void on_query(irccd& irccd, const query_event& event) override; + + /** + * \copydoc Plugin::on_query_command + */ + void on_query_command(irccd& irccd, const query_event& event) override; + + /** + * \copydoc Plugin::on_reload + */ + void on_reload(irccd& irccd) override; + + /** + * \copydoc Plugin::on_topic + */ + void on_topic(irccd& irccd, const topic_event& event) override; + + /** + * \copydoc Plugin::on_unload + */ + void on_unload(irccd& irccd) override; + + /** + * \copydoc Plugin::on_whois + */ + void on_whois(irccd& irccd, const whois_event& event) override; +}; + +/** + * \brief Implementation for searching Javascript plugins. + */ +class js_plugin_loader : public plugin_loader { +private: + irccd& irccd_; + std::vector> modules_; + +public: + /** + * Constructor. + * + * \param irccd the irccd instance + */ + js_plugin_loader(irccd& irccd) noexcept; + + /** + * Destructor defaulted. + */ + ~js_plugin_loader() noexcept; + + /** + * Register a new module for loading new plugins. + * + * \param module the module to add + */ + void add_module(std::unique_ptr module); + + /** + * \copydoc PluginLoader::open + */ + std::shared_ptr open(const std::string& id, + const std::string& path) noexcept override; +}; + +} // !irccd + +#endif // !IRCCD_PLUGIN_JS_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_plugin_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_plugin_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,385 @@ +/* + * js_plugin_module.cpp -- Irccd.Plugin API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include + +#include "js_irccd_module.hpp" +#include "js_plugin.hpp" +#include "js_plugin_module.hpp" + +namespace irccd { + +namespace { + +const char plugin_ref[] = "\xff""\xff""irccd-plugin-ptr"; + +/* + * wrap + * ------------------------------------------------------------------ + * + * Wrap function for these functions because they all takes the same arguments. + * + * - load, + * - reload, + * - unload. + */ +template +duk_idx_t wrap(duk_context* ctx, int nret, Func&& func) +{ + std::string name = duk_require_string(ctx, 0); + + try { + func(dukx_get_irccd(ctx), name); + } catch (const std::out_of_range &ex) { + dukx_throw(ctx, ReferenceError(ex.what())); + } catch (const std::exception &ex) { + dukx_throw(ctx, Error(ex.what())); + } + + return nret; +} + +/* + * set + * ------------------------------------------------------------------ + * + * This setter is used to replace the Irccd.Plugin.(config|format|paths) + * property when the plugin assign a new one. + * + * Because the plugin configuration always has higher priority, when a new + * object is assigned to 'config' or to the 'format' property, the plugin + * configuration is merged to the assigned one, adding or replacing any values. + * + * Example: + * + * Plugin 'xyz' does: + * + * Irccd.Plugin.config = { + * mode: "simple", + * level: "123" + * }; + * + * The user configuration is: + * + * [plugin.xyz] + * mode = "hard" + * path = "/var" + * + * The final user table looks like this: + * + * Irccd.Plugin.Config = { + * mode: "hard", + * level: "123", + * path: "/var" + * }; + */ +duk_ret_t set(duk_context* ctx, const std::string& name) +{ + if (!duk_is_object(ctx, 0)) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "'%s' property must be object", name.c_str()); + + // Merge old table with new one. + duk_get_global_string(ctx, name.c_str()); + duk_enum(ctx, -1, 0); + + while (duk_next(ctx, -1, true)) + duk_put_prop(ctx, 0); + + // Pop enum and old table. + duk_pop_2(ctx); + + // Replace the old table with the new assigned one. + duk_put_global_string(ctx, name.c_str()); + + return 0; +} + +/* + * get + * ------------------------------------------------------------------ + * + * Get the Irccd.Plugin.(config|format|paths) property. + */ +duk_ret_t get(duk_context* ctx, const std::string& name) +{ + duk_get_global_string(ctx, name.c_str()); + + return 1; +} + +/* + * set_config + * ------------------------------------------------------------------ + * + * Wrap setter for Irccd.Plugin.config property. + */ +duk_ret_t set_config(duk_context* ctx) +{ + return set(ctx, js_plugin::config_property); +} + +/* + * get_config + * ------------------------------------------------------------------ + * + * Wrap getter for Irccd.Plugin.config property. + */ +duk_ret_t get_config(duk_context* ctx) +{ + return get(ctx, js_plugin::config_property); +} + +/* + * set_format + * ------------------------------------------------------------------ + * + * Wrap setter for Irccd.Plugin.format property. + */ +duk_ret_t set_format(duk_context* ctx) +{ + return set(ctx, js_plugin::format_property); +} + +/* + * get_format + * ------------------------------------------------------------------ + * + * Wrap getter for Irccd.Plugin.format property. + */ +duk_ret_t get_format(duk_context* ctx) +{ + return get(ctx, js_plugin::format_property); +} + +/* + * set_paths + * ------------------------------------------------------------------ + * + * Wrap setter for Irccd.Plugin.format property. + */ +duk_ret_t set_paths(duk_context* ctx) +{ + return set(ctx, js_plugin::paths_property); +} + +/* + * get_paths + * ------------------------------------------------------------------ + * + * Wrap getter for Irccd.Plugin.format property. + */ +duk_ret_t get_paths(duk_context* ctx) +{ + return get(ctx, js_plugin::paths_property); +} + +/* + * Function: Irccd.Plugin.info([name]) + * ------------------------------------------------------------------ + * + * Get information about a plugin. + * + * The returned object as the following properties: + * + * - name: (string) the plugin identifier, + * - author: (string) the author, + * - license: (string) the license, + * - summary: (string) a short description, + * - version: (string) the version + * + * Arguments: + * - name, the plugin identifier, if not specified the current plugin is + * selected. + * Returns: + * The plugin information or undefined if the plugin was not found. + */ +duk_idx_t info(duk_context* ctx) +{ + std::shared_ptr plugin; + + if (duk_get_top(ctx) >= 1) + plugin = dukx_get_irccd(ctx).plugins().get(duk_require_string(ctx, 0)); + else + plugin = dukx_get_plugin(ctx); + + if (!plugin) + return 0; + + duk_push_object(ctx); + dukx_push_std_string(ctx, plugin->name()); + duk_put_prop_string(ctx, -2, "name"); + dukx_push_std_string(ctx, plugin->author()); + duk_put_prop_string(ctx, -2, "author"); + dukx_push_std_string(ctx, plugin->license()); + duk_put_prop_string(ctx, -2, "license"); + dukx_push_std_string(ctx, plugin->summary()); + duk_put_prop_string(ctx, -2, "summary"); + dukx_push_std_string(ctx, plugin->version()); + duk_put_prop_string(ctx, -2, "version"); + + return 1; +} + +/* + * Function: Irccd.Plugin.list() + * ------------------------------------------------------------------ + * + * Get the list of plugins, the array returned contains all plugin names. + * + * Returns: + * The list of all plugin names. + */ +duk_idx_t list(duk_context* ctx) +{ + dukx_push_array(ctx, dukx_get_irccd(ctx).plugins().list(), [] (auto ctx, auto plugin) { + dukx_push_std_string(ctx, plugin->name()); + }); + + return 1; +} + +/* + * Function: Irccd.Plugin.load(name) + * ------------------------------------------------------------------ + * + * Load a plugin by name. This function will search through the standard + * directories. + * + * Arguments: + * - name, the plugin identifier. + * Throws: + * - Error on errors, + * - ReferenceError if the plugin was not found. + */ +duk_idx_t load(duk_context* ctx) +{ + return wrap(ctx, 0, [&] (irccd &irccd, const std::string &name) { + irccd.plugins().load(name); + }); +} + +/* + * Function: Irccd.Plugin.reload(name) + * ------------------------------------------------------------------ + * + * Reload a plugin by name. + * + * Arguments: + * - name, the plugin identifier. + * Throws: + * - Error on errors, + * - ReferenceError if the plugin was not found. + */ +duk_idx_t reload(duk_context* ctx) +{ + return wrap(ctx, 0, [&] (irccd &irccd, const std::string &name) { + irccd.plugins().reload(name); + }); +} + +/* + * Function: Irccd.Plugin.unload(name) + * ------------------------------------------------------------------ + * + * Unload a plugin by name. + * + * Arguments: + * - name, the plugin identifier. + * Throws: + * - Error on errors, + * - ReferenceError if the plugin was not found. + */ +duk_idx_t unload(duk_context* ctx) +{ + return wrap(ctx, 0, [&] (irccd &irccd, const std::string &name) { + irccd.plugins().unload(name); + }); +} + +const duk_function_list_entry functions[] = { + { "info", info, DUK_VARARGS }, + { "list", list, 0 }, + { "load", load, 1 }, + { "reload", reload, 1 }, + { "unload", unload, 1 }, + { nullptr, nullptr, 0 } +}; + +} // !namespace + +js_plugin_module::js_plugin_module() noexcept + : module("Irccd.Plugin") +{ +} + +void js_plugin_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_push_pointer(plugin->context(), new std::weak_ptr(plugin)); + duk_push_object(plugin->context()); + duk_push_c_function(plugin->context(), [] (auto ctx) -> duk_ret_t { + duk_get_global_string(ctx, plugin_ref); + delete static_cast*>(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + duk_push_null(ctx); + duk_put_global_string(ctx, plugin_ref); + return 0; + }, 1); + duk_set_finalizer(plugin->context(), -2); + duk_put_global_string(plugin->context(), "\xff""\xff""dummy-shared-ptr"); + duk_put_global_string(plugin->context(), plugin_ref); + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, functions); + + // 'config' property. + duk_push_string(plugin->context(), "config"); + duk_push_c_function(plugin->context(), get_config, 0); + duk_push_c_function(plugin->context(), set_config, 1); + duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER); + + // 'format' property. + duk_push_string(plugin->context(), "format"); + duk_push_c_function(plugin->context(), get_format, 0); + duk_push_c_function(plugin->context(), set_format, 1); + duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER); + + // 'format' property. + duk_push_string(plugin->context(), "paths"); + duk_push_c_function(plugin->context(), get_paths, 0); + duk_push_c_function(plugin->context(), set_paths, 1); + duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER); + + duk_put_prop_string(plugin->context(), -2, "Plugin"); + duk_pop(plugin->context()); +} + +std::shared_ptr dukx_get_plugin(duk_context* ctx) +{ + StackAssert sa(ctx); + + duk_get_global_string(ctx, plugin_ref); + auto plugin = static_cast*>(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + + return plugin->lock(); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_plugin_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_plugin_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,59 @@ +/* + * js_plugin_module.hpp -- Irccd.Plugin API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_PLUGIN_MODULE_HPP +#define IRCCD_JS_PLUGIN_MODULE_HPP + +/** + * \file js_plugin_module.hpp + * \brief Irccd.Plugin JavaScript API. + */ + +#include "duktape.hpp" +#include "module.hpp" + +namespace irccd { + +/** + * \brief Irccd.Plugin JavaScript API. + * \ingroup modules + */ +class js_plugin_module : public module { +public: + /** + * Irccd.Plugin. + */ + js_plugin_module() noexcept; + + /** + * \copydoc Module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +/** + * Access the plugin stored in this context. + * + * \param ctx the context + * \return the plugin + */ +std::shared_ptr dukx_get_plugin(duk_context* ctx); + +} // !irccd + +#endif // !IRCCD_JS_PLUGIN_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_server_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_server_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,581 @@ +/* + * js_server_module.cpp -- Irccd.Server API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include "js_irccd_module.hpp" +#include "js_server_module.hpp" + +namespace irccd { + +namespace { + +const char *signature("\xff""\xff""irccd-server-ptr"); +const char *prototype("\xff""\xff""irccd-server-prototype"); + +std::shared_ptr self(duk_context* ctx) +{ + StackAssert sa(ctx); + + duk_push_this(ctx); + duk_get_prop_string(ctx, -1, signature); + auto ptr = duk_to_pointer(ctx, -1); + duk_pop_2(ctx); + + if (!ptr) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object"); + + return *static_cast*>(ptr); +} + +/* + * Method: Server.cmode(channel, mode) + * ------------------------------------------------------------------ + * + * Change a channel mode. + * + * Arguments: + * - channel, the channel, + * - mode, the mode. + */ +duk_ret_t cmode(duk_context* ctx) +{ + self(ctx)->cmode(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.cnotice(channel, message) + * ------------------------------------------------------------------ + * + * Send a channel notice. + * + * Arguments: + * - channel, the channel, + * - message, the message. + */ +duk_ret_t cnotice(duk_context* ctx) +{ + self(ctx)->cnotice(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.info() + * ------------------------------------------------------------------ + * + * Get the server information as an object containing the following properties: + * + * name: the server unique name + * host: the host name + * port: the port number + * ssl: true if using ssl + * sslVerify: true if ssl was verified + * channels: an array of all channels + */ +duk_ret_t info(duk_context* ctx) +{ + auto server = self(ctx); + + duk_push_object(ctx); + dukx_push_std_string(ctx, server->name()); + duk_put_prop_string(ctx, -2, "name"); + dukx_push_std_string(ctx, server->host()); + duk_put_prop_string(ctx, -2, "host"); + duk_push_int(ctx, server->port()); + duk_put_prop_string(ctx, -2, "port"); + duk_push_boolean(ctx, server->flags() & server::ssl); + duk_put_prop_string(ctx, -2, "ssl"); + duk_push_boolean(ctx, server->flags() & server::ssl_verify); + duk_put_prop_string(ctx, -2, "sslVerify"); + dukx_push_std_string(ctx, server->command_char()); + duk_put_prop_string(ctx, -2, "commandChar"); + dukx_push_std_string(ctx, server->realname()); + duk_put_prop_string(ctx, -2, "realname"); + dukx_push_std_string(ctx, server->nickname()); + duk_put_prop_string(ctx, -2, "nickname"); + dukx_push_std_string(ctx, server->username()); + duk_put_prop_string(ctx, -2, "username"); + dukx_push_array(ctx, server->channels(), [&] (auto ctx, auto channel) { + dukx_push_std_string(ctx, channel); + }); + duk_put_prop_string(ctx, -2, "channels"); + + return 1; +} + +/* + * Method: Server.invite(target, channel) + * ------------------------------------------------------------------ + * + * Invite someone to a channel. + * + * Arguments: + * - target, the target to invite, + * - channel, the channel. + */ +duk_ret_t invite(duk_context* ctx) +{ + self(ctx)->invite(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.join(channel, password = undefined) + * ------------------------------------------------------------------ + * + * Join a channel with an optional password. + * + * Arguments: + * - channel, the channel to join, + * - password, the password or undefined to not use. + */ +duk_ret_t join(duk_context* ctx) +{ + self(ctx)->join(duk_require_string(ctx, 0), dukx_get_std_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.kick(target, channel, reason = undefined) + * ------------------------------------------------------------------ + * + * Kick someone from a channel. + * + * Arguments: + * - target, the target to kick, + * - channel, the channel, + * - reason, the optional reason or undefined to not set. + */ +duk_ret_t kick(duk_context* ctx) +{ + self(ctx)->kick(duk_require_string(ctx, 0), duk_require_string(ctx, 1), dukx_get_std_string(ctx, 2)); + + return 0; +} + +/* + * Method: Server.me(target, message) + * ------------------------------------------------------------------ + * + * Send a CTCP Action. + * + * Arguments: + * - target, the target or a channel, + * - message, the message. + */ +duk_ret_t me(duk_context* ctx) +{ + self(ctx)->me(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.message(target, message) + * ------------------------------------------------------------------ + * + * Send a message. + * + * Arguments: + * - target, the target or a channel, + * - message, the message. + */ +duk_ret_t message(duk_context* ctx) +{ + self(ctx)->message(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.mode(mode) + * ------------------------------------------------------------------ + * + * Change your mode. + * + * Arguments: + * - mode, the new mode. + */ +duk_ret_t mode(duk_context* ctx) +{ + self(ctx)->mode(duk_require_string(ctx, 0)); + + return 0; +} + +/* + * Method: Server.names(channel) + * ------------------------------------------------------------------ + * + * Get the list of names from a channel. + * + * Arguments: + * - channel, the channel. + */ +duk_ret_t names(duk_context* ctx) +{ + self(ctx)->names(duk_require_string(ctx, 0)); + + return 0; +} + +/* + * Method: Server.nick(nickname) + * ------------------------------------------------------------------ + * + * Change the nickname. + * + * Arguments: + * - nickname, the nickname. + */ +duk_ret_t nick(duk_context* ctx) +{ + self(ctx)->set_nickname(duk_require_string(ctx, 0)); + + return 0; +} + +/* + * Method: Server.notice(target, message) + * ------------------------------------------------------------------ + * + * Send a private notice. + * + * Arguments: + * - target, the target, + * - message, the notice message. + */ +duk_ret_t notice(duk_context* ctx) +{ + self(ctx)->notice(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.part(channel, reason = undefined) + * ------------------------------------------------------------------ + * + * Leave a channel. + * + * Arguments: + * - channel, the channel to leave, + * - reason, the optional reason, keep undefined for portability. + */ +duk_ret_t part(duk_context* ctx) +{ + self(ctx)->part(duk_require_string(ctx, 0), dukx_get_std_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.send(raw) + * ------------------------------------------------------------------ + * + * Send a raw message to the IRC server. + * + * Arguments: + * - raw, the raw message (without terminators). + */ +duk_ret_t send(duk_context* ctx) +{ + self(ctx)->send(duk_require_string(ctx, 0)); + + return 0; +} + +/* + * Method: Server.topic(channel, topic) + * ------------------------------------------------------------------ + * + * Change a channel topic. + * + * Arguments: + * - channel, the channel, + * - topic, the new topic. + */ +duk_ret_t topic(duk_context* ctx) +{ + self(ctx)->topic(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + return 0; +} + +/* + * Method: Server.whois(target) + * ------------------------------------------------------------------ + * + * Get whois information. + * + * Arguments: + * - target, the target. + */ +duk_ret_t whois(duk_context* ctx) +{ + self(ctx)->whois(duk_require_string(ctx, 0)); + + return 0; +} + +/* + * Method: Server.toString() + * ------------------------------------------------------------------ + * + * Convert the object to std::string, convenience for adding the object + * as property key. + * + * duk_ret_turns: + * The server name (unique). + */ +duk_ret_t toString(duk_context* ctx) +{ + dukx_push_std_string(ctx, self(ctx)->name()); + + return 1; +} + +/* + * Function: Irccd.Server(params) [constructor] + * ------------------------------------------------------------------ + * + * Construct a new server. + * + * Params must be filled with the following properties: + * + * name: the name, + * host: the host, + * ipv6: true to use ipv6, (Optional: default false) + * port: the port number, (Optional: default 6667) + * password: the password, (Optional: default none) + * channels: array of channels (Optiona: default empty) + * ssl: true to use ssl, (Optional: default false) + * sslVerify: true to verify (Optional: default true) + * nickname: "nickname", (Optional, default: irccd) + * username: "user name", (Optional, default: irccd) + * realname: "real name", (Optional, default: IRC Client Daemon) + * commandChar: "!", (Optional, the command char, default: "!") + */ +duk_ret_t constructor(duk_context* ctx) +{ + if (!duk_is_constructor_call(ctx)) + return 0; + + duk_check_type(ctx, 0, DUK_TYPE_OBJECT); + + try { + auto json = duk_json_encode(ctx, 0); + auto s = server::from_json(nlohmann::json::parse(json)); + + duk_push_this(ctx); + duk_push_pointer(ctx, new std::shared_ptr(std::move(s))); + duk_put_prop_string(ctx, -2, signature); + duk_pop(ctx); + } catch (const std::exception& ex) { + duk_error(ctx, DUK_ERR_ERROR, "%s", ex.what()); + } + + return 0; +} + +/* + * Function: Irccd.Server() [destructor] + * ------------------------------------------------------------------ + * + * Delete the property. + */ +duk_ret_t destructor(duk_context* ctx) +{ + duk_get_prop_string(ctx, 0, signature); + delete static_cast*>(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + duk_del_prop_string(ctx, 0, signature); + + return 0; +} + +/* + * Function: Irccd.Server.add(s) + * ------------------------------------------------------------------ + * + * Register a new server to the irccd instance. + * + * Arguments: + * - s, the server to add. + */ +duk_ret_t add(duk_context* ctx) +{ + dukx_get_irccd(ctx).servers().add(dukx_require_server(ctx, 0)); + + return 0; +} + +/* + * Function: Irccd.Server.find(name) + * ------------------------------------------------------------------ + * + * Find a server by name. + * + * Arguments: + * - name, the server name + * duk_ret_turns: + * The server object or undefined if not found. + */ +duk_ret_t find(duk_context* ctx) +{ + auto server = dukx_get_irccd(ctx).servers().get(duk_require_string(ctx, 0)); + + if (!server) + return 0; + + dukx_push_server(ctx, server); + + return 1; +} + +/* + * Function: Irccd.Server.list() + * ------------------------------------------------------------------ + * + * Get the map of all loaded servers. + * + * duk_ret_turns: + * An object with string-to-servers pairs. + */ +duk_ret_t list(duk_context* ctx) +{ + duk_push_object(ctx); + + for (const auto &server : dukx_get_irccd(ctx).servers().servers()) { + dukx_push_server(ctx, server); + duk_put_prop_string(ctx, -2, server->name().c_str()); + } + + return 1; +} + +/* + * Function: irccd.Server.remove(name) + * ------------------------------------------------------------------ + * + * Remove a server from the irccd instance. You can pass the server object since + * it's coercible to a string. + * + * Arguments: + * - name the server name. + */ +duk_ret_t remove(duk_context* ctx) +{ + dukx_get_irccd(ctx).servers().remove(duk_require_string(ctx, 0)); + + return 0; +} + +const duk_function_list_entry methods[] = { + { "cmode", cmode, 2 }, + { "cnotice", cnotice, 2 }, + { "info", info, 0 }, + { "invite", invite, 2 }, + { "join", join, DUK_VARARGS }, + { "kick", kick, DUK_VARARGS }, + { "me", me, 2 }, + { "message", message, 2 }, + { "mode", mode, 1 }, + { "names", names, 1 }, + { "nick", nick, 1 }, + { "notice", notice, 2 }, + { "part", part, DUK_VARARGS }, + { "send", send, 1 }, + { "topic", topic, 2 }, + { "whois", whois, 1 }, + { "toString", toString, 0 }, + { nullptr, nullptr, 0 } +}; + +const duk_function_list_entry functions[] = { + { "add", add, 1 }, + { "find", find, 1 }, + { "list", list, 0 }, + { "remove", remove, 1 }, + { nullptr, nullptr, 0 } +}; + +} // !namespace + +js_server_module::js_server_module() noexcept + : module("Irccd.Server") +{ +} + +void js_server_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_c_function(plugin->context(), constructor, 1); + duk_put_function_list(plugin->context(), -1, functions); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, methods); + duk_push_c_function(plugin->context(), destructor, 1); + duk_set_finalizer(plugin->context(), -2); + duk_dup_top(plugin->context()); + duk_put_global_string(plugin->context(), prototype); + duk_put_prop_string(plugin->context(), -2, "prototype"); + duk_put_prop_string(plugin->context(), -2, "Server"); + duk_pop(plugin->context()); +} + +void dukx_push_server(duk_context* ctx, std::shared_ptr server) +{ + assert(ctx); + assert(server); + + StackAssert sa(ctx, 1); + + duk_push_object(ctx); + duk_push_pointer(ctx, new std::shared_ptr(std::move(server))); + duk_put_prop_string(ctx, -2, signature); + duk_get_global_string(ctx, prototype); + duk_set_prototype(ctx, -2); +} + +std::shared_ptr dukx_require_server(duk_context* ctx, duk_idx_t index) +{ + if (!duk_is_object(ctx, index) || !duk_has_prop_string(ctx, index, signature)) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object"); + + duk_get_prop_string(ctx, index, signature); + auto file = *static_cast *>(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + + return file; +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_server_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_server_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,70 @@ +/* + * js_server_module.hpp -- Irccd.Server API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_SERVER_MODULE_HPP +#define IRCCD_JS_SERVER_MODULE_HPP + +/** + * \file mod-server.hpp + * \brief irccd.Server JavaScript API. + */ + +#include "duktape.hpp" +#include "module.hpp" +#include "server.hpp" + +namespace irccd { + +/** + * \brief irccd.Server JavaScript API. + * \ingroup modules + */ +class js_server_module : public module { +public: + /** + * irccd.Server. + */ + js_server_module() noexcept; + + /** + * \copydoc Module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +/** + * Push a server. + * + * \pre server != nullptr + * \param ctx the context + * \param server the server + */ +void dukx_push_server(duk_context* ctx, std::shared_ptr server); + +/** + * Require a server. Raise a JavaScript error if not a Server. + * + * \param ctx the context + * \param index the index + * \return the server + */ +std::shared_ptr dukx_require_server(duk_context* ctx, duk_idx_t index); + +} // !irccd + +#endif // !IRCCD_JS_SERVER_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_system_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_system_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,244 @@ +/* + * js_system_module.cpp -- Irccd.System API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include + +#include + +#if defined(HAVE_POPEN) +# include +#endif + +#include +#include + +#include "js_file_module.hpp" +#include "js_irccd_module.hpp" +#include "js_system_module.hpp" + +namespace irccd { + +namespace { + +/* + * Function: irccd.System.env(key) + * ------------------------------------------------------------------ + * + * Get an environment system variable. + * + * Arguments: + * - key, the environment variable. + * Returns: + * The value. + */ +duk_ret_t env(duk_context* ctx) +{ + dukx_push_std_string(ctx, sys::env(dukx_get_std_string(ctx, 0))); + + return 1; +} + +/* + * Function: irccd.System.exec(cmd) + * ------------------------------------------------------------------ + * + * Execute a system command. + * + * Arguments: + * - cmd, the command to execute. + */ +duk_ret_t exec(duk_context* ctx) +{ + std::system(duk_get_string(ctx, 0)); + + return 0; +} + +/* + * Function: irccd.System.home() + * ------------------------------------------------------------------ + * + * Get the operating system user's home. + * + * Returns: + * The user home directory. + */ +duk_ret_t home(duk_context* ctx) +{ + dukx_push_std_string(ctx, sys::home()); + + return 1; +} + +/* + * Function: irccd.System.name() + * ------------------------------------------------------------------ + * + * Get the operating system name. + * + * Returns: + * The system name. + */ +duk_ret_t name(duk_context* ctx) +{ + dukx_push_std_string(ctx, sys::name()); + + return 1; +} + +#if defined(HAVE_POPEN) + +/* + * Function: irccd.System.popen(cmd, mode) [optional] + * ------------------------------------------------------------------ + * + * Wrapper for popen(3) if the function is available. + * + * Arguments: + * - cmd, the command to execute, + * - mode, the mode (e.g. "r"). + * Returns: + * A irccd.File object. + * Throws + * - irccd.system_error on failures. + */ +duk_ret_t popen(duk_context* ctx) +{ + auto fp = ::popen(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); + + if (fp == nullptr) + dukx_throw(ctx, system_error()); + + dukx_push_file(ctx, new file(fp, [] (auto fp) { ::pclose(fp); })); + + return 1; +} + +#endif // !HAVE_POPEN + +/* + * Function: irccd.System.sleep(delay) + * ------------------------------------------------------------------ + * + * Sleep the main loop for the specific delay in seconds. + */ +duk_ret_t sleep(duk_context* ctx) +{ + std::this_thread::sleep_for(std::chrono::seconds(duk_get_int(ctx, 0))); + + return 0; +} + +/* + * Function: irccd.System.ticks() + * ------------------------------------------------------------------ + * + * Get the number of milliseconds since irccd was started. + * + * Returns: + * The number of milliseconds. + */ +duk_ret_t ticks(duk_context* ctx) +{ + duk_push_int(ctx, sys::ticks()); + + return 1; +} + +/* + * Function: irccd.System.usleep(delay) + * ------------------------------------------------------------------ + * + * Sleep the main loop for the specific delay in microseconds. + */ +duk_ret_t usleep(duk_context* ctx) +{ + std::this_thread::sleep_for(std::chrono::microseconds(duk_get_int(ctx, 0))); + + return 0; +} + +/* + * Function: irccd.System.uptime() + * ------------------------------------------------------------------ + * + * Get the system uptime. + * + * Returns: + * The system uptime. + */ +duk_ret_t uptime(duk_context* ctx) +{ + duk_push_int(ctx, sys::uptime()); + + return 0; +} + +/* + * Function: irccd.System.version() + * ------------------------------------------------------------------ + * + * Get the operating system version. + * + * Returns: + * The system version. + */ +duk_ret_t version(duk_context* ctx) +{ + dukx_push_std_string(ctx, sys::version()); + + return 1; +} + +const duk_function_list_entry functions[] = { + { "env", env, 1 }, + { "exec", exec, 1 }, + { "home", home, 0 }, + { "name", name, 0 }, +#if defined(HAVE_POPEN) + { "popen", popen, 2 }, +#endif + { "sleep", sleep, 1 }, + { "ticks", ticks, 0 }, + { "uptime", uptime, 0 }, + { "usleep", usleep, 1 }, + { "version", version, 0 }, + { nullptr, nullptr, 0 } +}; + +} // !namespace + +js_system_module::js_system_module() noexcept + : module("Irccd.System") +{ +} + +void js_system_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, functions); + duk_put_prop_string(plugin->context(), -2, "System"); + duk_pop(plugin->context()); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_system_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_system_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,50 @@ +/* + * js_system_module.hpp -- Irccd.System API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_SYSTEM_MODULE_HPP +#define IRCCD_JS_SYSTEM_MODULE_HPP + +/** + * \file mod-system.hpp + * \brief irccd.System JavaScript API. + */ + +#include "module.hpp" + +namespace irccd { + +/** + * \brief irccd.System JavaScript API. + * \ingroup modules + */ +class js_system_module : public module { +public: + /** + * irccd.System. + */ + js_system_module() noexcept; + + /** + * \copydoc Module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +} // !irccd + +#endif // !IRCCD_JS_SYSTEM_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_timer_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_timer_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,210 @@ +/* + * js_timer_module.cpp -- Irccd.timer API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include +#include +#include +#include + +#include "js_irccd_module.hpp" +#include "js_plugin_module.hpp" +#include "js_timer_module.hpp" + +using namespace fmt::literals; + +namespace irccd { + +namespace { + +const char* signature("\xff""\xff""irccd-timer-ptr"); +const char* callback_table("\xff""\xff""irccd-timer-callbacks"); + +void handle_signal(irccd& instance, std::weak_ptr ptr, std::string key) +{ + auto plugin = ptr.lock(); + + if (!plugin) + return; + + instance.post([plugin, key] (irccd &) { + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), callback_table); + duk_get_prop_string(plugin->context(), -1, key.c_str()); + duk_remove(plugin->context(), -2); + + if (duk_is_callable(plugin->context(), -1)) { + if (duk_pcall(plugin->context(), 0) != 0) + log::warning("plugin {}: {}"_format(plugin->name(), dukx_exception(plugin->context(), -1).stack)); + else + duk_pop(plugin->context()); + } else + duk_pop(plugin->context()); + }); +} + +std::shared_ptr self(duk_context* ctx) +{ + StackAssert sa(ctx); + + duk_push_this(ctx); + duk_get_prop_string(ctx, -1, signature); + auto ptr = duk_to_pointer(ctx, -1); + duk_pop_2(ctx); + + if (!ptr) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a timer object"); + + return *static_cast*>(ptr); +} + +/* + * Method: timer.start() + * -------------------------------------------------------- + * + * Start the timer. If the timer is already started the method is a no-op. + */ +duk_ret_t start(duk_context* ctx) +{ + auto timer = self(ctx); + + if (!timer->is_running()) + timer->start(); + + return 0; +} + +/* + * Method: timer.stop() + * -------------------------------------------------------- + * + * Stop the timer. + */ +duk_ret_t stop(duk_context* ctx) +{ + auto timer = self(ctx); + + if (timer->is_running()) + timer->stop(); + + return 0; +} + +const duk_function_list_entry methods[] = { + { "start", start, 0 }, + { "stop", stop, 0 }, + { nullptr, nullptr, 0 } +}; + +/* + * Function: Irccd.timer(type, delay, callback) [constructor] + * -------------------------------------------------------- + * + * Create a new timer object. + * + * Arguments: + * - type, the type of timer (irccd.timer.Single or irccd.timer.Repeat), + * - delay, the interval in milliseconds, + * - callback, the function to call. + */ +duk_ret_t constructor(duk_context* ctx) +{ + // Check parameters. + auto type = duk_require_int(ctx, 0); + auto delay = duk_require_int(ctx, 1); + + if (type < static_cast(timer::type::single) || type > static_cast(timer::type::repeat)) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "invalid timer type"); + if (delay < 0) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "negative delay given"); + if (!duk_is_callable(ctx, 2)) + duk_error(ctx, DUK_ERR_TYPE_ERROR, "missing callback function"); + + // Construct the timer in 'this'. + auto& irccd = dukx_get_irccd(ctx); + auto tm = std::make_shared(static_cast(type), delay); + auto hash = std::to_string(reinterpret_cast(tm.get())); + + tm->on_signal.connect(std::bind(handle_signal, std::ref(irccd), + std::weak_ptr(dukx_get_plugin(ctx)), hash)); + + duk_push_this(ctx); + duk_push_pointer(ctx, new std::shared_ptr(std::move(tm))); + duk_put_prop_string(ctx, -2, signature); + duk_push_string(ctx, hash.c_str()); + duk_put_prop_string(ctx, -2, "\xff""\xff""timer-key"); + duk_push_c_function(ctx, [] (duk_context* ctx) -> duk_ret_t { + StackAssert sa(ctx); + + duk_get_prop_string(ctx, 0, "\xff""\xff""timer-key"); + auto hash = duk_get_string(ctx, -1); + duk_pop(ctx); + duk_get_prop_string(ctx, 0, signature); + static_cast*>(duk_to_pointer(ctx, -1))->get()->stop(); + delete static_cast*>(duk_to_pointer(ctx, -1)); + duk_pop(ctx); + duk_get_global_string(ctx, callback_table); + duk_del_prop_string(ctx, -1, hash); + duk_pop(ctx); + log::debug("plugin: timer destroyed"); + + return 0; + }, 1); + duk_set_finalizer(ctx, -2); + + // Save a callback function into the callback table. + duk_get_global_string(ctx, callback_table); + duk_dup(ctx, 2); + duk_put_prop_string(ctx, -2, hash.c_str()); + duk_pop(ctx); + + return 0; +} + +const duk_number_list_entry constants[] = { + { "Single", static_cast(timer::type::single) }, + { "Repeat", static_cast(timer::type::repeat) }, + { nullptr, 0 } +}; + +} // !namespace + +js_timer_module::js_timer_module() noexcept + : module("Irccd.timer") +{ +} + +void js_timer_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_c_function(plugin->context(), constructor, 3); + duk_put_number_list(plugin->context(), -1, constants); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, methods); + duk_put_prop_string(plugin->context(), -2, "prototype"); + duk_put_prop_string(plugin->context(), -2, "Timer"); + duk_pop(plugin->context()); + duk_push_object(plugin->context()); + duk_put_global_string(plugin->context(), callback_table); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_timer_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_timer_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,50 @@ +/* + * js_timer_module.hpp -- Irccd.Timer API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_TIMER_MODULE_HPP +#define IRCCD_JS_TIMER_MODULE_HPP + +/** + * \file js_timer_module + * \brief irccd.Timer JavaScript API. + */ + +#include "module.hpp" + +namespace irccd { + +/** + * \brief Irccd.Timer JavaScript API. + * \ingroup modules + */ +class js_timer_module : public module { +public: + /** + * Constructor. + */ + js_timer_module() noexcept; + + /** + * \copydoc module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +} // !irccd + +#endif // !IRCCD_MOD_TIMER_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_unicode_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_unicode_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,153 @@ +/* + * js_unicode_module.cpp -- Irccd.Unicode API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include "duktape.hpp" +#include "js_unicode_module.hpp" +#include "unicode.hpp" + +namespace irccd { + +namespace { + +/* + * Function: Irccd.Unicode.isDigit(code) + * -------------------------------------------------------- + * + * Arguments: + * - code, the code point. + * Returns: + * True if the code is in the digit category. + */ +duk_ret_t is_digit(duk_context* ctx) +{ + duk_push_boolean(ctx, unicode::isdigit(duk_get_int(ctx, 0))); + + return 1; +} + +/* + * Function: Irccd.Unicode.isLetter(code) + * -------------------------------------------------------- + * + * Arguments: + * - code, the code point. + * Returns: + * True if the code is in the letter category. + */ +duk_ret_t is_letter(duk_context* ctx) +{ + duk_push_boolean(ctx, unicode::isalpha(duk_get_int(ctx, 0))); + + return 1; +} + +/* + * Function: Irccd.Unicode.isLower(code) + * -------------------------------------------------------- + * + * Arguments: + * - code, the code point. + * Returns: + * True if the code is lower case. + */ +duk_ret_t is_lower(duk_context* ctx) +{ + duk_push_boolean(ctx, unicode::islower(duk_get_int(ctx, 0))); + + return 1; +} + +/* + * Function: Irccd.Unicode.isSpace(code) + * -------------------------------------------------------- + * + * Arguments: + * - code, the code point. + * Returns: + * True if the code is in the space category. + */ +duk_ret_t is_space(duk_context* ctx) +{ + duk_push_boolean(ctx, unicode::isspace(duk_get_int(ctx, 0))); + + return 1; +} + +/* + * Function: Irccd.Unicode.isTitle(code) + * -------------------------------------------------------- + * + * Arguments: + * - code, the code point. + * Returns: + * True if the code is title case. + */ +duk_ret_t is_title(duk_context* ctx) +{ + duk_push_boolean(ctx, unicode::istitle(duk_get_int(ctx, 0))); + + return 1; +} + +/* + * Function: Irccd.Unicode.isUpper(code) + * -------------------------------------------------------- + * + * Arguments: + * - code, the code point. + * Returns: + * True if the code is upper case. + */ +duk_ret_t is_upper(duk_context* ctx) +{ + duk_push_boolean(ctx, unicode::isupper(duk_get_int(ctx, 0))); + + return 1; +} + +const duk_function_list_entry functions[] = { + { "isDigit", is_digit, 1 }, + { "isLetter", is_letter, 1 }, + { "isLower", is_lower, 1 }, + { "isSpace", is_space, 1 }, + { "isTitle", is_title, 1 }, + { "isUpper", is_upper, 1 }, + { nullptr, nullptr, 0 } +}; + +} // !namespace + +js_unicode_module::js_unicode_module() noexcept + : module("Irccd.Unicode") +{ +} + +void js_unicode_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, functions); + duk_put_prop_string(plugin->context(), -2, "Unicode"); + duk_pop(plugin->context()); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_unicode_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_unicode_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,50 @@ +/* + * js_unicode_module.hpp -- Irccd.Unicode API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_UNICODE_MODULE_HPP +#define IRCCD_JS_UNICODE_MODULE_HPP + +/** + * \file js_unicode_module.hpp + * \brief irccd.Unicode JavaScript API. + */ + +#include "module.hpp" + +namespace irccd { + +/** + * \brief Irccd.Unicode JavaScript API. + * \ingroup modules + */ +class js_unicode_module : public module { +public: + /** + * Constructor. + */ + js_unicode_module() noexcept; + + /** + * \copydoc Module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +} // !irccd + +#endif // !IRCCD_JS_UNICODE_MODULE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_util_module.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_util_module.cpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,300 @@ +/* + * js_util_module.cpp -- Irccd.Util API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include + +#include + +#include "js_util_module.hpp" +#include "js_plugin.hpp" + +namespace irccd { + +namespace { + +/* + * Read parameters for irccd.Util.format function, the object is defined as + * following: + * + * { + * date: the date object + * flags: the flags (not implemented yet) + * field1: a field to substitute in #{} pattern + * field2: a field to substitute in #{} pattern + * fieldn: ... + * } + */ +util::subst get_subst(duk_context* ctx, int index) +{ + util::subst params; + + if (!duk_is_object(ctx, index)) + return params; + + dukx_enumerate(ctx, index, 0, true, [&] (auto) { + if (dukx_get_std_string(ctx, -2) == "date") + params.time = static_cast(duk_get_number(ctx, -1) / 1000); + else + params.keywords.insert({dukx_get_std_string(ctx, -2), dukx_get_std_string(ctx, -1)}); + }); + + return params; +} + +/* + * split (for Irccd.Util.cut) + * ------------------------------------------------------------------ + * + * Extract individual tokens in array or a whole string as a std:::vector. + */ +std::vector split(duk_context* ctx) +{ + duk_require_type_mask(ctx, 0, DUK_TYPE_MASK_OBJECT | DUK_TYPE_MASK_STRING); + + std::vector result; + std::string pattern = " \t\n"; + + if (duk_is_string(ctx, 0)) + result = util::split(dukx_get_std_string(ctx, 0), pattern); + else if (duk_is_array(ctx, 0)) { + duk_enum(ctx, 0, DUK_ENUM_ARRAY_INDICES_ONLY); + + while (duk_next(ctx, -1, 1)) { + // Split individual tokens as array if spaces are found. + auto tmp = util::split(duk_to_string(ctx, -1), pattern); + + result.insert(result.end(), tmp.begin(), tmp.end()); + duk_pop_2(ctx); + } + } + + return result; +} + +/* + * limit (for Irccd.Util.cut) + * ------------------------------------------------------------------ + * + * Get the maxl/maxc argument. + * + * The argument value is the default and also used as the result returned. + */ +int limit(duk_context* ctx, int index, const char* name, int value) +{ + if (duk_get_top(ctx) < index || !duk_is_number(ctx, index)) + return value; + + value = duk_to_int(ctx, index); + + if (value <= 0) + duk_error(ctx, DUK_ERR_RANGE_ERROR, "argument %d (%s) must be positive", index, name); + + return value; +} + +/* + * lines (for Irccd.Util.cut) + * ------------------------------------------------------------------ + * + * Build a list of lines. + * + * Several cases possible: + * + * - s is the current line + * - abc is the token to add + * + * s = "" (new line) + * s -> "abc" + * + * s = "hello world" (enough room) + * s -> "hello world abc" + * + * s = "hello world" (not enough room: maxc is smaller) + * s+1 = "abc" + */ +std::vector lines(duk_context* ctx, const std::vector& tokens, int maxc) +{ + std::vector result{""}; + + for (const auto& s : tokens) { + if (s.length() > static_cast(maxc)) + duk_error(ctx, DUK_ERR_RANGE_ERROR, "word '%s' could not fit in maxc limit (%d)", s.c_str(), maxc); + + // Compute the length required (prepend a space if needed) + auto required = s.length() + (result.back().empty() ? 0 : 1); + + if (result.back().length() + required > static_cast(maxc)) + result.push_back(s); + else { + if (!result.back().empty()) + result.back() += ' '; + + result.back() += s; + } + } + + return result; +} + +/* + * Function: Irccd.Util.cut(data, maxc, maxl) + * -------------------------------------------------------- + * + * Cut a piece of data into several lines. + * + * The argument data is a string or a list of strings. In any case, all strings + * are first splitted by spaces and trimmed. This ensure that useless + * whitespaces are discarded. + * + * The argument maxc controls the maximum of characters allowed per line, it can + * be a positive integer. If undefined is given, a default of 72 is used. + * + * The argument maxl controls the maximum of lines allowed. It can be a positive + * integer or undefined for an infinite list. + * + * If maxl is used as a limit and the data can not fit within the bounds, + * undefined is returned. + * + * An empty list may be returned if empty strings were found. + * + * Arguments: + * - data, a string or an array of strings, + * - maxc, max number of colums (Optional, default: 72), + * - maxl, max number of lines (Optional, default: undefined). + * Returns: + * A list of strings ready to be sent or undefined if the data is too big. + * Throws: + * - RangeError if maxl or maxc are negative numbers, + * - RangeError if one word length was bigger than maxc, + * - TypeError if data is not a string or a list of strings. + */ +duk_ret_t cut(duk_context* ctx) +{ + auto list = lines(ctx, split(ctx), limit(ctx, 1, "maxc", 72)); + auto maxl = limit(ctx, 2, "maxl", INT_MAX); + + if (list.size() > static_cast(maxl)) + return 0; + + // Empty list but lines() returns at least one. + if (list.size() == 1 && list[0].empty()) { + duk_push_array(ctx); + return 1; + } + + dukx_push_array(ctx, list, dukx_push_std_string); + + return 1; +} + +/* + * Function: Irccd.Util.format(text, parameters) + * -------------------------------------------------------- + * + * Format a string with templates. + * + * Arguments: + * - input, the text to update, + * - params, the parameters. + * Returns: + * The converted text. + */ +duk_ret_t format(duk_context* ctx) +{ + try { + dukx_push_std_string(ctx, util::format(dukx_get_std_string(ctx, 0), get_subst(ctx, 1))); + } catch (const std::exception &ex) { + dukx_throw(ctx, SyntaxError(ex.what())); + } + + return 1; +} + +/* + * Function: Irccd.Util.splituser(ident) + * -------------------------------------------------------- + * + * Return the nickname part from a full username. + * + * Arguments: + * - ident, the full identity. + * Returns: + * The nickname. + */ +duk_ret_t splituser(duk_context* ctx) +{ + auto target = duk_require_string(ctx, 0); + char nick[32] = {0}; + + irc_target_get_nick(target, nick, sizeof (nick) -1); + duk_push_string(ctx, nick); + + return 1; +} + +/* + * Function: Irccd.Util.splithost(ident) + * -------------------------------------------------------- + * + * Return the hostname part from a full username. + * + * Arguments: + * - ident, the full identity. + * Returns: + * The hostname. + */ +duk_ret_t splithost(duk_context* ctx) +{ + auto target = duk_require_string(ctx, 0); + char host[32] = {0}; + + irc_target_get_host(target, host, sizeof (host) -1); + duk_push_string(ctx, host); + + return 1; +} + +const duk_function_list_entry functions[] = { + { "cut", cut, DUK_VARARGS }, + { "format", format, DUK_VARARGS }, + { "splituser", splituser, 1 }, + { "splithost", splithost, 1 }, + { nullptr, nullptr, 0 } +}; + +} // !namespace + +js_util_module::js_util_module() noexcept + : module("Irccd.Util") +{ +} + +void js_util_module::load(irccd&, std::shared_ptr plugin) +{ + StackAssert sa(plugin->context()); + + duk_get_global_string(plugin->context(), "Irccd"); + duk_push_object(plugin->context()); + duk_put_function_list(plugin->context(), -1, functions); + duk_put_prop_string(plugin->context(), -2, "Util"); + duk_pop(plugin->context()); +} + +} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/js_util_module.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libirccd-js/irccd/js_util_module.hpp Tue Sep 26 17:18:47 2017 +0200 @@ -0,0 +1,50 @@ +/* + * js_util_module.hpp -- Irccd.Util API + * + * Copyright (c) 2013-2017 David Demelier + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef IRCCD_JS_UTIL_MODULE_HPP +#define IRCCD_JS_UTIL_MODULE_HPP + +/** + * \file js_util_module.hpp + * \brief irccd.Util JavaScript API. + */ + +#include "module.hpp" + +namespace irccd { + +/** + * \brief Irccd.Util JavaScript API. + * \ingroup modules + */ +class js_util_module : public module { +public: + /** + * Constructor. + */ + js_util_module() noexcept; + + /** + * \copydoc module::load + */ + void load(irccd& irccd, std::shared_ptr plugin) override; +}; + +} // !irccd + +#endif // !IRCCD_MOD_UTIL_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-directory.cpp --- a/libirccd-js/irccd/mod-directory.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,386 +0,0 @@ -/* - * mod-directory.cpp -- Irccd.Directory API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include -#include -#include -#include -#include -#include -#include - -#include - -#include "duktape.hpp" -#include "fs.hpp" -#include "mod-directory.hpp" -#include "mod-irccd.hpp" -#include "plugin-js.hpp" -#include "sysconfig.hpp" - -namespace irccd { - -namespace { - -std::string path(duk_context *ctx) -{ - duk_push_this(ctx); - duk_get_prop_string(ctx, -1, "path"); - - if (duk_get_type(ctx, -1) != DUK_TYPE_STRING) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Directory object"); - - auto ret = dukx_get_std_string(ctx, -1); - - if (ret.empty()) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "directory object has empty path"); - - duk_pop_n(ctx, 2); - - return ret; -} - -/* - * Find an entry recursively (or not) in a directory using a predicate which can - * be used to test for regular expression, equality. - * - * Do not use this function directly, use: - * - * - findName - * - findRegex - */ -template -std::string findPath(const std::string &base, bool recursive, Pred pred) -{ - /* - * For performance reason, we first iterate over all entries that are - * not directories to avoid going deeper recursively if the requested - * file is in the current directory. - */ - auto entries = fs::readdir(base); - - for (const auto &entry : entries) - if (entry.type != fs::Entry::Dir && pred(entry.name)) - return base + entry.name; - - if (!recursive) - return ""; - - for (const auto &entry : entries) { - if (entry.type == fs::Entry::Dir) { - std::string next = base + entry.name + fs::separator(); - std::string path = findPath(next, true, pred); - - if (!path.empty()) - return path; - } - } - - return ""; -} - -/* - * Helper for finding by equality. - */ -std::string findName(std::string base, const std::string &pattern, bool recursive) -{ - return findPath(base, recursive, [&] (const std::string &entryname) -> bool { - return pattern == entryname; - }); -} - -/* - * Helper for finding by regular expression - */ -std::string findRegex(const std::string &base, std::string pattern, bool recursive) -{ - std::regex regexp(pattern, std::regex::ECMAScript); - std::smatch smatch; - - return findPath(base, recursive, [&] (const std::string &entryname) -> bool { - return std::regex_match(entryname, smatch, regexp); - }); -} - -/* - * Generic find function for: - * - * - Directory.find - * - Directory.prototype.find - * - * The patternIndex is the argument where to test if the argument is a regex or - * a string. - */ -duk_ret_t find(duk_context *ctx, std::string base, bool recursive, int patternIndex) -{ - try { - std::string path; - - if (duk_is_string(ctx, patternIndex)) - path = findName(base, duk_get_string(ctx, patternIndex), recursive); - else { - // Check if it's a valid RegExp object. - duk_get_global_string(ctx, "RegExp"); - auto isRegex = duk_instanceof(ctx, patternIndex, -1); - duk_pop(ctx); - - if (isRegex) { - duk_get_prop_string(ctx, patternIndex, "source"); - auto pattern = duk_to_string(ctx, -1); - duk_pop(ctx); - - path = findRegex(base, pattern, recursive); - } else - duk_error(ctx, DUK_ERR_TYPE_ERROR, "pattern must be a string or a regex expression"); - } - - if (path.empty()) - return 0; - - dukx_push_std_string(ctx, path); - } catch (const std::exception &ex) { - duk_error(ctx, DUK_ERR_ERROR, "%s", ex.what()); - } - - return 1; -} - -/* - * Generic remove function for: - * - * - Directory.remove - * - Directory.prototype.remove - */ -duk_ret_t remove(duk_context *ctx, const std::string &path, bool recursive) -{ - boost::system::error_code ec; - - if (!boost::filesystem::is_directory(path, ec) || ec) { - dukx_throw(ctx, SystemError(EINVAL, "not a directory")); - } - - if (!recursive) { - boost::filesystem::remove(path, ec); - } else { - boost::filesystem::remove_all(path, ec); - } - - return 0; -} - -/* - * Method: Directory.find(pattern, recursive) - * -------------------------------------------------------- - * - * Synonym of Directory.find(path, pattern, recursive) but the path is taken - * from the directory object. - * - * Arguments: - * - pattern, the regular expression or file name, - * - recursive, set to true to search recursively (default: false). - * Returns: - * The path to the file or undefined if not found. - * Throws: - * - Any exception on error. - */ -duk_ret_t methodFind(duk_context *ctx) -{ - return find(ctx, path(ctx), duk_get_boolean(ctx, 1), 0); -} - -/* - * Method: Directory.remove(recursive) - * -------------------------------------------------------- - * - * Synonym of Directory.remove(recursive) but the path is taken from the - * directory object. - * - * Arguments: - * - recursive, recursively or not (default: false). - * Throws: - * - Any exception on error. - */ -duk_ret_t methodRemove(duk_context *ctx) -{ - return remove(ctx, path(ctx), duk_get_boolean(ctx, 0)); -} - -const duk_function_list_entry methods[] = { - { "find", methodFind, DUK_VARARGS }, - { "remove", methodRemove, 1 }, - { nullptr, nullptr, 0 } -}; - -/* - * Directory "static" functions - * ------------------------------------------------------------------ - */ - -/* - * Function: Irccd.Directory(path, flags) [constructor] - * -------------------------------------------------------- - * - * Opens and read the directory at the specified path. - * - * Arguments: - * - path, the path to the directory, - * - flags, the optional flags (default: 0). - * Throws: - * - Any exception on error - */ -duk_ret_t constructor(duk_context *ctx) -{ - if (!duk_is_constructor_call(ctx)) - return 0; - - try { - std::string path = duk_require_string(ctx, 0); - std::int8_t flags = duk_get_uint(ctx, 1); - - if (!boost::filesystem::is_directory(path)) - dukx_throw(ctx, SystemError(EINVAL, "not a directory")); - - std::vector list = fs::readdir(path, flags); - - duk_push_this(ctx); - duk_push_string(ctx, "count"); - duk_push_int(ctx, list.size()); - duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE); - duk_push_string(ctx, "path"); - dukx_push_std_string(ctx, path); - duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE); - duk_push_string(ctx, "entries"); - duk_push_array(ctx); - - for (unsigned i = 0; i < list.size(); ++i) { - duk_push_object(ctx); - dukx_push_std_string(ctx, list[i].name); - duk_put_prop_string(ctx, -2, "name"); - duk_push_int(ctx, list[i].type); - duk_put_prop_string(ctx, -2, "type"); - duk_put_prop_index(ctx, -2, i); - } - - duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE); - } catch (const std::exception &ex) { - dukx_throw(ctx, SystemError(errno, ex.what())); - } - - return 0; -} - -/* - * Function: Irccd.Directory.find(path, pattern, recursive) - * -------------------------------------------------------- - * - * Find an entry by a pattern or a regular expression. - * - * Arguments: - * - path, the base path, - * - pattern, the regular expression or file name, - * - recursive, set to true to search recursively (default: false). - * Returns: - * The path to the file or undefined on errors or not found. - */ -duk_ret_t funcFind(duk_context *ctx) -{ - return find(ctx, duk_require_string(ctx, 0), duk_get_boolean(ctx, 2), 1); -} - -/* - * Function: Irccd.Directory.remove(path, recursive) - * -------------------------------------------------------- - * - * Remove the directory optionally recursively. - * - * Arguments: - * - path, the path to the directory, - * - recursive, recursively or not (default: false). - * Throws: - * - Any exception on error. - */ -duk_ret_t funcRemove(duk_context *ctx) -{ - return remove(ctx, duk_require_string(ctx, 0), duk_get_boolean(ctx, 1)); -} - -/* - * Function: Irccd.Directory.mkdir(path, mode = 0700) - * -------------------------------------------------------- - * - * Create a directory specified by path. It will create needed subdirectories - * just like you have invoked mkdir -p. - * - * Arguments: - * - path, the path to the directory, - * Throws: - * - Any exception on error. - */ -duk_ret_t funcMkdir(duk_context *ctx) -{ - try { - boost::filesystem::create_directories(duk_require_string(ctx, 0)); - } catch (const std::exception &ex) { - dukx_throw(ctx, SystemError(errno, ex.what())); - } - - return 0; -} - -const duk_function_list_entry functions[] = { - { "find", funcFind, DUK_VARARGS }, - { "mkdir", funcMkdir, DUK_VARARGS }, - { "remove", funcRemove, DUK_VARARGS }, - { nullptr, nullptr, 0 } -}; - -const duk_number_list_entry constants[] = { - { "Dot", static_cast(fs::Dot) }, - { "DotDot", static_cast(fs::DotDot) }, - { "TypeUnknown", static_cast(fs::Entry::Unknown) }, - { "TypeDir", static_cast(fs::Entry::Dir) }, - { "TypeFile", static_cast(fs::Entry::File) }, - { "TypeLink", static_cast(fs::Entry::Link) }, - { nullptr, 0 } -}; - -} // !namespace - -DirectoryModule::DirectoryModule() noexcept - : Module("Irccd.Directory") -{ -} - -void DirectoryModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_c_function(plugin->context(), constructor, 2); - duk_put_number_list(plugin->context(), -1, constants); - duk_put_function_list(plugin->context(), -1, functions); - dukx_push_std_string(plugin->context(), std::string{fs::separator()}); - duk_put_prop_string(plugin->context(), -2, "separator"); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, methods); - duk_put_prop_string(plugin->context(), -2, "prototype"); - duk_put_prop_string(plugin->context(), -2, "Directory"); - duk_pop(plugin->context()); -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-directory.hpp --- a/libirccd-js/irccd/mod-directory.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * mod-directory.hpp -- Irccd.Directory API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_DIRECTORY_HPP -#define IRCCD_MOD_DIRECTORY_HPP - -/** - * \file mod-directory.hpp - * \brief Irccd.Directory JavaScript API. - */ - -#include "module.hpp" - -namespace irccd { - -/** - * \brief Irccd.Directory JavaScript API. - * \ingroup modules - */ -class DirectoryModule : public Module { -public: - /** - * Irccd.Directory. - */ - IRCCD_EXPORT DirectoryModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -} // !irccd - -#endif // !IRCCD_MOD_DIRECTORY_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-elapsed-timer.cpp --- a/libirccd-js/irccd/mod-elapsed-timer.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,161 +0,0 @@ -/* - * mod-elapsed-timer.cpp -- Irccd.ElapsedTimer API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "elapsed-timer.hpp" -#include "mod-elapsed-timer.hpp" -#include "plugin-js.hpp" - -namespace irccd { - -namespace { - -const char *Signature("\xff""\xff""irccd-elapsed-timer-ptr"); - -ElapsedTimer *self(duk_context *ctx) -{ - StackAssert sa(ctx); - - duk_push_this(ctx); - duk_get_prop_string(ctx, -1, Signature); - auto ptr = static_cast(duk_to_pointer(ctx, -1)); - duk_pop_2(ctx); - - if (!ptr) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "not an ElapsedTimer object"); - - return ptr; -} - -/* - * Method: ElapsedTimer.pause - * ------------------------------------------------------------------ - * - * Pause the timer, without resetting the current elapsed time stored. - */ -duk_ret_t pause(duk_context *ctx) -{ - self(ctx)->pause(); - - return 0; -} - -/* - * Method: ElapsedTimer.reset - * ------------------------------------------------------------------ - * - * Reset the elapsed time to 0, the status is not modified. - */ -duk_ret_t reset(duk_context *ctx) -{ - self(ctx)->reset(); - - return 0; -} - -/* - * Method: ElapsedTimer.restart - * ------------------------------------------------------------------ - * - * Restart the timer without resetting the current elapsed time. - */ -duk_ret_t restart(duk_context *ctx) -{ - self(ctx)->restart(); - - return 0; -} - -/* - * Method: ElapsedTimer.elapsed - * ------------------------------------------------------------------ - * - * Get the number of elapsed milliseconds. - * - * Returns: - * The time elapsed. - */ -duk_ret_t elapsed(duk_context *ctx) -{ - duk_push_uint(ctx, self(ctx)->elapsed()); - - return 1; -} - -/* - * Function: Irccd.ElapsedTimer() [constructor] - * ------------------------------------------------------------------ - * - * Construct a new ElapsedTimer object. - */ -duk_ret_t constructor(duk_context *ctx) -{ - duk_push_this(ctx); - duk_push_pointer(ctx, new ElapsedTimer); - duk_put_prop_string(ctx, -2, Signature); - duk_pop(ctx); - - return 0; -} - -/* - * Function: Irccd.ElapsedTimer() [destructor] - * ------------------------------------------------------------------ - * - * Delete the property. - */ -duk_ret_t destructor(duk_context *ctx) -{ - duk_get_prop_string(ctx, 0, Signature); - delete static_cast(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - duk_del_prop_string(ctx, 0, Signature); - - return 0; -} - -const duk_function_list_entry methods[] = { - { "elapsed", elapsed, 0 }, - { "pause", pause, 0 }, - { "reset", reset, 0 }, - { "restart", restart, 0 }, - { nullptr, nullptr, 0 } -}; - -} // !namespace - -ElapsedTimerModule::ElapsedTimerModule() noexcept - : Module("Irccd.ElapsedTimer") -{ -} - -void ElapsedTimerModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_c_function(plugin->context(), constructor, 0); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, methods); - duk_push_c_function(plugin->context(), destructor, 1); - duk_set_finalizer(plugin->context(), -2); - duk_put_prop_string(plugin->context(), -2, "prototype"); - duk_put_prop_string(plugin->context(), -2, "ElapsedTimer"); - duk_pop(plugin->context()); -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-elapsed-timer.hpp --- a/libirccd-js/irccd/mod-elapsed-timer.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * mod-elapsed-timer.hpp -- Irccd.ElapsedTimer API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_ELAPSED_TIMER_HPP -#define IRCCD_MOD_ELAPSED_TIMER_HPP - -/** - * \file mod-elapsed-timer.hpp - * \brief Irccd.ElapsedTimer JavaScript API. - */ - -#include "module.hpp" - -namespace irccd { - -/** - * \brief Irccd.ElapsedTimer JavaScript API. - * \ingroup modules - */ -class ElapsedTimerModule : public Module { -public: - /** - * Irccd.ElapsedTimer. - */ - IRCCD_EXPORT ElapsedTimerModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -} // !irccd - -#endif // !IRCCD_MOD_ELAPSED_TIMER_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-file.cpp --- a/libirccd-js/irccd/mod-file.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,699 +0,0 @@ -/* - * mod-file.cpp -- Irccd.File API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include -#include -#include -#include -#include - -#include - -#include "sysconfig.hpp" - -#if defined(HAVE_STAT) -# include -# include -#endif - -#include "fs.hpp" -#include "mod-file.hpp" -#include "mod-irccd.hpp" -#include "plugin-js.hpp" - -namespace irccd { - -namespace { - -const char *Signature("\xff""\xff""irccd-file-ptr"); -const char *Prototype("\xff""\xff""irccd-file-prototype"); - -#if defined(HAVE_STAT) - -/* - * pushStat - * ------------------------------------------------------------------ - */ - -void pushStat(duk_context *ctx, const struct stat &st) -{ - StackAssert sa(ctx, 1); - - duk_push_object(ctx); - -#if defined(HAVE_STAT_ST_ATIME) - duk_push_int(ctx, st.st_atime); - duk_put_prop_string(ctx, -2, "atime"); -#endif -#if defined(HAVE_STAT_ST_BLKSIZE) - duk_push_int(ctx, st.st_blksize); - duk_put_prop_string(ctx, -2, "blksize"); -#endif -#if defined(HAVE_STAT_ST_BLOCKS) - duk_push_int(ctx, st.st_blocks); - duk_put_prop_string(ctx, -2, "blocks"); -#endif -#if defined(HAVE_STAT_ST_CTIME) - duk_push_int(ctx, st.st_ctime); - duk_put_prop_string(ctx, -2, "ctime"); -#endif -#if defined(HAVE_STAT_ST_DEV) - duk_push_int(ctx, st.st_dev); - duk_put_prop_string(ctx, -2, "dev"); -#endif -#if defined(HAVE_STAT_ST_GID) - duk_push_int(ctx, st.st_gid); - duk_put_prop_string(ctx, -2, "gid"); -#endif -#if defined(HAVE_STAT_ST_INO) - duk_push_int(ctx, st.st_ino); - duk_put_prop_string(ctx, -2, "ino"); -#endif -#if defined(HAVE_STAT_ST_MODE) - duk_push_int(ctx, st.st_mode); - duk_put_prop_string(ctx, -2, "mode"); -#endif -#if defined(HAVE_STAT_ST_MTIME) - duk_push_int(ctx, st.st_mtime); - duk_put_prop_string(ctx, -2, "mtime"); -#endif -#if defined(HAVE_STAT_ST_NLINK) - duk_push_int(ctx, st.st_nlink); - duk_put_prop_string(ctx, -2, "nlink"); -#endif -#if defined(HAVE_STAT_ST_RDEV) - duk_push_int(ctx, st.st_rdev); - duk_put_prop_string(ctx, -2, "rdev"); -#endif -#if defined(HAVE_STAT_ST_SIZE) - duk_push_int(ctx, st.st_size); - duk_put_prop_string(ctx, -2, "size"); -#endif -#if defined(HAVE_STAT_ST_UID) - duk_push_int(ctx, st.st_uid); - duk_put_prop_string(ctx, -2, "uid"); -#endif -} - -#endif // !HAVE_STAT - -// Remove trailing \r for CRLF line style. -inline std::string clearCr(std::string input) -{ - if (input.length() > 0 && input.back() == '\r') - input.pop_back(); - - return input; -} - -File *self(duk_context *ctx) -{ - StackAssert sa(ctx); - - duk_push_this(ctx); - duk_get_prop_string(ctx, -1, Signature); - auto ptr = static_cast(duk_to_pointer(ctx, -1)); - duk_pop_2(ctx); - - if (!ptr) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a File object"); - - return ptr; -} - -/* - * File methods. - * ------------------------------------------------------------------ - */ - -/* - * Method: File.basename() - * -------------------------------------------------------- - * - * Synonym of `Irccd.File.basename(path)` but with the path from the file. - * - * duk_ret_turns: - * The base name. - */ -duk_ret_t methodBasename(duk_context *ctx) -{ - dukx_push_std_string(ctx, fs::baseName(self(ctx)->path())); - - return 1; -} - -/* - * Method: File.close() - * -------------------------------------------------------- - * - * Force close of the file, automatically called when object is collected. - */ -duk_ret_t methodClose(duk_context *ctx) -{ - self(ctx)->close(); - - return 0; -} - -/* - * Method: File.dirname() - * -------------------------------------------------------- - * - * Synonym of `Irccd.File.dirname(path)` but with the path from the file. - * - * duk_ret_turns: - * The directory name. - */ -duk_ret_t methodDirname(duk_context *ctx) -{ - dukx_push_std_string(ctx, fs::dirName(self(ctx)->path())); - - return 1; -} - -/* - * Method: File.lines() - * -------------------------------------------------------- - * - * Read all lines and return an array. - * - * duk_ret_turns: - * An array with all lines. - * Throws - * - Any exception on error. - */ -duk_ret_t methodLines(duk_context *ctx) -{ - duk_push_array(ctx); - - std::FILE *fp = self(ctx)->handle(); - std::string buffer; - std::array data; - std::int32_t i = 0; - - while (std::fgets(&data[0], data.size(), fp) != nullptr) { - buffer += data.data(); - - auto pos = buffer.find('\n'); - - if (pos != std::string::npos) { - dukx_push_std_string(ctx, clearCr(buffer.substr(0, pos))); - duk_put_prop_index(ctx, -2, i++); - - buffer.erase(0, pos + 1); - } - } - - // Maybe an error in the stream. - if (std::ferror(fp)) - dukx_throw(ctx, SystemError()); - - // Missing '\n' in end of file. - if (!buffer.empty()) { - dukx_push_std_string(ctx, clearCr(buffer)); - duk_put_prop_index(ctx, -2, i++); - } - - return 1; -} - -/* - * Method: File.read(amount) - * -------------------------------------------------------- - * - * Read the specified amount of characters or the whole file. - * - * Arguments: - * - amount, the amount of characters or -1 to read all (Optional, default: -1). - * duk_ret_turns: - * The string. - * Throws: - * - Any exception on error. - */ -duk_ret_t methodRead(duk_context *ctx) -{ - auto file = self(ctx); - auto amount = duk_is_number(ctx, 0) ? duk_get_int(ctx, 0) : -1; - - if (amount == 0 || file->handle() == nullptr) - return 0; - - try { - std::string data; - std::size_t total = 0; - - if (amount < 0) { - std::array buffer; - std::size_t nread; - - while ((nread = std::fread(&buffer[0], sizeof (buffer[0]), buffer.size(), file->handle())) > 0) { - if (std::ferror(file->handle())) - dukx_throw(ctx, SystemError()); - - std::copy(buffer.begin(), buffer.begin() + nread, std::back_inserter(data)); - total += nread; - } - } else { - data.resize((std::size_t)amount); - total = std::fread(&data[0], sizeof (data[0]), (std::size_t)amount, file->handle()); - - if (std::ferror(file->handle())) - dukx_throw(ctx, SystemError()); - - data.resize(total); - } - - dukx_push_std_string(ctx, data); - } catch (const std::exception &) { - dukx_throw(ctx, SystemError()); - } - - return 1; -} - -/* - * Method: File.readline() - * -------------------------------------------------------- - * - * Read the next line available. - * - * duk_ret_turns: - * The next line or undefined if eof. - * Throws: - * - Any exception on error. - */ -duk_ret_t methodReadline(duk_context *ctx) -{ - std::FILE *fp = self(ctx)->handle(); - std::string result; - - if (fp == nullptr || std::feof(fp)) - return 0; - for (int ch; (ch = std::fgetc(fp)) != EOF && ch != '\n'; ) - result += (char)ch; - if (std::ferror(fp)) - dukx_throw(ctx, SystemError()); - - dukx_push_std_string(ctx, clearCr(result)); - - return 1; -} - -/* - * Method: File.remove() - * -------------------------------------------------------- - * - * Synonym of File.remove(path) but with the path from the file. - * - * Throws: - * - Any exception on error. - */ -duk_ret_t methodRemove(duk_context *ctx) -{ - if (::remove(self(ctx)->path().c_str()) < 0) - dukx_throw(ctx, SystemError()); - - return 0; -} - -/* - * Method: File.seek(type, amount) - * -------------------------------------------------------- - * - * Sets the position in the file. - * - * Arguments: - * - type, the type of setting (File.SeekSet, File.SeekCur, File.SeekSet), - * - amount, the new offset. - * Throws: - * - Any exception on error. - */ -duk_ret_t methodSeek(duk_context *ctx) -{ - auto fp = self(ctx)->handle(); - auto type = duk_require_int(ctx, 0); - auto amount = duk_require_int(ctx, 1); - - if (fp != nullptr && std::fseek(fp, amount, type) != 0) - dukx_throw(ctx, SystemError()); - - return 0; -} - -#if defined(HAVE_STAT) - -/* - * Method: File.stat() [optional] - * -------------------------------------------------------- - * - * Synonym of File.stat(path) but with the path from the file. - * - * duk_ret_turns: - * The stat information. - * Throws: - * - Any exception on error. - */ -duk_ret_t methodStat(duk_context *ctx) -{ - auto file = self(ctx); - struct stat st; - - if (file->handle() == nullptr && ::stat(file->path().c_str(), &st) < 0) - dukx_throw(ctx, SystemError()); - else - pushStat(ctx, st); - - return 1; -} - -#endif // !HAVE_STAT - -/* - * Method: File.tell() - * -------------------------------------------------------- - * - * Get the actual position in the file. - * - * duk_ret_turns: - * The position. - * Throws: - * - Any exception on error. - */ -duk_ret_t methodTell(duk_context *ctx) -{ - auto fp = self(ctx)->handle(); - long pos; - - if (fp == nullptr) - return 0; - - if ((pos = std::ftell(fp)) == -1L) - dukx_throw(ctx, SystemError()); - else - duk_push_int(ctx, pos); - - return 1; -} - -/* - * Method: File.write(data) - * -------------------------------------------------------- - * - * Write some characters to the file. - * - * Arguments: - * - data, the character to write. - * duk_ret_turns: - * The number of bytes written. - * Throws: - * - Any exception on error. - */ -duk_ret_t methodWrite(duk_context *ctx) -{ - std::FILE *fp = self(ctx)->handle(); - std::string data = duk_require_string(ctx, 0); - - if (fp == nullptr) - return 0; - - std::size_t nwritten = std::fwrite(data.c_str(), 1, data.length(), fp); - - if (std::ferror(fp)) - dukx_throw(ctx, SystemError()); - - duk_push_uint(ctx, nwritten); - - return 1; -} - -const duk_function_list_entry methods[] = { - { "basename", methodBasename, 0 }, - { "close", methodClose, 0 }, - { "dirname", methodDirname, 0 }, - { "lines", methodLines, 0 }, - { "read", methodRead, 1 }, - { "readline", methodReadline, 0 }, - { "remove", methodRemove, 0 }, - { "seek", methodSeek, 2 }, -#if defined(HAVE_STAT) - { "stat", methodStat, 0 }, -#endif - { "tell", methodTell, 0 }, - { "write", methodWrite, 1 }, - { nullptr, nullptr, 0 } -}; - -/* - * File "static" functions - * ------------------------------------------------------------------ - */ - -/* - * Function: Irccd.File(path, mode) [constructor] - * -------------------------------------------------------- - * - * Open a file specified by path with the specified mode. - * - * Arguments: - * - path, the path to the file, - * - mode, the mode string. - * Throws: - * - Any exception on error. - */ -duk_ret_t constructor(duk_context *ctx) -{ - if (!duk_is_constructor_call(ctx)) - return 0; - - try { - dukx_new_file(ctx, new File(duk_require_string(ctx, 0), duk_require_string(ctx, 1))); - } catch (const std::exception &) { - dukx_throw(ctx, SystemError()); - } - - return 0; -} - -/* - * Function: Irccd.File() [destructor] - * ------------------------------------------------------------------ - * - * Delete the property. - */ -duk_ret_t destructor(duk_context *ctx) -{ - duk_get_prop_string(ctx, 0, Signature); - delete static_cast(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - duk_del_prop_string(ctx, 0, Signature); - - return 0; -} - -/* - * Function: Irccd.File.basename(path) - * -------------------------------------------------------- - * - * duk_ret_turn the file basename as specified in `basename(3)` C function. - * - * Arguments: - * - path, the path to the file. - * duk_ret_turns: - * The base name. - */ -duk_ret_t functionBasename(duk_context *ctx) -{ - dukx_push_std_string(ctx, fs::baseName(duk_require_string(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.File.dirname(path) - * -------------------------------------------------------- - * - * duk_ret_turn the file directory name as specified in `dirname(3)` C function. - * - * Arguments: - * - path, the path to the file. - * duk_ret_turns: - * The directory name. - */ -duk_ret_t functionDirname(duk_context *ctx) -{ - dukx_push_std_string(ctx, fs::dirName(duk_require_string(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.File.exists(path) - * -------------------------------------------------------- - * - * Check if the file exists. - * - * Arguments: - * - path, the path to the file. - * duk_ret_turns: - * True if exists. - * Throws: - * - Any exception if we don't have access. - */ -duk_ret_t functionExists(duk_context *ctx) -{ - try { - duk_push_boolean(ctx, boost::filesystem::exists(duk_require_string(ctx, 0))); - } catch (...) { - duk_push_boolean(ctx, false); - } - - return 1; -} - -/* - * function Irccd.File.remove(path) - * -------------------------------------------------------- - * - * Remove the file at the specified path. - * - * Arguments: - * - path, the path to the file. - * Throws: - * - Any exception on error. - */ -duk_ret_t functionRemove(duk_context *ctx) -{ - if (::remove(duk_require_string(ctx, 0)) < 0) - dukx_throw(ctx, SystemError()); - - return 0; -} - -#if defined(HAVE_STAT) - -/* - * function Irccd.File.stat(path) [optional] - * -------------------------------------------------------- - * - * Get file information at the specified path. - * - * Arguments: - * - path, the path to the file. - * duk_ret_turns: - * The stat information. - * Throws: - * - Any exception on error. - */ -duk_ret_t functionStat(duk_context *ctx) -{ - struct stat st; - - if (::stat(duk_require_string(ctx, 0), &st) < 0) - dukx_throw(ctx, SystemError()); - - pushStat(ctx, st); - - return 1; -} - -#endif // !HAVE_STAT - -const duk_function_list_entry functions[] = { - { "basename", functionBasename, 1 }, - { "dirname", functionDirname, 1 }, - { "exists", functionExists, 1 }, - { "remove", functionRemove, 1 }, -#if defined(HAVE_STAT) - { "stat", functionStat, 1 }, -#endif - { nullptr, nullptr, 0 } -}; - -const duk_number_list_entry constants[] = { - { "SeekCur", SEEK_CUR }, - { "SeekEnd", SEEK_END }, - { "SeekSet", SEEK_SET }, - { nullptr, 0 } -}; - -} // !namespace - -FileModule::FileModule() noexcept - : Module("Irccd.File") -{ -} - -void FileModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_c_function(plugin->context(), constructor, 2); - duk_put_number_list(plugin->context(), -1, constants); - duk_put_function_list(plugin->context(), -1, functions); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, methods); - duk_push_c_function(plugin->context(), destructor, 1); - duk_set_finalizer(plugin->context(), -2); - duk_dup(plugin->context(), -1); - duk_put_global_string(plugin->context(), Prototype); - duk_put_prop_string(plugin->context(), -2, "prototype"); - duk_put_prop_string(plugin->context(), -2, "File"); - duk_pop(plugin->context()); -} - -void dukx_new_file(duk_context *ctx, File *fp) -{ - assert(ctx); - assert(fp); - - StackAssert sa(ctx); - - duk_push_this(ctx); - duk_push_pointer(ctx, fp); - duk_put_prop_string(ctx, -2, Signature); - duk_pop(ctx); -} - -void dukx_push_file(duk_context *ctx, File *fp) -{ - assert(ctx); - assert(fp); - - StackAssert sa(ctx, 1); - - duk_push_object(ctx); - duk_push_pointer(ctx, fp); - duk_put_prop_string(ctx, -2, Signature); - duk_get_global_string(ctx, Prototype); - duk_set_prototype(ctx, -2); -} - -File *dukx_require_file(duk_context *ctx, duk_idx_t index) -{ - if (!duk_is_object(ctx, index) || !duk_has_prop_string(ctx, index, Signature)) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a File object"); - - duk_get_prop_string(ctx, index, Signature); - File *file = static_cast(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - - return file; -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-file.hpp --- a/libirccd-js/irccd/mod-file.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,184 +0,0 @@ -/* - * mod-file.hpp -- Irccd.File API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_FILE_HPP -#define IRCCD_MOD_FILE_HPP - -/** - * \file mod-file.hpp - * \brief Irccd.File JavaScript API. - */ - -#include -#include -#include -#include -#include -#include -#include - -#include "duktape.hpp" -#include "module.hpp" - -namespace irccd { - -/** - * \brief Object for Javascript to perform I/O. - * - * This class can be constructed to Javascript. - * - * It is used in: - * - * - Irccd.File [constructor] - * - Irccd.System.popen (optional) - */ -class File { -private: - File(const File &) = delete; - File &operator=(const File &) = delete; - - File(File &&) = delete; - File &operator=(File &&) = delete; - -private: - std::string m_path; - std::FILE *m_stream; - std::function m_destructor; - -public: - /** - * Construct a file specified by path - * - * \param path the path - * \param mode the mode string (for std::fopen) - * \throw std::runtime_error on failures - */ - inline File(std::string path, const std::string &mode) - : m_path(std::move(path)) - , m_destructor([] (std::FILE *fp) { std::fclose(fp); }) - { - if ((m_stream = std::fopen(m_path.c_str(), mode.c_str())) == nullptr) - throw std::runtime_error(std::strerror(errno)); - } - - /** - * Construct a file from a already created FILE pointer (e.g. popen). - * - * The class takes ownership of fp and will close it. - * - * \pre destructor must not be null - * \param fp the file pointer - * \param destructor the function to close fp (e.g. std::fclose) - */ - inline File(std::FILE *fp, std::function destructor) noexcept - : m_stream(fp) - , m_destructor(std::move(destructor)) - { - assert(m_destructor != nullptr); - } - - /** - * Closes the file. - */ - virtual ~File() noexcept - { - close(); - } - - /** - * Get the path. - * - * \return the path - * \warning empty when constructed from the FILE constructor - */ - inline const std::string &path() const noexcept - { - return m_path; - } - - /** - * Get the handle. - * - * \return the handle or nullptr if the stream was closed - */ - inline std::FILE *handle() noexcept - { - return m_stream; - } - - /** - * Force close, can be safely called multiple times. - */ - inline void close() noexcept - { - if (m_stream) { - m_destructor(m_stream); - m_stream = nullptr; - } - } -}; - -/** - * \brief Irccd.File JavaScript API. - * \ingroup modules - */ -class FileModule : public Module { -public: - /** - * Irccd.File. - */ - IRCCD_EXPORT FileModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -/** - * Construct the file as this. - * - * The object prototype takes ownership of fp and will be deleted once - * collected. - * - * \pre fp != nullptr - * \param ctx the the context - * \param fp the file - */ -IRCCD_EXPORT void dukx_new_file(duk_context *ctx, File *fp); - -/** - * Push a file. - * - * \pre fp != nullptr - * \param ctx the the context - * \param fp the file - */ -IRCCD_EXPORT void dukx_push_file(duk_context *ctx, File *fp); - -/** - * Require a file. Raises a JavaScript error if not a File. - * - * \param ctx the context - * \param index the index - */ -IRCCD_EXPORT File *dukx_require_file(duk_context *ctx, duk_idx_t index); - -} // !irccd - -#endif // !IRCCD_MOD_FILE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-irccd.cpp --- a/libirccd-js/irccd/mod-irccd.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,231 +0,0 @@ -/* - * mod-irccd.cpp -- Irccd API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include -#include -#include - -#include "mod-irccd.hpp" -#include "plugin-js.hpp" -#include "sysconfig.hpp" - -namespace irccd { - -namespace { - -const std::unordered_map errors{ - { "E2BIG", E2BIG }, - { "EACCES", EACCES }, - { "EADDRINUSE", EADDRINUSE }, - { "EADDRNOTAVAIL", EADDRNOTAVAIL }, - { "EAFNOSUPPORT", EAFNOSUPPORT }, - { "EAGAIN", EAGAIN }, - { "EALREADY", EALREADY }, - { "EBADF", EBADF }, -#if defined(EBADMSG) - { "EBADMSG", EBADMSG }, -#endif - { "EBUSY", EBUSY }, - { "ECANCELED", ECANCELED }, - { "ECHILD", ECHILD }, - { "ECONNABORTED", ECONNABORTED }, - { "ECONNREFUSED", ECONNREFUSED }, - { "ECONNRESET", ECONNRESET }, - { "EDEADLK", EDEADLK }, - { "EDESTADDRREQ", EDESTADDRREQ }, - { "EDOM", EDOM }, - { "EEXIST", EEXIST }, - { "EFAULT", EFAULT }, - { "EFBIG", EFBIG }, - { "EHOSTUNREACH", EHOSTUNREACH }, -#if defined(EIDRM) - { "EIDRM", EIDRM }, -#endif - { "EILSEQ", EILSEQ }, - { "EINPROGRESS", EINPROGRESS }, - { "EINTR", EINTR }, - { "EINVAL", EINVAL }, - { "EIO", EIO }, - { "EISCONN", EISCONN }, - { "EISDIR", EISDIR }, - { "ELOOP", ELOOP }, - { "EMFILE", EMFILE }, - { "EMLINK", EMLINK }, - { "EMSGSIZE", EMSGSIZE }, - { "ENAMETOOLONG", ENAMETOOLONG }, - { "ENETDOWN", ENETDOWN }, - { "ENETRESET", ENETRESET }, - { "ENETUNREACH", ENETUNREACH }, - { "ENFILE", ENFILE }, - { "ENOBUFS", ENOBUFS }, -#if defined(ENODATA) - { "ENODATA", ENODATA }, -#endif - { "ENODEV", ENODEV }, - { "ENOENT", ENOENT }, - { "ENOEXEC", ENOEXEC }, - { "ENOLCK", ENOLCK }, -#if defined(ENOLINK) - { "ENOLINK", ENOLINK }, -#endif - { "ENOMEM", ENOMEM }, -#if defined(ENOMSG) - { "ENOMSG", ENOMSG }, -#endif - { "ENOPROTOOPT", ENOPROTOOPT }, - { "ENOSPC", ENOSPC }, -#if defined(ENOSR) - { "ENOSR", ENOSR }, -#endif -#if defined(ENOSTR) - { "ENOSTR", ENOSTR }, -#endif - { "ENOSYS", ENOSYS }, - { "ENOTCONN", ENOTCONN }, - { "ENOTDIR", ENOTDIR }, - { "ENOTEMPTY", ENOTEMPTY }, -#if defined(ENOTRECOVERABLE) - { "ENOTRECOVERABLE", ENOTRECOVERABLE }, -#endif - { "ENOTSOCK", ENOTSOCK }, - { "ENOTSUP", ENOTSUP }, - { "ENOTTY", ENOTTY }, - { "ENXIO", ENXIO }, - { "EOPNOTSUPP", EOPNOTSUPP }, - { "EOVERFLOW", EOVERFLOW }, - { "EOWNERDEAD", EOWNERDEAD }, - { "EPERM", EPERM }, - { "EPIPE", EPIPE }, - { "EPROTO", EPROTO }, - { "EPROTONOSUPPORT", EPROTONOSUPPORT }, - { "EPROTOTYPE", EPROTOTYPE }, - { "ERANGE", ERANGE }, - { "EROFS", EROFS }, - { "ESPIPE", ESPIPE }, - { "ESRCH", ESRCH }, -#if defined(ETIME) - { "ETIME", ETIME }, -#endif - { "ETIMEDOUT", ETIMEDOUT }, -#if defined(ETXTBSY) - { "ETXTBSY", ETXTBSY }, -#endif - { "EWOULDBLOCK", EWOULDBLOCK }, - { "EXDEV", EXDEV } -}; - -duk_ret_t constructor(duk_context *ctx) -{ - duk_push_this(ctx); - duk_push_int(ctx, duk_require_int(ctx, 0)); - duk_put_prop_string(ctx, -2, "errno"); - duk_push_string(ctx, duk_require_string(ctx, 1)); - duk_put_prop_string(ctx, -2, "message"); - duk_push_string(ctx, "SystemError"); - duk_put_prop_string(ctx, -2, "name"); - duk_pop(ctx); - - return 0; -} - -} // !namespace - -SystemError::SystemError() - : m_errno(errno) - , m_message(std::strerror(m_errno)) -{ -} - -SystemError::SystemError(int e, std::string message) - : m_errno(e) - , m_message(std::move(message)) -{ -} - -void SystemError::raise(duk_context *ctx) const -{ - StackAssert sa(ctx, 0); - - duk_get_global_string(ctx, "Irccd"); - duk_get_prop_string(ctx, -1, "SystemError"); - duk_remove(ctx, -2); - duk_push_int(ctx, m_errno); - dukx_push_std_string(ctx, m_message); - duk_new(ctx, 2); - duk_throw(ctx); -} - -IrccdModule::IrccdModule() noexcept - : Module("Irccd") -{ -} - -void IrccdModule::load(Irccd &irccd, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - // Irccd. - duk_push_object(plugin->context()); - - // Version. - duk_push_object(plugin->context()); - duk_push_int(plugin->context(), IRCCD_VERSION_MAJOR); - duk_put_prop_string(plugin->context(), -2, "major"); - duk_push_int(plugin->context(), IRCCD_VERSION_MINOR); - duk_put_prop_string(plugin->context(), -2, "minor"); - duk_push_int(plugin->context(), IRCCD_VERSION_PATCH); - duk_put_prop_string(plugin->context(), -2, "patch"); - duk_put_prop_string(plugin->context(), -2, "version"); - - // Create the SystemError that inherits from Error. - duk_push_c_function(plugin->context(), constructor, 2); - - // Put errno codes into the Irccd.SystemError object. - for (const auto &pair : errors) { - duk_push_int(plugin->context(), pair.second); - duk_put_prop_string(plugin->context(), -2, pair.first.c_str()); - } - - duk_push_object(plugin->context()); - duk_get_global_string(plugin->context(), "Error"); - duk_get_prop_string(plugin->context(), -1, "prototype"); - duk_remove(plugin->context(), -2); - duk_set_prototype(plugin->context(), -2); - duk_put_prop_string(plugin->context(), -2, "prototype"); - duk_put_prop_string(plugin->context(), -2, "SystemError"); - - // Set Irccd as global. - duk_put_global_string(plugin->context(), "Irccd"); - - // Store global instance. - duk_push_pointer(plugin->context(), &irccd); - duk_put_global_string(plugin->context(), "\xff""\xff""irccd-ref"); -} - -Irccd &dukx_get_irccd(duk_context *ctx) -{ - StackAssert sa(ctx); - - duk_get_global_string(ctx, "\xff""\xff""irccd-ref"); - Irccd *irccd = static_cast(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - - return *irccd; -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-irccd.hpp --- a/libirccd-js/irccd/mod-irccd.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,93 +0,0 @@ -/* - * mod-irccd.hpp -- Irccd API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_IRCCD_HPP -#define IRCCD_MOD_IRCCD_HPP - -/** - * \file mod-irccd.hpp - * \brief Irccd JavaScript API. - */ - -#include -#include -#include - -#include "duktape.hpp" -#include "module.hpp" - -namespace irccd { - -/** - * \brief Custom JavaScript exception for system error. - */ -class SystemError { -private: - int m_errno; - std::string m_message; - -public: - /** - * Create a system error from the current errno value. - */ - IRCCD_EXPORT SystemError(); - - /** - * Create a system error with the given errno and message. - * - * \param e the errno number - * \param message the message - */ - IRCCD_EXPORT SystemError(int e, std::string message); - - /** - * Raise the SystemError. - * - * \param ctx the context - */ - IRCCD_EXPORT void raise(duk_context *ctx) const; -}; - -/** - * \brief Irccd JavaScript API. - * \ingroup modules - */ -class IrccdModule : public Module { -public: - /** - * Irccd. - */ - IRCCD_EXPORT IrccdModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -/** - * Get irccd instance stored in this context. - * - * \param ctx the context - * \return the irccd reference - */ -Irccd &dukx_get_irccd(duk_context *ctx); - -} // !irccd - -#endif // !IRCCD_MOD_IRCCD_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-logger.cpp --- a/libirccd-js/irccd/mod-logger.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,102 +0,0 @@ -/* - * mod-logger.cpp -- Irccd.Logger API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "mod-logger.hpp" -#include "mod-plugin.hpp" -#include "logger.hpp" -#include "plugin-js.hpp" - -namespace irccd { - -namespace { - -duk_ret_t print(duk_context *ctx, std::ostream &out) -{ - out << "plugin " << dukx_get_plugin(ctx)->name() << ": " << duk_require_string(ctx, 0) << std::endl; - - return 0; -} - -/* - * Function: Irccd.Logger.info(message) - * -------------------------------------------------------- - * - * Write a verbose message. - * - * Arguments: - * - message, the message. - */ -duk_ret_t info(duk_context *ctx) -{ - return print(ctx, log::info()); -} - -/* - * Function: Irccd.Logger.warning(message) - * -------------------------------------------------------- - * - * Write a warning message. - * - * Arguments: - * - message, the warning. - */ -duk_ret_t warning(duk_context *ctx) -{ - return print(ctx, log::warning()); -} - -/* - * Function: Logger.debug(message) - * -------------------------------------------------------- - * - * Write a debug message, only shown if irccd is compiled in debug. - * - * Arguments: - * - message, the message. - */ -duk_ret_t debug(duk_context *ctx) -{ - return print(ctx, log::debug()); -} - -const duk_function_list_entry functions[] = { - { "info", info, 1 }, - { "warning", warning, 1 }, - { "debug", debug, 1 }, - { nullptr, nullptr, 0 } -}; - -} // !namespace - -LoggerModule::LoggerModule() noexcept - : Module("Irccd.Logger") -{ -} - -void LoggerModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, functions); - duk_put_prop_string(plugin->context(), -2, "Logger"); - duk_pop(plugin->context()); -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-logger.hpp --- a/libirccd-js/irccd/mod-logger.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * mod-logger.hpp -- Irccd.Logger API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_LOGGER_HPP -#define IRCCD_MOD_LOGGER_HPP - -/** - * \file mod-logger.hpp - * \brief Irccd.Logger JavaScript API. - */ - -#include "module.hpp" - -namespace irccd { - -/** - * \brief Irccd.Logger JavaScript API. - * \ingroup modules - */ -class LoggerModule : public Module { -public: - /** - * Irccd.Logger. - */ - IRCCD_EXPORT LoggerModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -} // !irccd - -#endif // !IRCCD_MOD_LOGGER_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-plugin.cpp --- a/libirccd-js/irccd/mod-plugin.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,383 +0,0 @@ -/* - * mod-plugin.cpp -- Irccd.Plugin API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "irccd.hpp" -#include "plugin-js.hpp" -#include "service.hpp" -#include "mod-irccd.hpp" -#include "mod-plugin.hpp" - -namespace irccd { - -namespace { - -const char PluginGlobal[] = "\xff""\xff""irccd-plugin-ptr"; - -/* - * wrap - * ------------------------------------------------------------------ - * - * Wrap function for these functions because they all takes the same arguments. - * - * - load, - * - reload, - * - unload. - */ -template -duk_idx_t wrap(duk_context *ctx, int nret, Func &&func) -{ - std::string name = duk_require_string(ctx, 0); - - try { - func(dukx_get_irccd(ctx), name); - } catch (const std::out_of_range &ex) { - dukx_throw(ctx, ReferenceError(ex.what())); - } catch (const std::exception &ex) { - dukx_throw(ctx, Error(ex.what())); - } - - return nret; -} - -/* - * set - * ------------------------------------------------------------------ - * - * This setter is used to replace the Irccd.plugin->(config|format) property when - * the plugin assign a new one. - * - * Because the plugin configuration always has higher priority, when a new - * object is assigned to 'config' or to the 'format' property, the plugin - * configuration is merged to the assigned one, adding or replacing any values. - * - * Example: - * - * Plugin 'xyz' does: - * - * Irccd.plugin->config = { - * mode: "simple", - * level: "123" - * }; - * - * The user configuration is: - * - * [plugin->xyz] - * mode = "hard" - * path = "/var" - * - * The final user table looks like this: - * - * Irccd.plugin->config = { - * mode: "hard", - * level: "123", - * path: "/var" - */ -duk_ret_t set(duk_context *ctx, const char *name) -{ - if (!duk_is_object(ctx, 0)) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "'%s' property must be object", name); - - // Merge old table with new one. - duk_get_global_string(ctx, name); - duk_enum(ctx, -1, 0); - - while (duk_next(ctx, -1, true)) - duk_put_prop(ctx, 0); - - // Pop enum and old table. - duk_pop_2(ctx); - - // Replace the old table with the new assigned one. - duk_put_global_string(ctx, name); - - return 0; -} - -/* - * get - * ------------------------------------------------------------------ - * - * Get the Irccd.plugin->(config|format|paths) property. - */ -duk_ret_t get(duk_context *ctx, const char *name) -{ - duk_get_global_string(ctx, name); - - return 1; -} - -/* - * setConfig - * ------------------------------------------------------------------ - * - * Wrap setter for Irccd.plugin->config property. - */ -duk_ret_t setConfig(duk_context *ctx) -{ - return set(ctx, JsPlugin::ConfigProperty); -} - -/* - * getConfig - * ------------------------------------------------------------------ - * - * Wrap getter for Irccd.plugin->config property. - */ -duk_ret_t getConfig(duk_context *ctx) -{ - return get(ctx, JsPlugin::ConfigProperty); -} - -/* - * setFormat - * ------------------------------------------------------------------ - * - * Wrap setter for Irccd.plugin->format property. - */ -duk_ret_t setFormat(duk_context *ctx) -{ - return set(ctx, JsPlugin::FormatProperty); -} - -/* - * getFormat - * ------------------------------------------------------------------ - * - * Wrap getter for Irccd.plugin->format property. - */ -duk_ret_t getFormat(duk_context *ctx) -{ - return get(ctx, JsPlugin::FormatProperty); -} - -/* - * setPaths - * ------------------------------------------------------------------ - * - * Wrap setter for Irccd.plugin->format property. - */ -duk_ret_t setPaths(duk_context *ctx) -{ - return set(ctx, JsPlugin::PathsProperty); -} - -/* - * getPaths - * ------------------------------------------------------------------ - * - * Wrap getter for Irccd.plugin->format property. - */ -duk_ret_t getPaths(duk_context *ctx) -{ - return get(ctx, JsPlugin::PathsProperty); -} - -/* - * Function: Irccd.plugin.info([name]) - * ------------------------------------------------------------------ - * - * Get information about a plugin-> - * - * The returned object as the following properties: - * - * - name: (string) the plugin identifier, - * - author: (string) the author, - * - license: (string) the license, - * - summary: (string) a short description, - * - version: (string) the version - * - * Arguments: - * - name, the plugin identifier, if not specified the current plugin is - * selected. - * Returns: - * The plugin information or undefined if the plugin was not found. - */ -duk_idx_t info(duk_context *ctx) -{ - std::shared_ptr plugin; - - if (duk_get_top(ctx) >= 1) - plugin = dukx_get_irccd(ctx).plugins().get(duk_require_string(ctx, 0)); - else - plugin = dukx_get_plugin(ctx); - - if (!plugin) - return 0; - - duk_push_object(ctx); - dukx_push_std_string(ctx, plugin->name()); - duk_put_prop_string(ctx, -2, "name"); - dukx_push_std_string(ctx, plugin->author()); - duk_put_prop_string(ctx, -2, "author"); - dukx_push_std_string(ctx, plugin->license()); - duk_put_prop_string(ctx, -2, "license"); - dukx_push_std_string(ctx, plugin->summary()); - duk_put_prop_string(ctx, -2, "summary"); - dukx_push_std_string(ctx, plugin->version()); - duk_put_prop_string(ctx, -2, "version"); - - return 1; -} - -/* - * Function: Irccd.plugin->list() - * ------------------------------------------------------------------ - * - * Get the list of plugins, the array returned contains all plugin names. - * - * Returns: - * The list of all plugin names. - */ -duk_idx_t list(duk_context *ctx) -{ - dukx_push_array(ctx, dukx_get_irccd(ctx).plugins().list(), [] (auto ctx, auto plugin) { - dukx_push_std_string(ctx, plugin->name()); - }); - - return 1; -} - -/* - * Function: Irccd.plugin->load(name) - * ------------------------------------------------------------------ - * - * Load a plugin by name. This function will search through the standard - * directories. - * - * Arguments: - * - name, the plugin identifier. - * Throws: - * - Error on errors, - * - ReferenceError if the plugin was not found. - */ -duk_idx_t load(duk_context *ctx) -{ - return wrap(ctx, 0, [&] (Irccd &irccd, const std::string &name) { - irccd.plugins().load(name); - }); -} - -/* - * Function: Irccd.plugin->reload(name) - * ------------------------------------------------------------------ - * - * Reload a plugin by name. - * - * Arguments: - * - name, the plugin identifier. - * Throws: - * - Error on errors, - * - ReferenceError if the plugin was not found. - */ -duk_idx_t reload(duk_context *ctx) -{ - return wrap(ctx, 0, [&] (Irccd &irccd, const std::string &name) { - irccd.plugins().reload(name); - }); -} - -/* - * Function: Irccd.plugin->unload(name) - * ------------------------------------------------------------------ - * - * Unload a plugin by name. - * - * Arguments: - * - name, the plugin identifier. - * Throws: - * - Error on errors, - * - ReferenceError if the plugin was not found. - */ -duk_idx_t unload(duk_context *ctx) -{ - return wrap(ctx, 0, [&] (Irccd &irccd, const std::string &name) { - irccd.plugins().unload(name); - }); -} - -const duk_function_list_entry functions[] = { - { "info", info, DUK_VARARGS }, - { "list", list, 0 }, - { "load", load, 1 }, - { "reload", reload, 1 }, - { "unload", unload, 1 }, - { nullptr, nullptr, 0 } -}; - -} // !namespace - -PluginModule::PluginModule() noexcept - : Module("Irccd.Plugin") -{ -} - -void PluginModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_push_pointer(plugin->context(), new std::weak_ptr(plugin)); - duk_push_object(plugin->context()); - duk_push_c_function(plugin->context(), [] (auto *ctx) -> duk_ret_t { - duk_get_global_string(ctx, PluginGlobal); - delete static_cast *>(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - duk_push_null(ctx); - duk_put_global_string(ctx, PluginGlobal); - return 0; - }, 1); - duk_set_finalizer(plugin->context(), -2); - duk_put_global_string(plugin->context(), "\xff""\xff""dummy-shared-ptr"); - duk_put_global_string(plugin->context(), PluginGlobal); - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, functions); - - // 'config' property. - duk_push_string(plugin->context(), "config"); - duk_push_c_function(plugin->context(), getConfig, 0); - duk_push_c_function(plugin->context(), setConfig, 1); - duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER); - - // 'format' property. - duk_push_string(plugin->context(), "format"); - duk_push_c_function(plugin->context(), getFormat, 0); - duk_push_c_function(plugin->context(), setFormat, 1); - duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER); - - // 'format' property. - duk_push_string(plugin->context(), "paths"); - duk_push_c_function(plugin->context(), getPaths, 0); - duk_push_c_function(plugin->context(), setPaths, 1); - duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER); - - duk_put_prop_string(plugin->context(), -2, "Plugin"); - duk_pop(plugin->context()); -} - -std::shared_ptr dukx_get_plugin(duk_context *ctx) -{ - StackAssert sa(ctx); - - duk_get_global_string(ctx, PluginGlobal); - auto plugin = static_cast *>(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - - return plugin->lock(); -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-plugin.hpp --- a/libirccd-js/irccd/mod-plugin.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,59 +0,0 @@ -/* - * mod-plugin.hpp -- Irccd.Plugin API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_PLUGIN_HPP -#define IRCCD_MOD_PLUGIN_HPP - -/** - * \file mod-plugin.hpp - * \brief Irccd.Plugin JavaScript API. - */ - -#include "duktape.hpp" -#include "module.hpp" - -namespace irccd { - -/** - * \brief Irccd.Plugin JavaScript API. - * \ingroup modules - */ -class PluginModule : public Module { -public: - /** - * Irccd.Plugin. - */ - IRCCD_EXPORT PluginModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -/** - * Access the plugin stored in this context. - * - * \param ctx the context - * \return the plugin - */ -std::shared_ptr dukx_get_plugin(duk_context *ctx); - -} // !irccd - -#endif // !IRCCD_MOD_PLUGIN_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-server.cpp --- a/libirccd-js/irccd/mod-server.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,580 +0,0 @@ -/* - * mod-server.cpp -- Irccd.Server API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include -#include -#include - -#include "irccd.hpp" -#include "mod-irccd.hpp" -#include "mod-server.hpp" -#include "plugin-js.hpp" -#include "server.hpp" -#include "service.hpp" - -namespace irccd { - -namespace { - -const char *Signature("\xff""\xff""irccd-server-ptr"); -const char *Prototype("\xff""\xff""irccd-server-prototype"); - -std::shared_ptr self(duk_context *ctx) -{ - StackAssert sa(ctx); - - duk_push_this(ctx); - duk_get_prop_string(ctx, -1, Signature); - auto ptr = duk_to_pointer(ctx, -1); - duk_pop_2(ctx); - - if (!ptr) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object"); - - return *static_cast *>(ptr); -} - -/* - * Method: Server.cmode(channel, mode) - * ------------------------------------------------------------------ - * - * Change a channel mode. - * - * Arguments: - * - channel, the channel, - * - mode, the mode. - */ -duk_ret_t cmode(duk_context *ctx) -{ - self(ctx)->cmode(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.cnotice(channel, message) - * ------------------------------------------------------------------ - * - * Send a channel notice. - * - * Arguments: - * - channel, the channel, - * - message, the message. - */ -duk_ret_t cnotice(duk_context *ctx) -{ - self(ctx)->cnotice(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.info() - * ------------------------------------------------------------------ - * - * Get the server information as an object containing the following properties: - * - * name: the server unique name - * host: the host name - * port: the port number - * ssl: true if using ssl - * sslVerify: true if ssl was verified - * channels: an array of all channels - */ -duk_ret_t info(duk_context *ctx) -{ - auto server = self(ctx); - - duk_push_object(ctx); - dukx_push_std_string(ctx, server->name()); - duk_put_prop_string(ctx, -2, "name"); - dukx_push_std_string(ctx, server->host()); - duk_put_prop_string(ctx, -2, "host"); - duk_push_int(ctx, server->port()); - duk_put_prop_string(ctx, -2, "port"); - duk_push_boolean(ctx, server->flags() & Server::Ssl); - duk_put_prop_string(ctx, -2, "ssl"); - duk_push_boolean(ctx, server->flags() & Server::SslVerify); - duk_put_prop_string(ctx, -2, "sslVerify"); - dukx_push_std_string(ctx, server->commandCharacter()); - duk_put_prop_string(ctx, -2, "commandChar"); - dukx_push_std_string(ctx, server->realname()); - duk_put_prop_string(ctx, -2, "realname"); - dukx_push_std_string(ctx, server->nickname()); - duk_put_prop_string(ctx, -2, "nickname"); - dukx_push_std_string(ctx, server->username()); - duk_put_prop_string(ctx, -2, "username"); - dukx_push_array(ctx, server->channels(), [&] (auto ctx, auto channel) { - dukx_push_std_string(ctx, channel); - }); - duk_put_prop_string(ctx, -2, "channels"); - - return 1; -} - -/* - * Method: Server.invite(target, channel) - * ------------------------------------------------------------------ - * - * Invite someone to a channel. - * - * Arguments: - * - target, the target to invite, - * - channel, the channel. - */ -duk_ret_t invite(duk_context *ctx) -{ - self(ctx)->invite(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.join(channel, password = undefined) - * ------------------------------------------------------------------ - * - * Join a channel with an optional password. - * - * Arguments: - * - channel, the channel to join, - * - password, the password or undefined to not use. - */ -duk_ret_t join(duk_context *ctx) -{ - self(ctx)->join(duk_require_string(ctx, 0), dukx_get_std_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.kick(target, channel, reason = undefined) - * ------------------------------------------------------------------ - * - * Kick someone from a channel. - * - * Arguments: - * - target, the target to kick, - * - channel, the channel, - * - reason, the optional reason or undefined to not set. - */ -duk_ret_t kick(duk_context *ctx) -{ - self(ctx)->kick(duk_require_string(ctx, 0), duk_require_string(ctx, 1), dukx_get_std_string(ctx, 2)); - - return 0; -} - -/* - * Method: Server.me(target, message) - * ------------------------------------------------------------------ - * - * Send a CTCP Action. - * - * Arguments: - * - target, the target or a channel, - * - message, the message. - */ -duk_ret_t me(duk_context *ctx) -{ - self(ctx)->me(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.message(target, message) - * ------------------------------------------------------------------ - * - * Send a message. - * - * Arguments: - * - target, the target or a channel, - * - message, the message. - */ -duk_ret_t message(duk_context *ctx) -{ - self(ctx)->message(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.mode(mode) - * ------------------------------------------------------------------ - * - * Change your mode. - * - * Arguments: - * - mode, the new mode. - */ -duk_ret_t mode(duk_context *ctx) -{ - self(ctx)->mode(duk_require_string(ctx, 0)); - - return 0; -} - -/* - * Method: Server.names(channel) - * ------------------------------------------------------------------ - * - * Get the list of names from a channel. - * - * Arguments: - * - channel, the channel. - */ -duk_ret_t names(duk_context *ctx) -{ - self(ctx)->names(duk_require_string(ctx, 0)); - - return 0; -} - -/* - * Method: Server.nick(nickname) - * ------------------------------------------------------------------ - * - * Change the nickname. - * - * Arguments: - * - nickname, the nickname. - */ -duk_ret_t nick(duk_context *ctx) -{ - self(ctx)->setNickname(duk_require_string(ctx, 0)); - - return 0; -} - -/* - * Method: Server.notice(target, message) - * ------------------------------------------------------------------ - * - * Send a private notice. - * - * Arguments: - * - target, the target, - * - message, the notice message. - */ -duk_ret_t notice(duk_context *ctx) -{ - self(ctx)->notice(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.part(channel, reason = undefined) - * ------------------------------------------------------------------ - * - * Leave a channel. - * - * Arguments: - * - channel, the channel to leave, - * - reason, the optional reason, keep undefined for portability. - */ -duk_ret_t part(duk_context *ctx) -{ - self(ctx)->part(duk_require_string(ctx, 0), dukx_get_std_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.send(raw) - * ------------------------------------------------------------------ - * - * Send a raw message to the IRC server. - * - * Arguments: - * - raw, the raw message (without terminators). - */ -duk_ret_t send(duk_context *ctx) -{ - self(ctx)->send(duk_require_string(ctx, 0)); - - return 0; -} - -/* - * Method: Server.topic(channel, topic) - * ------------------------------------------------------------------ - * - * Change a channel topic. - * - * Arguments: - * - channel, the channel, - * - topic, the new topic. - */ -duk_ret_t topic(duk_context *ctx) -{ - self(ctx)->topic(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - return 0; -} - -/* - * Method: Server.whois(target) - * ------------------------------------------------------------------ - * - * Get whois information. - * - * Arguments: - * - target, the target. - */ -duk_ret_t whois(duk_context *ctx) -{ - self(ctx)->whois(duk_require_string(ctx, 0)); - - return 0; -} - -/* - * Method: Server.toString() - * ------------------------------------------------------------------ - * - * Convert the object to std::string, convenience for adding the object - * as property key. - * - * duk_ret_turns: - * The server name (unique). - */ -duk_ret_t toString(duk_context *ctx) -{ - dukx_push_std_string(ctx, self(ctx)->name()); - - return 1; -} - -/* - * Function: Irccd.Server(params) [constructor] - * ------------------------------------------------------------------ - * - * Construct a new server. - * - * Params must be filled with the following properties: - * - * name: the name, - * host: the host, - * ipv6: true to use ipv6, (Optional: default false) - * port: the port number, (Optional: default 6667) - * password: the password, (Optional: default none) - * channels: array of channels (Optiona: default empty) - * ssl: true to use ssl, (Optional: default false) - * sslVerify: true to verify (Optional: default true) - * nickname: "nickname", (Optional, default: irccd) - * username: "user name", (Optional, default: irccd) - * realname: "real name", (Optional, default: IRC Client Daemon) - * commandChar: "!", (Optional, the command char, default: "!") - */ -duk_ret_t constructor(duk_context *ctx) -{ - if (!duk_is_constructor_call(ctx)) - return 0; - - duk_check_type(ctx, 0, DUK_TYPE_OBJECT); - - try { - auto json = duk_json_encode(ctx, 0); - auto s = Server::fromJson(nlohmann::json::parse(json)); - - duk_push_this(ctx); - duk_push_pointer(ctx, new std::shared_ptr(std::move(s))); - duk_put_prop_string(ctx, -2, Signature); - duk_pop(ctx); - } catch (const std::exception &ex) { - duk_error(ctx, DUK_ERR_ERROR, "%s", ex.what()); - } - - return 0; -} - -/* - * Function: Irccd.Server() [destructor] - * ------------------------------------------------------------------ - * - * Delete the property. - */ -duk_ret_t destructor(duk_context *ctx) -{ - duk_get_prop_string(ctx, 0, Signature); - delete static_cast *>(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - duk_del_prop_string(ctx, 0, Signature); - - return 0; -} - -/* - * Function: Irccd.Server.add(s) - * ------------------------------------------------------------------ - * - * Register a new server to the irccd instance. - * - * Arguments: - * - s, the server to add. - */ -duk_ret_t add(duk_context *ctx) -{ - dukx_get_irccd(ctx).servers().add(dukx_require_server(ctx, 0)); - - return 0; -} - -/* - * Function: Irccd.Server.find(name) - * ------------------------------------------------------------------ - * - * Find a server by name. - * - * Arguments: - * - name, the server name - * duk_ret_turns: - * The server object or undefined if not found. - */ -duk_ret_t find(duk_context *ctx) -{ - auto server = dukx_get_irccd(ctx).servers().get(duk_require_string(ctx, 0)); - - if (!server) - return 0; - - dukx_push_server(ctx, server); - - return 1; -} - -/* - * Function: Irccd.Server.list() - * ------------------------------------------------------------------ - * - * Get the map of all loaded servers. - * - * duk_ret_turns: - * An object with string-to-servers pairs. - */ -duk_ret_t list(duk_context *ctx) -{ - duk_push_object(ctx); - - for (const auto &server : dukx_get_irccd(ctx).servers().servers()) { - dukx_push_server(ctx, server); - duk_put_prop_string(ctx, -2, server->name().c_str()); - } - - return 1; -} - -/* - * Function: Irccd.Server.remove(name) - * ------------------------------------------------------------------ - * - * Remove a server from the irccd instance. You can pass the server object since - * it's coercible to a string. - * - * Arguments: - * - name the server name. - */ -duk_ret_t remove(duk_context *ctx) -{ - dukx_get_irccd(ctx).servers().remove(duk_require_string(ctx, 0)); - - return 0; -} - -const duk_function_list_entry methods[] = { - { "cmode", cmode, 2 }, - { "cnotice", cnotice, 2 }, - { "info", info, 0 }, - { "invite", invite, 2 }, - { "join", join, DUK_VARARGS }, - { "kick", kick, DUK_VARARGS }, - { "me", me, 2 }, - { "message", message, 2 }, - { "mode", mode, 1 }, - { "names", names, 1 }, - { "nick", nick, 1 }, - { "notice", notice, 2 }, - { "part", part, DUK_VARARGS }, - { "send", send, 1 }, - { "topic", topic, 2 }, - { "whois", whois, 1 }, - { "toString", toString, 0 }, - { nullptr, nullptr, 0 } -}; - -const duk_function_list_entry functions[] = { - { "add", add, 1 }, - { "find", find, 1 }, - { "list", list, 0 }, - { "remove", remove, 1 }, - { nullptr, nullptr, 0 } -}; - -} // !namespace - -ServerModule::ServerModule() noexcept - : Module("Irccd.Server") -{ -} - -void ServerModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_c_function(plugin->context(), constructor, 1); - duk_put_function_list(plugin->context(), -1, functions); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, methods); - duk_push_c_function(plugin->context(), destructor, 1); - duk_set_finalizer(plugin->context(), -2); - duk_dup_top(plugin->context()); - duk_put_global_string(plugin->context(), Prototype); - duk_put_prop_string(plugin->context(), -2, "prototype"); - duk_put_prop_string(plugin->context(), -2, "Server"); - duk_pop(plugin->context()); -} - -void dukx_push_server(duk_context *ctx, std::shared_ptr server) -{ - assert(ctx); - assert(server); - - StackAssert sa(ctx, 1); - - duk_push_object(ctx); - duk_push_pointer(ctx, new std::shared_ptr(std::move(server))); - duk_put_prop_string(ctx, -2, Signature); - duk_get_global_string(ctx, Prototype); - duk_set_prototype(ctx, -2); -} - -std::shared_ptr dukx_require_server(duk_context *ctx, duk_idx_t index) -{ - if (!duk_is_object(ctx, index) || !duk_has_prop_string(ctx, index, Signature)) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object"); - - duk_get_prop_string(ctx, index, Signature); - auto file = *static_cast *>(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - - return file; -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-server.hpp --- a/libirccd-js/irccd/mod-server.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,70 +0,0 @@ -/* - * mod-server.hpp -- Irccd.Server API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_SERVER_HPP -#define IRCCD_MOD_SERVER_HPP - -/** - * \file mod-server.hpp - * \brief Irccd.Server JavaScript API. - */ - -#include "duktape.hpp" -#include "module.hpp" -#include "server.hpp" - -namespace irccd { - -/** - * \brief Irccd.Server JavaScript API. - * \ingroup modules - */ -class ServerModule : public Module { -public: - /** - * Irccd.Server. - */ - IRCCD_EXPORT ServerModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -/** - * Push a server. - * - * \pre server != nullptr - * \param ctx the context - * \param server the server - */ -IRCCD_EXPORT void dukx_push_server(duk_context *ctx, std::shared_ptr server); - -/** - * Require a server. Raise a JavaScript error if not a Server. - * - * \param ctx the context - * \param index the index - * \return the server - */ -IRCCD_EXPORT std::shared_ptr dukx_require_server(duk_context *ctx, duk_idx_t index); - -} // !irccd - -#endif // !IRCCD_JS_SERVER_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-system.cpp --- a/libirccd-js/irccd/mod-system.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,243 +0,0 @@ -/* - * mod-system.cpp -- Irccd.System API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include -#include -#include - -#include "sysconfig.hpp" - -#if defined(HAVE_POPEN) -# include -#endif - -#include "mod-file.hpp" -#include "mod-irccd.hpp" -#include "mod-system.hpp" -#include "plugin-js.hpp" -#include "system.hpp" - -namespace irccd { - -namespace { - -/* - * Function: Irccd.System.env(key) - * ------------------------------------------------------------------ - * - * Get an environment system variable. - * - * Arguments: - * - key, the environment variable. - * Returns: - * The value. - */ -duk_ret_t env(duk_context *ctx) -{ - dukx_push_std_string(ctx, sys::env(dukx_get_std_string(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.System.exec(cmd) - * ------------------------------------------------------------------ - * - * Execute a system command. - * - * Arguments: - * - cmd, the command to execute. - */ -duk_ret_t exec(duk_context *ctx) -{ - std::system(duk_get_string(ctx, 0)); - - return 0; -} - -/* - * Function: Irccd.System.home() - * ------------------------------------------------------------------ - * - * Get the operating system user's home. - * - * Returns: - * The user home directory. - */ -duk_ret_t home(duk_context *ctx) -{ - dukx_push_std_string(ctx, sys::home()); - - return 1; -} - -/* - * Function: Irccd.System.name() - * ------------------------------------------------------------------ - * - * Get the operating system name. - * - * Returns: - * The system name. - */ -duk_ret_t name(duk_context *ctx) -{ - dukx_push_std_string(ctx, sys::name()); - - return 1; -} - -#if defined(HAVE_POPEN) - -/* - * Function: Irccd.System.popen(cmd, mode) [optional] - * ------------------------------------------------------------------ - * - * Wrapper for popen(3) if the function is available. - * - * Arguments: - * - cmd, the command to execute, - * - mode, the mode (e.g. "r"). - * Returns: - * A Irccd.File object. - * Throws - * - Irccd.SystemError on failures. - */ -duk_ret_t popen(duk_context *ctx) -{ - auto fp = ::popen(duk_require_string(ctx, 0), duk_require_string(ctx, 1)); - - if (fp == nullptr) - dukx_throw(ctx, SystemError()); - - dukx_push_file(ctx, new File(fp, [] (std::FILE *fp) { ::pclose(fp); })); - - return 1; -} - -#endif // !HAVE_POPEN - -/* - * Function: Irccd.System.sleep(delay) - * ------------------------------------------------------------------ - * - * Sleep the main loop for the specific delay in seconds. - */ -duk_ret_t sleep(duk_context *ctx) -{ - std::this_thread::sleep_for(std::chrono::seconds(duk_get_int(ctx, 0))); - - return 0; -} - -/* - * Function: Irccd.System.ticks() - * ------------------------------------------------------------------ - * - * Get the number of milliseconds since irccd was started. - * - * Returns: - * The number of milliseconds. - */ -duk_ret_t ticks(duk_context *ctx) -{ - duk_push_int(ctx, sys::ticks()); - - return 1; -} - -/* - * Function: Irccd.System.usleep(delay) - * ------------------------------------------------------------------ - * - * Sleep the main loop for the specific delay in microseconds. - */ -duk_ret_t usleep(duk_context *ctx) -{ - std::this_thread::sleep_for(std::chrono::microseconds(duk_get_int(ctx, 0))); - - return 0; -} - -/* - * Function: Irccd.System.uptime() - * ------------------------------------------------------------------ - * - * Get the system uptime. - * - * Returns: - * The system uptime. - */ -duk_ret_t uptime(duk_context *ctx) -{ - duk_push_int(ctx, sys::uptime()); - - return 0; -} - -/* - * Function: Irccd.System.version() - * ------------------------------------------------------------------ - * - * Get the operating system version. - * - * Returns: - * The system version. - */ -duk_ret_t version(duk_context *ctx) -{ - dukx_push_std_string(ctx, sys::version()); - - return 1; -} - -const duk_function_list_entry functions[] = { - { "env", env, 1 }, - { "exec", exec, 1 }, - { "home", home, 0 }, - { "name", name, 0 }, -#if defined(HAVE_POPEN) - { "popen", popen, 2 }, -#endif - { "sleep", sleep, 1 }, - { "ticks", ticks, 0 }, - { "uptime", uptime, 0 }, - { "usleep", usleep, 1 }, - { "version", version, 0 }, - { nullptr, nullptr, 0 } -}; - -} // !namespace - -SystemModule::SystemModule() noexcept - : Module("Irccd.System") -{ -} - -void SystemModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, functions); - duk_put_prop_string(plugin->context(), -2, "System"); - duk_pop(plugin->context()); -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-system.hpp --- a/libirccd-js/irccd/mod-system.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * mod-system.hpp -- Irccd.System API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_SYSTEM_HPP -#define IRCCD_MOD_SYSTEM_HPP - -/** - * \file mod-system.hpp - * \brief Irccd.System JavaScript API. - */ - -#include "module.hpp" - -namespace irccd { - -/** - * \brief Irccd.System JavaScript API. - * \ingroup modules - */ -class SystemModule : public Module { -public: - /** - * Irccd.System. - */ - IRCCD_EXPORT SystemModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -} // !irccd - -#endif // !IRCCD_MOD_SYSTEM_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-timer.cpp --- a/libirccd-js/irccd/mod-timer.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,209 +0,0 @@ -/* - * mod-timer.cpp -- Irccd.Timer API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include - -#include "irccd.hpp" -#include "logger.hpp" -#include "mod-irccd.hpp" -#include "mod-timer.hpp" -#include "mod-plugin.hpp" -#include "plugin-js.hpp" -#include "timer.hpp" - -using namespace fmt::literals; - -namespace irccd { - -namespace { - -const char *Signature("\xff""\xff""irccd-timer-ptr"); -const char *CallbackTable("\xff""\xff""irccd-timer-callbacks"); - -void handleSignal(Irccd& irccd, std::weak_ptr ptr, std::string key) -{ - auto plugin = ptr.lock(); - - if (!plugin) - return; - - irccd.post([plugin, key] (Irccd &) { - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), CallbackTable); - duk_get_prop_string(plugin->context(), -1, key.c_str()); - duk_remove(plugin->context(), -2); - - if (duk_is_callable(plugin->context(), -1)) { - if (duk_pcall(plugin->context(), 0) != 0) - log::warning("plugin {}: {}"_format(plugin->name(), dukx_exception(plugin->context(), -1).stack)); - else - duk_pop(plugin->context()); - } else - duk_pop(plugin->context()); - }); -} - -std::shared_ptr self(duk_context *ctx) -{ - StackAssert sa(ctx); - - duk_push_this(ctx); - duk_get_prop_string(ctx, -1, Signature); - auto ptr = duk_to_pointer(ctx, -1); - duk_pop_2(ctx); - - if (!ptr) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Timer object"); - - return *static_cast *>(ptr); -} - -/* - * Method: Timer.start() - * -------------------------------------------------------- - * - * Start the timer. If the timer is already started the method is a no-op. - */ -duk_ret_t start(duk_context *ctx) -{ - auto timer = self(ctx); - - if (!timer->isRunning()) - timer->start(); - - return 0; -} - -/* - * Method: Timer.stop() - * -------------------------------------------------------- - * - * Stop the timer. - */ -duk_ret_t stop(duk_context *ctx) -{ - auto timer = self(ctx); - - if (timer->isRunning()) - timer->stop(); - - return 0; -} - -const duk_function_list_entry methods[] = { - { "start", start, 0 }, - { "stop", stop, 0 }, - { nullptr, nullptr, 0 } -}; - -/* - * Function: Irccd.Timer(type, delay, callback) [constructor] - * -------------------------------------------------------- - * - * Create a new timer object. - * - * Arguments: - * - type, the type of timer (Irccd.Timer.Single or Irccd.Timer.Repeat), - * - delay, the interval in milliseconds, - * - callback, the function to call. - */ -duk_ret_t constructor(duk_context *ctx) -{ - // Check parameters. - auto type = duk_require_int(ctx, 0); - auto delay = duk_require_int(ctx, 1); - - if (type < static_cast(TimerType::Single) || type > static_cast(TimerType::Repeat)) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "invalid timer type"); - if (delay < 0) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "negative delay given"); - if (!duk_is_callable(ctx, 2)) - duk_error(ctx, DUK_ERR_TYPE_ERROR, "missing callback function"); - - // Construct the timer in 'this'. - auto &irccd = dukx_get_irccd(ctx); - auto timer = std::make_shared(static_cast(type), delay); - auto hash = std::to_string(reinterpret_cast(timer.get())); - - timer->onSignal.connect(std::bind(handleSignal, std::ref(irccd), - std::weak_ptr(dukx_get_plugin(ctx)), hash)); - - duk_push_this(ctx); - duk_push_pointer(ctx, new std::shared_ptr(std::move(timer))); - duk_put_prop_string(ctx, -2, Signature); - duk_push_string(ctx, hash.c_str()); - duk_put_prop_string(ctx, -2, "\xff""\xff""timer-key"); - duk_push_c_function(ctx, [] (duk_context *ctx) -> duk_ret_t { - StackAssert sa(ctx); - - duk_get_prop_string(ctx, 0, "\xff""\xff""timer-key"); - auto hash = duk_get_string(ctx, -1); - duk_pop(ctx); - duk_get_prop_string(ctx, 0, Signature); - static_cast *>(duk_to_pointer(ctx, -1))->get()->stop(); - delete static_cast *>(duk_to_pointer(ctx, -1)); - duk_pop(ctx); - duk_get_global_string(ctx, CallbackTable); - duk_del_prop_string(ctx, -1, hash); - duk_pop(ctx); - log::debug("plugin: timer destroyed"); - - return 0; - }, 1); - duk_set_finalizer(ctx, -2); - - // Save a callback function into the callback table. - duk_get_global_string(ctx, CallbackTable); - duk_dup(ctx, 2); - duk_put_prop_string(ctx, -2, hash.c_str()); - duk_pop(ctx); - - return 0; -} - -const duk_number_list_entry constants[] = { - { "Single", static_cast(TimerType::Single) }, - { "Repeat", static_cast(TimerType::Repeat) }, - { nullptr, 0 } -}; - -} // !namespace - -TimerModule::TimerModule() noexcept - : Module("Irccd.Timer") -{ -} - -void TimerModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_c_function(plugin->context(), constructor, 3); - duk_put_number_list(plugin->context(), -1, constants); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, methods); - duk_put_prop_string(plugin->context(), -2, "prototype"); - duk_put_prop_string(plugin->context(), -2, "Timer"); - duk_pop(plugin->context()); - duk_push_object(plugin->context()); - duk_put_global_string(plugin->context(), CallbackTable); -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-timer.hpp --- a/libirccd-js/irccd/mod-timer.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * mod-timer.hpp -- Irccd.Timer API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_TIMER_HPP -#define IRCCD_MOD_TIMER_HPP - -/** - * \file mod-timer.hpp - * \brief Irccd.Timer JavaScript API. - */ - -#include "module.hpp" - -namespace irccd { - -/** - * \brief Irccd.Timer JavaScript API. - * \ingroup modules - */ -class TimerModule : public Module { -public: - /** - * Irccd.Timer. - */ - IRCCD_EXPORT TimerModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -} // !irccd - -#endif // !IRCCD_MOD_TIMER_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-unicode.cpp --- a/libirccd-js/irccd/mod-unicode.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,152 +0,0 @@ -/* - * mod-unicode.cpp -- Irccd.Unicode API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "duktape.hpp" -#include "mod-unicode.hpp" -#include "plugin-js.hpp" -#include "unicode.hpp" - -namespace irccd { - -namespace { - -/* - * Function: Irccd.Unicode.isDigit(code) - * -------------------------------------------------------- - * - * Arguments: - * - code, the code point. - * Returns: - * True if the code is in the digit category. - */ -duk_ret_t isDigit(duk_context *ctx) -{ - duk_push_boolean(ctx, unicode::isdigit(duk_get_int(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.Unicode.isLetter(code) - * -------------------------------------------------------- - * - * Arguments: - * - code, the code point. - * Returns: - * True if the code is in the letter category. - */ -duk_ret_t isLetter(duk_context *ctx) -{ - duk_push_boolean(ctx, unicode::isalpha(duk_get_int(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.Unicode.isLower(code) - * -------------------------------------------------------- - * - * Arguments: - * - code, the code point. - * Returns: - * True if the code is lower case. - */ -duk_ret_t isLower(duk_context *ctx) -{ - duk_push_boolean(ctx, unicode::islower(duk_get_int(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.Unicode.isSpace(code) - * -------------------------------------------------------- - * - * Arguments: - * - code, the code point. - * Returns: - * True if the code is in the space category. - */ -duk_ret_t isSpace(duk_context *ctx) -{ - duk_push_boolean(ctx, unicode::isspace(duk_get_int(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.Unicode.isTitle(code) - * -------------------------------------------------------- - * - * Arguments: - * - code, the code point. - * Returns: - * True if the code is title case. - */ -duk_ret_t isTitle(duk_context *ctx) -{ - duk_push_boolean(ctx, unicode::istitle(duk_get_int(ctx, 0))); - - return 1; -} - -/* - * Function: Irccd.Unicode.isUpper(code) - * -------------------------------------------------------- - * - * Arguments: - * - code, the code point. - * Returns: - * True if the code is upper case. - */ -duk_ret_t isUpper(duk_context *ctx) -{ - duk_push_boolean(ctx, unicode::isupper(duk_get_int(ctx, 0))); - - return 1; -} - -const duk_function_list_entry functions[] = { - { "isDigit", isDigit, 1 }, - { "isLetter", isLetter, 1 }, - { "isLower", isLower, 1 }, - { "isSpace", isSpace, 1 }, - { "isTitle", isTitle, 1 }, - { "isUpper", isUpper, 1 }, - { nullptr, nullptr, 0 } -}; - -} // !namespace - -UnicodeModule::UnicodeModule() noexcept - : Module("Irccd.Unicode") -{ -} - -void UnicodeModule::load(Irccd &, std::shared_ptr plugin) -{ - StackAssert sa(plugin->context()); - - duk_get_global_string(plugin->context(), "Irccd"); - duk_push_object(plugin->context()); - duk_put_function_list(plugin->context(), -1, functions); - duk_put_prop_string(plugin->context(), -2, "Unicode"); - duk_pop(plugin->context()); -} - -} // !irccd diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-unicode.hpp --- a/libirccd-js/irccd/mod-unicode.hpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * mod-unicode.cpp -- Irccd.Unicode API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef IRCCD_MOD_UNICODE_HPP -#define IRCCD_MOD_UNICODE_HPP - -/** - * \file mod-unicode.hpp - * \brief Irccd.Unicode JavaScript API. - */ - -#include "module.hpp" - -namespace irccd { - -/** - * \brief Irccd.Unicode JavaScript API. - * \ingroup modules - */ -class UnicodeModule : public Module { -public: - /** - * Irccd.Unicode. - */ - IRCCD_EXPORT UnicodeModule() noexcept; - - /** - * \copydoc Module::load - */ - IRCCD_EXPORT void load(Irccd &irccd, std::shared_ptr plugin) override; -}; - -} // !irccd - -#endif // !IRCCD_MOD_UNICODE_HPP diff -r beb6c638b841 -r 7e273b7f4f92 libirccd-js/irccd/mod-util.cpp --- a/libirccd-js/irccd/mod-util.cpp Fri Aug 11 13:45:42 2017 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,303 +0,0 @@ -/* - * mod-util.cpp -- Irccd.Util API - * - * Copyright (c) 2013-2017 David Demelier - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include - -#include - -#include "mod-util.hpp" -#include "plugin-js.hpp" -#include "util.hpp" - -namespace irccd { - -namespace { - -/** - * Read parameters for Irccd.Util.format function, the object is defined as - * following: - * - * { - * date: the date object - * flags: the flags (not implemented yet) - * field1: a field to substitute in #{} pattern - * field2: a field to substitute in #{} pattern - * fieldn: ... - * } - */ -util::Substitution getSubstitution(duk_context *ctx, int index) -{ - util::Substitution params; - - if (!duk_is_object(ctx, index)) - return params; - - dukx_enumerate(ctx, index, 0, true, [&] (duk_context *) { - if (dukx_get_std_string(ctx, -2) == "date") - params.time = static_cast(duk_get_number(ctx, -1) / 1000); - else - params.keywords.insert({dukx_get_std_string(ctx, -2), dukx_get_std_string(ctx, -1)}); - }); - - return params; -} - -/* - * split (for Irccd.Util.cut as cut) - * ------------------------------------------------------------------ - * - * Extract individual tokens in array or a whole string as a std:::vector. - */ -std::vector split(duk_context *ctx) -{ - duk_require_type_mask(ctx, 0, DUK_TYPE_MASK_OBJECT | DUK_TYPE_MASK_STRING); - - std::vector result; - std::string pattern = " \t\n"; - - if (duk_is_string(ctx, 0)) { - result = util::split(dukx_get_std_string(ctx, 0), pattern); - } else if (duk_is_array(ctx, 0)) { - duk_enum(ctx, 0, DUK_ENUM_ARRAY_INDICES_ONLY); - - while (duk_next(ctx, -1, 1)) { - // Split individual tokens as array if spaces are found. - auto tmp = util::split(duk_to_string(ctx, -1), pattern); - - result.insert(result.end(), tmp.begin(), tmp.end()); - duk_pop_2(ctx); - } - } - - return result; -} - -/* - * limit (for Irccd.Util.cut as cut) - * ------------------------------------------------------------------ - * - * Get the maxl/maxc argument. - * - * The argument value is the default and also used as the result returned. - */ -int limit(duk_context *ctx, int index, const char *name, int value) -{ - if (duk_get_top(ctx) < index || !duk_is_number(ctx, index)) { - return value; - } - - value = duk_to_int(ctx, index); - - if (value <= 0) { - duk_error(ctx, DUK_ERR_RANGE_ERROR, "argument %d (%s) must be positive", index, name); - } - - return value; -} - -/* - * lines (for Irccd.Util.cut as cut) - * ------------------------------------------------------------------ - * - * Build a list of lines. - * - * Several cases possible: - * - * - s is the current line - * - abc is the token to add - * - * s = "" (new line) - * s -> "abc" - * - * s = "hello world" (enough room) - * s -> "hello world abc" - * - * s = "hello world" (not enough room: maxc is smaller) - * s+1 = "abc" - */ -std::vector lines(duk_context *ctx, const std::vector& tokens, int maxc) -{ - std::vector