syndi 0.1.1-x86-mingw32

data/lib/syndi/config.rb

@@ -0,0 +1,113 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+require 'psych'
+require 'syndi/verbosity'
+require 'csyndi'
+
+# Namespace: Syndi
+module Syndi
+
+  # A class which provides a functional, simple configuration interface. It uses
+  # YAML by means of Psych.
+  #
+  # @api Syndi
+  # @since 4.0.0
+  # @author noxgirl
+  # @author swarley
+  #
+  # @!attribute conf
+  #   @return [Hash{}] This is the hash which contains the data parsed from
+  #     the configuration file.
+  #   @see #[]
+  class Config
+    
+    attr_reader :conf, :type
+
+    # Produce a new instance, and attempt to parse.
+    #
+    # @param [String] filepath Path to configuration file.
+    def initialize filepath
+      $m.verbose("Trying to initialize configuration from '#{filepath}'...", VSIMPLE) do
+        @path = filepath
+        parse
+      end # verbose
+    end
+
+    # Rehash the configuration.
+    #
+    # If an error occurs, it will revert the configuration to its prior state
+    # so that everything can continue to function.
+    def rehash!
+      
+      $m.debug("Configuration file is rehashing.")
+
+      # Keep the old configuration in case of issues.
+      oldconf = @conf
+      @conf   = {}
+
+      # Rehash
+      parse!
+
+      # Ensure it really succeeded.
+      if @conf.empty? or !@conf.instance_of? Hash
+        # Nope. Restore old configuration.
+        @conf = oldconf
+        $m.error 'Failed to rehash the configuration file (parser produced empty config)! Reverting to old configuration.'
+        return 0
+      end
+      
+      $m.events.call :rehash
+
+    # This rescue is applicable to anything that happens in here, since if it is reached, there really was an error in general.
+    rescue => e 
+      $m.error 'Failed to rehash configuration file! Reverting to old configuration.', false, e.backtrace
+      @conf = oldconf
+      return 0
+    end
+
+    # Return value of @conf[key].
+    #
+    # @return [Object] Value of @conf[key].
+    # @see @conf
+    def [] key
+      @conf[key]
+    end
+
+    #######
+    private
+    #######
+
+    # Parse the configuration file, and output the data to {#x}.
+    #
+    # @raise [ConfigError] If the file does not exist.
+    # @raise [ConfigError] If the file cannot be processed.
+    def parse
+
+      # Ensure foremost that the configuration file exists.
+      unless File.exists? @path
+        raise ConfigError, "Configuration file '#@path' does not exist!"
+      end
+
+      # Get the data from the file.
+      f    = File.open(@path)
+      data = f.read
+      f.close
+
+      conf = {}
+      # Process the YAML.
+      begin
+        conf = Psych.load data
+      rescue => e
+        raise ConfigError, "Failed to process the YAML in '#@path'", e.backtrace
+      end
+
+      @conf = conf
+
+    end # def parse
+
+  end # class Config
+
+end # module Syndi
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/syndi/dsl/base.rb

@@ -0,0 +1,74 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+# Namespace: Syndi
+module Syndi
+
+  # Namespace: DSL
+  module DSL
+
+    # A domain-specific language (DSL) wrapper mixin for simple usage of the events
+    # system, {Syndi::API::Events}, and the timers system, {Syndi::API::Timers}.
+    #
+    # @api DSL
+    # @author noxgirl
+    # @since 4.0.0
+    #
+    # @see Syndi::API::Events
+    # @see Syndi::API::Timers
+    module Base
+        
+      # @see Syndi::API::Timers#spawn
+      def clock_do(*args);   $m.clock.spawn(*args); end
+      # @see Syndi::API::Timers#del
+      def clock_stop(*args); $m.clock.del(*args);   end
+
+      # Hook onto an event.
+      #
+      # @param [Symbol] system The events system to access.
+      # @param [Symbol] event The event onto which to hook.
+      #
+      # @see Syndi::API::Events#on
+      def on(sys, event, &prc)
+        if sys == :syndi # central system
+          $m.events.on(event, prc)
+        else
+          $m.send(sys).events.on(event, prc) if $m.respond_to? sys
+        end
+      end
+      
+      # Emit an event.
+      #
+      # @param [Symbol] system The events system to access.
+      # @param [Symbol] event The event onto which to hook.
+      #
+      # @see Syndi::API::Events#call
+      def emit(sys, event, *args)
+        if sys == :syndi # central system
+          $m.events.call(event, *args)
+        else
+          $m.send(sys).events.call(event, *args) if $m.respond_to? sys
+        end
+      end
+      
+      # Delete a hook.
+      #
+      # @param [Symbol] system The events system to access.
+      # @param [Array(Symbol, Integer, String)] hook The identification data of the hook.
+      #
+      # @see Syndi::API::Events#del
+      def undo_on(sys, hook)
+        if sys == :syndi # central system
+          $m.events.del(hook)
+        else
+          $m.send(sys).events.del(hook) if $m.respond_to? sys
+        end
+      end
+
+    end # module Base
+
+  end # module DSL
+
+end # module Syndi
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/syndi/dsl/irc.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+module Syndi
+  module DSL
+    module IRC
+      # ok
+    end
+  end
+end
+
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/syndi/events.rb

@@ -0,0 +1,130 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+require 'syndi/verbosity'
+
+module Syndi
+
+  # A simple event management system, designed particularly for Syndi.
+  #
+  # @!attribute [r] events
+  #   @return [Hash{Symbol => Array<Syndi::Events::Listener>}] The collection of events and associated listeners.
+  class Events
+
+    attr_reader :events
+
+    def initialize
+      @events = Hash.new
+    end
+
+    # Create a new listener on a given +event+, which will have the given
+    # block attached and executed upon the event's occurrence.
+    #
+    # @param [Symbol] event The event which to await.
+    # @param [Integer] priority The priority this listener should have in the hook
+    #    execution procedure. Must be 1-5 with 1 being of utmost priority.
+    #
+    # @yield [...] The parameters passed when the event was broadcasted. This varies
+    #   by event. See the official event reference for Syndi events.
+    #
+    # @return [Syndi::Events::Listener] The listener.
+    def on event, priority = 3, &prc
+      @events[event] ||= Array.new
+
+      if priority < 1 || priority > 5
+        raise ArgumentError, "invalid event priority specified"
+      end
+
+      hook = Listener.new self, event, priority, prc
+      @events[event] << hook
+      hook
+    end
+
+    # This will broadcast the given +event+, executing each listener and passing
+    # to it the parameters supplied here, respecting priority and operating in a
+    # thread.
+    #
+    # @param [Symbol] event
+    # @param [...] parameters The arguments to be passed to each listener.
+    def emit event, *parameters
+      if @events[event]
+
+        # collect the listeners with respect to priority
+        one, two, three, four, five = gather @events[event]
+
+        Syndi.log.verbose "event *#{event}* is being broadcasted on #{self}", VNOISY
+
+        # spawn a thread and perform the executions
+        Thread.new do
+          begin
+            # cease if status ever becomes false/nil
+            status = true
+            
+            one.each   { |code| status = code.call *parameters if status }
+            two.each   { |code| status = code.call *parameters if status }
+            three.each { |code| status = code.call *parameters if status }
+            four.each  { |code| status = code.call *parameters if status }
+            five.each  { |code| status = code.call *parameters if status }
+          rescue => e
+            # catch thread errors
+            Syndi.log.error "A listener to a broadcast of #{event} on #{self} caused an exception to rise (#{e})", true
+          end
+        end
+
+      end
+    end
+
+    def inspect
+      "<#Syndi::Events: obj_id=#{object_id} event_count=#{@events.length}>"
+    end
+    alias_method :to_s, :inspect
+
+    private
+
+    # Gather hooks.
+    def gather list
+      [list.collect { |hook| (hook.priority == 1 ? hook : nil) }.compact,
+       list.collect { |hook| (hook.priority == 2 ? hook : nil) }.compact,
+       list.collect { |hook| (hook.priority == 3 ? hook : nil) }.compact,
+       list.collect { |hook| (hook.priority == 4 ? hook : nil) }.compact,
+       list.collect { |hook| (hook.priority == 5 ? hook : nil) }.compact]
+    end
+
+    public
+
+    # A class which represents a listener.
+    class Listener
+      attr_reader :event, :priority, :code
+
+      # Spawn a new listener object.
+      def initialize sys, event, priority, prc
+        @sys      = sys
+        @event    = event
+        @priority = priority
+        @code     = prc
+
+        Syndi.log.verbose "new listener spawned and attached to #{event}: #{self}", VNOISY
+      end
+
+      # Terminate this object.
+      def deaf
+        @sys.events[event].delete self
+      end
+
+      # Execute this listener.
+      def call *args
+        @code.call *args
+      end
+
+      def inspect
+        "<#Syndi::Events::Listener: sys=#@sys event=#@event priority=#@priority>"
+      end
+      alias_method :to_s, :inspect
+
+    end
+
+  end
+
+end
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/syndi/irc.rb

@@ -0,0 +1,8 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+require 'syndi/irc/library'
+
+LIBRARY_IRC = Syndi::IRC::Library.new
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/syndi/irc/common.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+module Syndi
+
+  module IRC
+
+    # A class which manages such common IRC functions as syndijoining channels,
+    # and identifying to services the traditional PRIVMSG way.
+    class Common
+
+      # Construct a new common function handler.
+      #
+      # @param [Syndi::IRC::Library] lib The IRC library instance.
+      def initialize lib
+        @lib = lib
+        $m.events.on   :die,       &method(:do_die)
+        @lib.events.on :connected, &method(:do_syndijoin)
+      end
+
+      # Automatically identify with services the traditional way, which is
+      # to say by a /msg.
+      #
+      # @param [Syndi::IRC::Server] irc The IRC connection.
+      def do_identify irc
+        if $m.conf['irc'][irc.s]['nickIdentify']
+          
+          # Assume the service is NickServ if not specified
+          service = $m.conf['irc'][irc.s]['nickIdentify']['service'] || 'NickServ'
+          # and assume the command is IDENTIFY if not specified
+          command = $m.conf['irc'][irc.s]['nickIdentify']['command'] || 'IDENTIFY'
+
+          # we can't actually /msg anyone yet.....
+        end
+      end
+
+      # Automatically join IRC channels upon connection.
+      #
+      # @param [Syndi::IRC::Server] irc The IRC connection.
+      def do_syndijoin irc
+        if $m.conf['irc'][irc.s]['syndijoin']
+          
+          $m.conf['irc'][irc.s]['syndijoin'].each do |chan|
+            irc.join(chan['name'], chan['key']||nil)
+          end
+
+        end
+      end
+
+      # Disconnect from servers on termination.
+      #
+      # @param [String] reason Reason for termination.
+      def do_die reason
+        @lib.connections.each { |net, irc| irc.disconnect reason }
+      end
+
+    end # class Common
+
+  end # module IRC
+
+end # module Syndi
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/syndi/irc/library.rb

@@ -0,0 +1,89 @@
+# Copyright (c) 2013, Autumn Perrault, et al. All rights reserved.
+# This free software is distributed under the FreeBSD license (see LICENSE).
+
+require 'syndi/irc/server'
+require 'syndi/irc/object/entity'
+require 'syndi/irc/object/channel'
+require 'syndi/irc/object/user'
+require 'syndi/irc/protocol'
+require 'syndi/irc/common'
+
+module Syndi
+  
+  module IRC
+    
+    # The base of the IRC framework.
+    #
+    # @!attribute [r] events
+    #   @return [Syndi::API::Events] The IRC event system.
+    #
+    # @!attribute [r] connections
+    #   @return [Hash{String => Syndi::IRC::Server}] Collection of IRC connections. 
+    class Library
+
+      attr_reader :events, :connections
+
+      def initialize
+
+        # Initialize our event system.
+        @events      = Syndi::API::Events.new
+        # Prepare our collection of IRC server connections.
+        @connections = Hash.new
+      
+        # Be ready to accept data.
+        $m.events.on :net_receive, 1, &method(:receive)
+
+        # Start connections when Syndi is started.
+        $m.events.on :start, &method(:start)
+
+        # Parse data.
+        @parser = Syndi::IRC::Protocol.new self
+
+        # Handle common functions.
+        @common = Syndi::IRC::Common.new self
+        
+      end # def initialize
+
+      # Process incoming network data.
+      #
+      # @param [Object] socket_object The socket object, which in the case of
+      #   ourselves should be an {Syndi::IRC::Server}, or we won't handle it.
+      def receive socket_object
+        if socket_object.instance_of? Syndi::IRC::Server
+          socket_object.recv
+        end
+      end
+
+      # Initiate IRC connections.
+      def start
+        
+        # Iterate through each IRC server in the config, and connect to it.
+        $m.conf['irc'].each do |name, hash|
+          begin
+            # Configure the IRC instance.
+            @connections[name] = Syndi::IRC::Server.new(name) do |c|
+              c.address = hash['address']
+              c.port    = hash['port']
+              c.nick    = hash['nickname'][0] 
+              c.user    = hash['username']
+              c.real    = hash['realName']
+              c.ssl     = hash['useSSL']
+            end
+
+            # Connect.
+            $m.sockets << @connections[name]
+            @connections[name].connect
+          rescue => e
+            $m.error("Connection to #{name} failed: #{e}", false, e.backtrace)
+          end
+        end
+
+      end # def start
+
+    end # class Library
+
+  end # module IRC
+
+end # module Syndi
+
+# vim: set ts=4 sts=2 sw=2 et: