Auto 4.0.0.alpha.1-x86-mingw32

data/ext/libauto/libauto.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2013, Autumn Perrault, et al. 
+ * All rights reserved.
+ * This free software is distributed under the FreeBSD license (LICENSE.md).
+ *
+ */
+
+#ifndef __LIBAUTO_H__
+#define __LIBAUTO_H__
+
+/* SYM(x) returns rb_intern(x) */
+#define SYM(str) rb_intern(#str)
+
+/* variable for the Auto module */
+VALUE mAuto;
+
+/* Init_libauto prototype */
+void Init_libauto();
+
+/* Auto's exceptions */
+VALUE eLogError;
+VALUE eConfigError;
+VALUE eDatabaseError;
+VALUE ePluginError;
+
+#endif
+
+/* vim: set ts=4 sts=4 sw=4 et cindent: */

data/ext/libauto/logger.c

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2013, Autumn Perrault, et al. 
+ * All rights reserved.
+ * This free software is distributed under the FreeBSD license (LICENSE.md).
+ *
+ */
+
+// So that the header will be read correctly.
+#define __LOGGER__
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <time.h>
+#include "auto.h"
+
+/* @overload initialize()
+ *   Constructs a new Auto::Logger instance.
+ *
+ *   @return [Auto::Logger]
+ */
+VALUE logger_init(VALUE self)
+{
+    rb_iv_set(self, "@status", ID2SYM(SYM(good)));
+    rb_funcall(self, SYM(log_directory_check), 0);
+    return self;
+}
+
+/* @overload error(message)
+ *   This will log +message+ as an error.
+ *
+ *   @param [String] message The error message to be reported.
+ *   @return [nil]
+ */
+VALUE logger_error(VALUE self, VALUE message)
+{
+    rb_funcall(self, SYM(log), 2, rb_str_new2("ERROR"), message);
+    return Qnil;
+}
+
+/* @overload debug(message)
+ *   This will log +message+ as a debug message.
+ *
+ *   @param [String] message The debug message to be reported.
+ *   @return [nil]
+ */
+VALUE logger_debug(VALUE self, VALUE message)
+{
+    rb_funcall(self, SYM(log), 2, rb_str_new2("DEBUG"), message);
+    return Qnil;
+}
+
+/* @overload warning(message)
+ *   This will log +message+ as a warning.
+ *
+ *   @param [String] message The admonitory message to be reported.
+ *   @return [nil]
+ */
+VALUE logger_warning(VALUE self, VALUE message)
+{
+    rb_funcall(self, SYM(log), 2, rb_str_new2("WARNING"), message);
+    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)
+{
+    rb_funcall(self, SYM(log), 2, rb_str_new2("INFO"), message);
+    return Qnil;
+}
+
+/* @overload log(type, message)
+ *   This will foremost call {#log_directory_check} to ensure the log directory
+ *   exists, and then log the given +message+ as +type+.
+ *
+ *   @param [String] type The type; e.g. WARNING, ERROR, etc.
+ *   @param [String] message The message to be logged.
+ *
+ *   @return [nil]
+ */
+VALUE logger_log(VALUE self, VALUE type, VALUE message)
+{
+    // Declaractions and assignments.
+    char *log_file_name  = ALLOCA_N(char, MAX_TIME_STRING_LENGTH + 1);
+    //
+    char *log_time = ALLOCA_N(char, LOG_TIME_FORMAT_LENGTH + 1); // Length of our maximum expected string
+    FILE *log_file;
+    
+    /* 8 is The number of extra characters i.e " ", "[]", "\n" */
+    size_t output_string_size = 8 + RSTRING_LEN(type) + RSTRING_LEN(message) + LOG_TIME_FORMAT_LENGTH;
+
+    char *formatted_message = ALLOCA_N(char, ++output_string_size);
+    
+    time_t current_time;
+
+    // Ensure we have the directory we need.
+    rb_funcall(self, SYM(log_directory_check), 0);
+
+    // Get the current time
+    time(&current_time);
+
+    // Create the file name
+    strftime(log_file_name, 100, LOG_FILE_FORMAT, localtime(&current_time));
+
+    // Open the log file for appending.
+    log_file = fopen(log_file_name, "a+");
+
+    // Make sure we can open the file.
+    if(log_file == NULL)
+    {
+        rb_raise(eLogError, "Could not open logfile %s for reading: %d", log_file_name, errno);
+        return Qnil;
+    }
+
+    // Create the time to log
+    strftime(log_time, 100, "%Y-%M-%d %X %z", localtime(&current_time));
+
+
+    // Create the string to log
+    sprintf(formatted_message, "[%s] [%s] %s\n", log_time, RSTRING_PTR(type), RSTRING_PTR(message));
+
+    // Write sting to log and close.
+    fputs(formatted_message, log_file);
+    fclose(log_file);
+    
+    return Qnil;
+}
+
+/* @overload log_directory_check()
+ *   @private
+ *
+ *   This will check whether the log directory exists, and attempt to create it
+ *   in the event that it doesn't.
+ *
+ *   @raise [LogError] If directory creation fails.
+ *   @return [nil]
+ */
+VALUE logger_log_directory_check(VALUE self)
+{
+    int result;
+
+#ifdef WIN32
+    result = _mkdir("logs/");
+#else
+    result = mkdir("logs", S_IRWXU);
+#endif
+
+    // Only raise an error if we fail to create the directory. 
+    if(result != 0 && errno != EEXIST)
+    {
+        int error_number = errno;
+        rb_iv_set(self, "@status", ID2SYM(SYM(bad)));
+        rb_raise(eLogError, "Could not create logs/: %s", strerror(error_number));
+    }
+
+    return Qnil;
+}
+
+/* initializes Auto::Logger in Ruby */
+void init_auto_logger()
+{
+    cLogger = rb_define_class_under(mAuto, "Logger", rb_cObject);
+    rb_define_method(cLogger, "initialize", logger_init, 0);
+    rb_define_method(cLogger, "error", logger_error, 1);
+    rb_define_method(cLogger, "debug", logger_debug, 1);
+    rb_define_method(cLogger, "warning", logger_warning, 1);
+    rb_define_method(cLogger, "info", logger_info, 1);
+    rb_define_private_method(cLogger, "log_directory_check", logger_log_directory_check, 0);
+    rb_define_private_method(cLogger, "log", logger_log, 2);
+}
+
+/* vim: set ts=4 sts=4 sw=4 et cindent: */

data/ext/libauto/logger.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2013, Autumn Perrault, et al. 
+ * All rights reserved.
+ * This free software is distributed under the FreeBSD license (LICENSE.md).
+ *
+ */
+
+#ifndef __AUTO_LOGGER_H__
+#define __AUTO_LOGGER_H__
+
+// Set format based on target OS.
+#ifdef WIN32
+#define LOG_FILE_FORMAT "logs\\%Y%m%d.log"
+#else
+#define LOG_FILE_FORMAT "logs/%Y%m%d.log"
+#endif
+
+// This is based on the desired output give or take a few characters.
+#define MAX_TIME_STRING_LENGTH 18
+
+// ("YYYY-MM-DD HH:MM:SS +ZZZZ") "YEAR-MONTH-DAY HOUR:MINUTES:SECONDS UTC_OFFSET"
+#define LOG_TIME_FORMAT_LENGTH 25
+
+VALUE cLogger;
+
+VALUE logger_init(VALUE self);
+
+VALUE logger_error(VALUE self, VALUE message);
+
+VALUE logger_debug(VALUE self, VALUE message);
+
+VALUE logger_warning(VALUE self, VALUE message);
+
+VALUE logger_info(VALUE self, VALUE message);
+
+VALUE logger_log(VALUE self, VALUE type, VALUE message);
+
+VALUE logger_log_directory_check(VALUE self);
+
+void init_auto_logger();
+
+
+#endif 
+// __AUTO_LOGGER_H__

data/lib/auto.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (LICENSE.md).
+
+require 'auto/rubyext/string'
+require 'auto/version'
+require 'libauto' # include the native extension
+require 'auto/bot'
+
+module Auto
+
+  # @return [Boolean] Whether we're installed as a gem.
+  def self.gem?
+    begin
+      # If we already checked, just return the result of that.
+      return @gem if defined? @gem
+
+      # Otherwise, check.
+      result = Gem.path.each do |gempath|
+        break true if __FILE__ =~ /^#{Regexp.escape gempath}/
+      end
+      @gem = (result == true ? true : false)
+    ensure
+      @gem ||= false
+    end
+  end
+
+  # @return [Boolean] Whether we're running on Microsoft Windows.
+  def self.windows?
+    begin
+      return @windows if defined? @windows
+      if ::RbConfig::CONFIG['host_os'] =~ /bccwin|djgpp|mswin|mingw|cygwin|wince/i
+        @windows = true
+      else
+        @windows = false
+      end
+    ensure
+      @windows ||= false
+    end
+  end
+
+end
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/auto/api.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (LICENSE.md).
+
+require 'auto/api/events'
+require 'auto/api/timers'
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/auto/api/events.rb

@@ -0,0 +1,166 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (LICENSE.md).
+
+require 'thread'
+require 'auto/api/object'
+
+# Entering namespace: Auto
+module Auto
+
+  # Entering namespace: API
+  module API
+
+    # A class which provides the the fundamental event system, upon which
+    # much of the API is based, and which follows a simple model of broadcasting
+    # and hooking onto such broadcasts.
+    #
+    # Plugin writers may be rather interested in {Auto::DSL::Base}, since that
+    # provides a simpler interface to Auto's instances of this class.
+    #
+    # @api Auto
+    # @since 4.0.0
+    # @author noxgirl
+    #
+    # @see Auto::DSL::Base
+    #
+    # @!attribute [r] threads
+    #   @return [Array] An array of threads used by {#call}.
+    class Events < Auto::API::Object
+
+      attr_reader :events, :threads
+
+      # Create a new instance of Auto::API::Events.
+      def initialize
+        @events  = {}
+        @threads = []
+      end
+
+      # Listen for (hook onto) an event.
+      #
+      # @param [Symbol] event The name of the event for which to listen.
+      # @param [Integer] priority The priority of the event from 1-5, 1 being utmost priority.
+      #
+      # @yield [...] The arguments that will be yielded to the block vary by event.
+      #   Please consult with the {file:docs/Events.md events specification} for details by event.
+      #
+      # @return [Array(Symbol, Integer, String)] Identification data including a unique string. Keep 
+      #   this if you need to destroy the hook later.
+      #
+      # @example
+      #   events.on :disconnect do |irc|
+      #     puts "I'm dying!"
+      #   end
+      #
+      # @see Auto::DSL::Base#on
+      # @see file:docs/Events.md
+      def on(event, priority=3, &cb)
+
+        # Priority must be in the range of 1-5.
+        unless (1..5).include? priority
+          return 0
+        end
+
+        # If the event does not exist, create it.
+        @events[event] ||= {1 => {}, 2 => {}, 3 => {}, 4 => {}, 5 => {}}
+
+        # Generate a unique pseudorandom ID for this hook.
+        id = ''
+        10.times { id += get_rand_char }
+        while @events[event][priority].has_key? id
+          id = ''
+          10.times { id += get_rand_char }
+        end
+
+        # Create the hook in memory.
+        @events[event][priority][id] = cb
+
+        [event, priority, id]
+
+      end
+
+      # Broadcast an event and associated arguments.
+      #
+      # The arguments are globbed into an array from the list passed to the
+      # method, so be sure to format your call correctly.
+      #
+      # If a hook returns +false+, all subsequent hook executions will be
+      # forestalled from occurring.
+      #
+      # @param [Symbol] event The event being broadcasted.
+      # @param [Array] args A list of arguments which should be passed to
+      #   the listeners. (splat)
+      #
+      # @example
+      #   events.call(:cow_moo, "the cows", "go moo", [1, 3, 5])
+      #
+      # @see Auto::DSL::Base#emit
+      def call(event, *args)
+        # Check if any hooks exist for this event.
+        if @events.include? event
+          $m.debug("A thread is spawning for the sake of a broadcast of event {#{event}}.") if $m.opts.verbose?
+          @threads << Thread.new(event) do |evnt|
+            status = nil
+            begin # catch exceptions
+              # Iterate through the hooks.
+              @events[evnt].each_key do |priority|
+                @events[evnt][priority].each_value do |prc|
+                  status = prc.call(*args) unless status == false
+                end # each hook
+              end # each priority
+            rescue => e
+              $m.error "An exception occurred inside the thread of #{event}: #{e}", false, e.backtrace
+              $m.error "Said thread has terminated with a backtrace report."
+            end # begin
+          end # thread
+        end # whether this event exists
+      end
+
+      # Delete a hook or listener.
+      #
+      # @param [Array(Symbol, Integer, String)] id The identification data of the hook,
+      #   as provided by #on.
+      #
+      # @see Auto::DSL::Base#undo_on
+      def del(id)
+        event, priority, hook = id
+
+        if @events.has_key? event
+          if @events[event][priority].has_key? hook
+            @events[event][priority].delete(hook)
+          end
+        end
+
+        tidy
+      end
+
+      # Terminate all active threads.
+      def die
+        @threads.each do |thr|
+          thr.kill if thr.active?
+        end
+      end
+
+      #######
+      private
+      #######
+
+      # Tidy up.
+      def tidy
+        @events.each do |name, lists|
+          empty = true
+          empty = lists.each_value { |v| break false if not v.empty? }
+          if empty
+            # Drop the event.
+            @events.delete name
+            next
+          end
+        end
+      end
+
+    end # class Events
+
+  end # module API
+
+end # module Auto
+
+# vim: set ts=4 sts=2 sw=2 et: