syndi 0.1.1-x86-mingw32

data/docs/Events.md

@@ -0,0 +1,103 @@
+# @title Specification of Events
+
+Specification of Events
+=======================
+
+**Events** are managed by Syndi's event systems, each of which is an instance
+of {Syndi::API::Events}.
+
+`$m.events` manages the **Syndi** events, which is to say the central events,
+while libraries have their own individual events systems.
+
+{Syndi::DSL::Base} provides `#on`, `#emit`, `#undo_on`, etc., which all provide
+easy distinction between the individual event systems. `:syndi`, for example,
+indicates the central system, whereas `:irc` indicates the IRC event system.
+
+:syndi
+-----
+
+### :start
+
+This event occurs when Syndi is starting, and each library is expected to await
+this event and upon its occurrence, initiate any of their processes.
+
+### :die `|reason|`
+
+**reason** (_String_): The reason for termination.
+
+This occurs when Syndi is terminating.
+
+### :net_receive `|socket_object|`
+
+**socket_object** (_Object_): The object with which the socket (`.socket`) is
+associated.
+
+This occurs when the socket associated with `socket_object` has data waiting to
+be read (as determined by `select()`).
+
+### :rehash
+
+This event occurs when the configuration file is successfully reprocessed and
+reloaded.
+
+:irc
+----
+
+### :preconnect |irc|
+
+**irc** (_Syndi::IRC::Server_): The IRC connection.
+
+This event occurs when we are about to register (i.e., send `USER`, `CAP LS`)
+on the server and initiate connection.
+
+### :receive |irc, data|
+
+**irc** (_Syndi::IRC::Server_): The IRC connection.  
+**data** (_String_): The line of data.
+
+This event occurs when data has been removed from the receive queue and is ready
+for processing, with newlines and carriage returns stripped.
+
+### :connected |irc|
+
+**irc** (_Syndi::IRC::Server_): The IRC connection.
+
+This event occurs after ISUPPORT has been received and processed, and the
+connection is fully established.
+
+Typically, at this point, any traditional service identification and syndijoining
+occurs.
+
+### :disconnect |irc, reason|
+
+**irc** (_Syndi::IRC::Server_): The IRC connection.  
+**reason** (_String_): The reason for which we are disconnecting.
+
+This event occurs when we're about to disconnect from the given server.
+
+### :send_join |irc, channel, key|
+
+**irc** (_Syndi::IRC::Server_): The IRC connection.  
+**channel** (_String_): The channel which we are attempting to join.  
+**key** (_String_ or _nil_): The key, if provided.
+
+This event occurs when we try to join a channel.
+
+### :send_nick |irc, nickname|
+
+**irc** (_Syndi::IRC::Server_): The IRC connection.  
+**nickname** (_String_): The nickname we are trying to use.
+
+This occurs when we try to change our nickname with /NICK.
+
+### :self_who |irc|
+
+**irc** (_Syndi::IRC::Server_): The IRC connection.
+
+This occurs when we send a /WHO on ourselves.
+
+### irc:onWhoReply `[all strs](irc*, nick, username, host, realname, awaystatus, server)`
+
+This event occurs when the bot receives **RPL_WHOREPLY** (numeric 352) in response to a /WHO. Note that
+`awaystatus =~ /H/` will be true if the user is not away, while `awaystatus =~ /G/` will be true if the
+user is away (`H` meaning _here_, `G` meaning _gone_).

data/docs/Upgrade.md

@@ -0,0 +1,16 @@
+# @title Upgrade Syndi 3 to 4
+
+Upgrade Syndi 3 to 4
+===================
+
+Summary
+-----------
+Syndi 3 was a comprehensive release of Syndi, and is currently available from 
+[Arinity](https://github.com/arinity/Syndi). As all things should hopefully improve
+however, this fourth major revision was begun.
+
+Nonetheless, we recognize that it is essential that we provide a means by which
+Syndi users may upgrade their old configuration files and databases to function
+with Syndi 4.
+
+We intend to address this matter when Syndi 4 is nearer stability.

data/ext/csyndi/events.c

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2013, Autumn Perrault, et al. 
+ * All rights reserved.
+ * This free software is distributed under the FreeBSD license (see LICENSE).
+ *
+ */
+
+#include "syndi.h"
+
+VALUE cEvents;
+
+static VALUE events_initialize(VALUE self)
+{
+    rb_iv_set(self, "@events", rb_hash_new());
+    rb_iv_set(self, "@threads", rb_ary_new());
+    return self;
+}
+
+static VALUE events_on(VALUE self, VALUE event, VALUE rbpriority, VALUE prc)
+{
+    int i, priority;
+
+    // convert the priority to an integer
+    priority = FIX2INT(rbpriority);
+
+    // priority must be 1-5
+    if (priority <= 1 || priority >= 5)
+        return Qnil;
+
+    // if the event does not exist, create it
+    if (rb_hash_aref(rb_iv_get(self, "@events"), event) == Qnil) {
+        rb_hash_aset(rb_iv_get(self, "@events"), event, rb_hash_new());
+        for (i = 1; i <= 5; ++i)
+            rb_hash_aset(rb_hash_aref(rb_iv_get(self, "@events"), event), INT2FIX(i), rb_hash_new());
+    }
+
+    
+
+    return Qnil; 
+}
+
+/* initialize Syndi::Events */
+static void init_events()
+{
+    cEvents = rb_define_class_under(mSyndi, "Events", SYM(Syndi::API::Object));
+    rb_define_method(cEvents, "initialize", events_initialize, 0);
+    rb_define_method(cEvents, "on", events_on, 3);
+}
+
+/* vim: set ts=4 sts=4 sw=4 et cindent: */

data/ext/csyndi/extconf.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+require 'mkmf'
+
+EXT         = 'csyndi'
+
+LIBSYNDI_DIR = File.expand_path(File.join('..', '..', '..', 'include'), __FILE__)
+unless Dir.exists? LIBSYNDI_DIR
+  STDERR.puts "csyndi headers are missing; your copy of Syndi is most probably broken."
+  exit 1
+end
+
+$CFLAGS << " -Wno-unused-function"
+$CFLAGS << " -I#{LIBSYNDI_DIR}"
+
+create_makefile EXT
+
+# vim: set ts=4 sts=2 sw=2 et:

data/ext/csyndi/integer.c

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2013, Autumn Perrault, et al. 
+ * All rights reserved.
+ * This free software is distributed under the FreeBSD license (see LICENSE).
+ *
+ */
+
+#include "syndi.h"
+
+/* SWAR algorithm for finding the number of set bits. */
+VALUE swar_bits_set(VALUE self)
+{
+    long long l = NUM2LONG(self);
+    l -= ((l >> 1) & 0x55555555);
+    l = (l & 0x33333333) + ((l >> 2) & 0x33333333);
+    return INT2FIX((((l + (l >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24);
+}
+
+/* c = PI(n-1, i=0, (b^2^i)) % m */
+VALUE modular_power(VALUE self, VALUE exponent, VALUE modulus)
+{
+    VALUE result = INT2FIX(1);
+    VALUE base = self;
+
+    int exp = NUM2INT(exponent);
+
+    if( (modulus << 1) == 0 )
+    {
+        // Avoid divide by zero
+        return Qnil;
+    }
+
+    while(exp > 0)
+    {	
+        if(exp & 1)
+            result = rb_funcall(rb_funcall(result, SYM(*), 1, base), SYM(%), 1, modulus);
+        exp >>= 1;
+        base = rb_funcall(rb_funcall(base, SYM(*), 1, base), SYM(%), 1, modulus);
+    }
+
+    // If the numbers become an issue we will switch to INT2NUM to allow for Bignums
+    return result;
+}
+
+/* initialize extension of Ruby stdlib Integer */
+void init_integer()
+{
+    rb_define_method(rb_cInteger, "bits_set", swar_bits_set, 0);
+    rb_define_method(rb_cInteger, "mod_exp", modular_power, 2);
+}
+
+/* vim: set ts=4 sts=4 sw=4 et cindent: */
+

data/ext/csyndi/libauto.c

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2013, Autumn Perrault, et al. 
+ * All rights reserved.
+ * This free software is distributed under the FreeBSD license (see LICENSE).
+ *
+ */
+
+#include "syndi.h"
+
+VALUE mSyndi;
+VALUE eLogError;
+VALUE ePluginError;
+VALUE eConfigError;
+VALUE eDatabaseError;
+
+/* initialize exceptions */
+void initialize_exceptions()
+{
+    eLogError = rb_define_class_under(mSyndi, "LogError", rb_eStandardError);
+    ePluginError = rb_define_class_under(mSyndi, "PluginError", rb_eStandardError);
+    eConfigError = rb_define_class_under(mSyndi, "ConfigError", rb_eStandardError);
+    eDatabaseError = rb_define_class_under(mSyndi, "DatabaseError", rb_eStandardError);
+}
+
+/* initialize Syndi module */
+void Init_csyndi()
+{
+    mSyndi = rb_define_module("Syndi");
+    /* initialize exceptions */
+    initialize_exceptions();
+    /* initialize Syndi::Logger */
+    init_syndi_logger();
+    /* extend Ruby stdlib Integer */
+    init_integer();
+}
+
+/* vim: set ts=4 sts=4 sw=4 et cindent: */

data/ext/csyndi/logger.c

@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2013, Autumn Perrault, et al. 
+ * All rights reserved.
+ * This free software is distributed under the FreeBSD license (see LICENSE).
+ *
+ */
+
+#include "syndi.h"
+
+VALUE cLogger;
+
+/* This will print a verbose message to STDOUT if the level of verbosity specified does
+ * not exceed the runtime verbosity.
+ */
+static void log_out2scrn(int type, const char *message, int level)
+{
+    char *real_type = ALLOCA_N(char, 12);
+
+    if (FIX2INT(rb_gv_get("$VERBOSITY")) < level)
+        return;
+
+    switch (type) {
+        case TYPE_FATAL:
+            real_type = RSTRING_PTR(rb_funcall(rb_str_new2("FATAL ERROR:"), SYM(red), 0));
+            break;
+        case TYPE_ERROR:
+            real_type = RSTRING_PTR(rb_funcall(rb_str_new2("ERROR:"), SYM(red), 0));
+            break;
+        case TYPE_WARNING:
+            real_type = RSTRING_PTR(rb_funcall(rb_str_new2("WARNING:"), SYM(red), 0));
+            break;
+        case TYPE_INFO:
+            real_type = RSTRING_PTR(rb_funcall(rb_str_new2("***"), SYM(green), 0));
+            break;
+        case TYPE_DEBUG:
+            real_type = RSTRING_PTR(rb_funcall(rb_str_new2("==>"), SYM(magenta), 0));
+            break;
+    }
+
+    printf("%s %s%s", real_type, message, OS_LINE_TERM);
+}
+
+/* This will foremost call log_dircheck() to ensure the presence of the log
+ * directory, and then it will output the message to today's logfile.
+ */
+static void log_out2file(const char *type, const char *message)
+{
+    char *log_file_name = ALLOCA_N(char, MAX_TIME_STRING_LENGTH + 1);
+    char *log_time = ALLOCA_N(char, LOG_TIME_FORMAT_LENGTH + 1);
+    FILE *log_file;
+    
+    /* 8 is the number of extra characters i.e " ", "[]", "\n" */
+    size_t output_string_size = 8 + strlen(type) + strlen(message) + LOG_TIME_FORMAT_LENGTH;
+    char *formatted_message = ALLOCA_N(char, ++output_string_size);
+    time_t current_time;
+
+    /* Ensure the log directory's existence. */
+    log_dircheck();
+
+    time(&current_time);
+
+    strftime(log_file_name, 100, LOG_FILE_FORMAT, localtime(&current_time));
+
+    log_file = fopen(log_file_name, "a+");
+    if (log_file == NULL)
+    {
+        rb_raise(eLogError, "Could not open logfile %s for reading: %d", log_file_name, errno);
+        return;
+    }
+
+    /* Fetch the current time and format the message. */
+    strftime(log_time, 100, "%Y-%M-%d %X %z", localtime(&current_time));
+    sprintf(formatted_message, "[%s] [%s] %s%s", log_time, type, message, OS_LINE_TERM);
+
+    /* Write to file. */
+    fputs(formatted_message, log_file);
+    fclose(log_file);
+}
+
+/* Ensure the existence of the log directory. */
+static void log_dircheck()
+{
+    int result;
+    char *dir = ALLOCA_N(char, strlen(SYNDI_DIR) + 5);
+
+#ifdef _WIN32
+    sprintf(dir, "%s\\logs", SYNDI_DIR);
+    result = _mkdir(dir);
+#else
+    sprintf(dir, "%s/logs", SYNDI_DIR);
+    result = mkdir(dir, S_IRWXU);
+#endif
+
+    // Only raise an error if we fail to create the directory. 
+    if (result != 0 && errno != EEXIST)
+    {
+        int error_number = errno;
+        rb_raise(eLogError, "Could not create %s: %s", dir, strerror(error_number));
+    }
+}
+
+/* @overload initialize()
+ *   Constructs a new Syndi::Logger instance.
+ *
+ *   @return [Syndi::Logger]
+ */
+VALUE logger_init(VALUE self)
+{
+    log_dircheck();
+    return self;
+}
+
+/* @overload fatal(message)
+ *   This will log +message+ as a fatal error, as well as kill the program.
+ *
+ *   @param [String] message The fatal error message to be reported.
+ *   @return [nil]
+ */
+VALUE logger_fatal(VALUE self, VALUE message)
+{
+    char *msg = RSTRING_PTR(message);
+    log_out2file("FATAL ERROR", msg);
+    log_out2scrn(TYPE_FATAL, msg, 0);
+    rb_exit(1);
+    return Qnil;
+}
+
+/* @overload error(message)
+ *   This will log +message+ as an error, optionally also outputting +backtrace+,
+ *   the data for which shall be obtained from Kernel#caller.
+ *
+ *   @param [String] message The error message to be reported.
+ *   @param [Boolean] backtrace Whether to output a backtrace.
+ *   @return [nil]
+ */
+VALUE logger_error(int argc, VALUE *argv, VALUE self)
+{
+    VALUE message;
+    VALUE backtrace;
+    VALUE bt_bool;
+    char *msg;
+
+    rb_scan_args(argc, argv, "11", &message, &bt_bool);
+
+    msg = RSTRING_PTR(message);
+    log_out2file("ERROR", msg);
+    log_out2scrn(TYPE_ERROR, msg, 0);
+
+    if (bt_bool == Qtrue)
+    {
+        backtrace = rb_funcall(rb_cObject, SYM(caller), 0);
+        fprintf(stderr, "Backtrace:%s", OS_LINE_TERM);
+        rb_funcall(rb_stderr, SYM(puts), 1, backtrace);
+    }
+    
+    return Qnil;
+}
+
+/* @overload warn(message)
+ *   This will log +message+ as a warning.
+ *
+ *   @param [String] message The admonitory message to be reported.
+ *   @return [nil]
+ */
+VALUE logger_warn(VALUE self, VALUE message)
+{
+    char *msg = RSTRING_PTR(message);
+    log_out2file("WARNING", msg);
+    log_out2scrn(TYPE_WARNING, msg, 0);
+    return Qnil;
+}
+
+/* @overload info(message)
+ *   This will log +message+ as an informative message.
+ *
+ *   @param [String] message The information to be reported.
+ *   @return [nil]
+ */
+VALUE logger_info(VALUE self, VALUE message)
+{
+    char *msg = RSTRING_PTR(message);
+    log_out2file("INFO", msg);
+    log_out2scrn(TYPE_INFO, msg, 0);
+    return Qnil;
+}
+
+/* @overload verbose(message, level)
+ *   Yield a message of verbosity magic. This will execute any block it is
+ *   passed (*implicit!*).
+ *
+ *   @param [String] message The message to be reported.
+ *   @param [Integer] level The level of verbosity. We recommend +VSIMPLE+,
+ *      +VUSEFUL+, or +VNOISY+.
+ *
+ *   @return [nil]
+ */
+VALUE logger_verbose(VALUE self, VALUE message, VALUE level)
+{
+    char *msg = RSTRING_PTR(message);
+    int vrb = FIX2INT(level);
+
+    /* check verbosity */
+    if (FIX2INT(rb_gv_get("$VERBOSITY")) < vrb)
+        return Qnil;
+
+    /* log */
+    log_out2file("DEBUG", msg);
+    log_out2scrn(TYPE_DEBUG, msg, vrb);
+
+    /* execute the block */
+    if (rb_block_given_p())
+        rb_yield(Qnil);
+
+    return Qnil;
+}
+
+/* initializes Syndi::Logger in Ruby */
+void init_syndi_logger()
+{
+    cLogger = rb_define_class_under(mSyndi, "Logger", rb_cObject);
+    rb_define_method(cLogger, "initialize", logger_init, 0);
+    rb_define_method(cLogger, "fatal", logger_fatal, 1);
+    rb_define_method(cLogger, "error", logger_error, -1);
+    rb_define_method(cLogger, "verbose", logger_verbose, 2);
+    rb_define_method(cLogger, "warn", logger_warn, 1);
+    rb_define_method(cLogger, "info", logger_info, 1);
+}
+
+/* vim: set ts=4 sts=4 sw=4 et cindent: */