Sutto-marvin 0.4.0 → 0.8.0.0

data/lib/marvin/irc/server.rb

@@ -1,71 +0,0 @@
-module Marvin
-  module IRC
-    module Server
-      
-      # Server utilities
-      autoload :NamedStore,         'marvin/irc/server/named_store'
-      
-      # Store each user
-      UserStore = NamedStore.new(:nicks, :user) do
-        
-        def virtual?(nick)
-          self[nick].is_a?(Marvin::IRC::Server::VirtualUserConnection)
-        end
-        
-        def reclaim(nick)
-          if has_key?(nick) && virtual?(nick)
-            self[nick].reclaim!
-          end
-        end
-        
-        # Nick is not taken when 
-        def nick_taken?(nick)
-          has_key?(nick) && !virtual(nick)
-        end
-        
-        def each_user_except(user)
-          self.each_user { |u| yield u unless user == u }
-        end
-      end
-      
-      # Store each channel
-      ChannelStore = NamedStore.new(:names, :channel)
-      
-      autoload :RemoteInterface,       'marvin/irc/server/remote_interface'
-      autoload :Channel,               'marvin/irc/server/channel'
-      # The actual network connection
-      autoload :BaseConnection,        'marvin/irc/server/base_connection'
-      # An our implementations of protocol-specific stuff.
-      autoload :VirtualUserConnection, 'marvin/irc/server/virtual_user_connection'
-      autoload :AbstractConnection,    'marvin/irc/server/abstract_connection'
-      autoload :UserConnection,        'marvin/irc/server/user_connection'
-      # autoload :ServerConnection,      'marvin/irc/server/server_connection'
-      # Extensions for each part
-      autoload :User,                  'marvin/irc/server/user'
-      
-      # call start_server w/ the default options
-      # and inside an EM::run block.
-      def self.run
-        Marvin::IRC::Server::RemoteInterface.start
-        EventMachine::run do
-          Marvin::Logger.info "Starting server..."
-          start_server :bind_addr => "0.0.0.0"
-        end
-      end
-      
-      # Starts the server with a set of given options
-      def self.start_server(opts = {})
-        opts[:started_at] ||= Time.now
-        opts[:host]       ||= self.host_name
-        opts[:port]       ||= 6667
-        EventMachine::start_server(opts[:bind_addr] || opts[:host], opts[:port], BaseConnection, opts)
-        Marvin::Logger.info "Server started"
-      end
-      
-      def self.host_name
-        @@host_name ||= Socket.gethostname
-      end
-      
-    end
-  end
-end

data/lib/marvin/loader.rb

@@ -1,149 +0,0 @@
-require 'fileutils'
-require 'singleton'
-
-module Marvin
-  class Loader
-    include Singleton
-    
-    # A Controller is any class e.g. a client / server
-    # which is provides the main functionality of the
-    # current client.
-    CONTROLLERS = {
-      :client             => Marvin::Settings.default_client,
-      :server             => Marvin::IRC::Server,
-      :ring_server        => Marvin::Distributed::RingServer,
-      :distributed_client => Marvin::Distributed::DRbClient,
-      :console            => Marvin::Console
-    }
-    
-    # For each of the known types, define a method
-    # as Marvin::Loader.type? so we can easily do
-    # things like conditional registers.
-    class << self
-      CONTROLLERS.keys.each do |type|
-        define_method(:"#{type}?") { Marvin::Loader.type == type }
-      end
-    end
-    
-    cattr_accessor :hooks, :boot, :type
-    self.hooks = {}
-    self.type = :client
-    
-    # Old style of registering a block to be run on startup
-    # for doing setup etc. now replaced by before_run
-    def self.before_connecting(&blk)
-      Marvin::Logger.warn "Marvin::Loader.before_connecting is deprecated, please use before_run instead."
-      before_run(&blk)
-    end
-    
-    # Append a hook for a given type of hook in order
-    # to be called later on via invoke_hooks!
-    def self.append_hook(type, &blk)
-      self.hooks_for(type) << blk unless blk.blank?
-    end
-    
-    # Return all of the existing hooks or an empty
-    # for a given hook type.
-    def self.hooks_for(type)
-      (self.hooks[type.to_sym] ||= [])
-    end
-    
-    # Invoke (call) all of the hooks for a given
-    # type.
-    def self.invoke_hooks!(type)
-      hooks_for(type).each { |hook| hook.call }
-    end
-    
-    # Append a call back to be run at a specific stage.
-    
-    # Register a hook to be run before the controller
-    # has started running.
-    def self.before_run(&blk)
-      append_hook(:before_run, &blk)
-    end
-    
-    # Register a hook to be run after the controller
-    # has stopped. Note that this will not guarantee
-    # all processing has completed.
-    def self.after_stop(&blk)
-      append_hook(:after_stop, &blk)
-    end
-    
-    def self.run!(type = :client)
-      self.type = type.to_sym
-      self.instance.run!
-    end
-    
-    def self.stop!(force = false)
-      self.instance.stop!(force)
-    end
-    
-    def run!
-      self.register_signals
-      Marvin::Options.parse!
-      Marvin::Daemon.daemonize! if Marvin::Settings.daemon?
-      Marvin::Logger.setup
-      self.load_settings
-      require(Marvin::Settings.root / "config" / "setup")
-      self.load_handlers
-      self.class.invoke_hooks!   :before_run
-      attempt_controller_action! :run
-    end
-    
-    def stop!(force = false)
-      if force || !@attempted_stop
-        self.class.invoke_hooks!   :before_stop
-        attempt_controller_action! :stop
-        self.class.invoke_hooks!   :after_stop
-        @attempted_stop = true
-      end
-      Marvin::Daemon.cleanup! if Marvin::Settings.daemon?
-    end
-    
-    protected
-    
-    # Get the controller for the current type if
-    # it exists and attempt to class a given action.
-    def attempt_controller_action!(action)
-      klass = CONTROLLERS[self.type]
-      klass.send(action) unless klass.blank? || !klass.respond_to?(action, true)
-    end
-    
-    # Load all of the handler's in the handlers subfolder
-    # of a marvin installation.
-    def load_handlers
-      Dir[Marvin::Settings.root / "handlers/**/*.rb"].each { |handler| require handler }
-    end
-    
-    def load_settings
-      Marvin::Settings.setup
-      case Marvin::Loader.type
-      # Perform client / type specific setup.
-      when :client
-        Marvin::Settings.default_client.configuration = Marvin::Settings.to_hash
-        Marvin::Settings.default_client.setup
-      when :distributed_client
-        Marvin::Settings.default_client = Marvin::Distributed::DRbClient
-      end
-    end
-    
-    def register_signals
-      ["INT", "TERM"].each do |sig|
-        trap sig do
-          Marvin::Loader.stop!
-          exit
-        end
-      end
-    end
-    
-    # Register to the Marvin::DataStore methods
-    if Marvin::Loader.client?
-      before_run do
-        Marvin::CoreCommands.register!
-        Marvin::DataStore.load!
-      end
-      after_stop { Marvin::DataStore.dump! }
-    end
-    
-  end
-end

data/lib/marvin/logger.rb

@@ -1,86 +0,0 @@
-module Marvin
-  class Logger
-    
-    cattr_accessor :logger
-    
-    class << self
-      
-      def setup
-        log_path = Marvin::Settings.root / "log/#{Marvin::Loader.type.to_s.dasherize}-#{Marvin::Settings.environment}.log"
-        self.logger ||= new(log_path, Marvin::Settings.log_level, Marvin::Settings.verbose)
-      end
-      
-      def method_missing(name, *args, &blk)
-       self.setup # Ensure the logger is setup
-       self.logger.send(name, *args, &blk)
-      end
-    
-    end
-    
-    LEVELS = {
-      :fatal => 7,
-      :error => 6,
-      :warn  => 4,
-      :info  => 3,
-      :debug => 0
-    }
-  
-    PREFIXES = {}
-  
-    LEVELS.each { |k,v| PREFIXES[k] = "[#{k.to_s.upcase}]".ljust 7 }
-
-    COLOURS = {
-      :fatal => 31, # red
-      :error => 33, # yellow
-      :warn  => 35, # magenta
-      :info  => 32, # green
-      :debug => 34  # white
-    }
-  
-    attr_accessor :level, :file, :verbose
-  
-    def initialize(path, level = :info, verbose = false)
-      self.level   = level.to_sym
-      self.verbose = verbose
-      self.file    = File.open(path, "a+")
-    end
-  
-    def close!
-      self.file.close
-    end
-  
-    LEVELS.each do |name, value|
-    
-      define_method(name) do |message|
-        write "#{PREFIXES[name]} #{message}", name if LEVELS[self.level] <= value
-      end
-    
-      define_method(:"#{name}?") do
-        LEVELS[self.level] <= value
-      end    
-    end
-  
-    def debug_exception(exception)
-    
-      error "Exception: #{exception}"
-      exception.backtrace.each do |l|
-        error ">> #{l}"
-      end
-    
-    end
-  
-    private
-  
-    def write(message, level = self.level)
-      self.file.puts message
-      self.file.flush
-      STDOUT.puts colourize(message, level) if self.verbose
-    end
-  
-    def colourize(message, level)
-      "\033[1;#{COLOURS[level]}m#{message}\033[0m"
-    end
- 
-    
-  end
-end

data/lib/marvin/options.rb

@@ -1,42 +0,0 @@
-require 'optparse'
-
-module Marvin
-  class Options
-  
-    def self.parse!
-      options = {
-        :verbose   => Marvin::Settings.verbose,
-        :log_level => Marvin::Settings.log_level.to_s,
-        :daemon    => false
-      }
-      
-      ARGV.options do |o|
-        script_name = File.basename($0)
-        o.set_summary_indent('    ')
-        o.banner =    "Usage: #{script_name}  [OPTIONS]"
-        o.define_head "Ruby IRC Library"
-        o.separator   ""
-        o.separator   ""
-        o.on("-l", "--level=[level]", String, "The log level to use",
-             "Default: #{options[:log_level]}") {|v| options[:log_level] = v}
-        o.on("-v", "--verbose", "Be verbose (print to stdout)") {|v| options[:verbose] = v}
-        o.on("-d", "--daemon",  "Run as a daemon (drop the PID)") {|v| options[:daemon] = v}
-        o.on("-k", "--kill", "Kill all of the current type / the running instances") do |kill|
-           if kill
-            Marvin::Daemon.kill_all(Marvin::Loader.type)
-            exit
-          end
-        end
-        
-        o.separator   ""
-        o.on_tail("-h", "--help", "Show this message.") { puts o; exit }
-        o.parse!
-      end
-      
-      Marvin::Settings.daemon    = options[:daemon]
-      Marvin::Settings.log_level = options[:log_level].to_sym
-      Marvin::Settings.verbose   = options[:verbose]
-    end
-  
-  end
-end

data/lib/marvin/parsers/regexp_parser.rb

@@ -1,93 +0,0 @@
-module Marvin
-  module Parsers
-    class RegexpParser < Marvin::AbstractParser
-    
-      cattr_accessor :regexp_matchers, :events
-      # Since we cbf implemented an ordered hash, just use regexp => event at the same
-      # index.
-      self.regexp_matchers = []
-      self.events = []
-    
-      attr_accessor :current_line
-    
-      # Appends an event to the end of the the events callback
-      # chain. It will be search in order of first-registered
-      # when used to match a URL (hence, order matters).
-      def self.register_event(*args)
-        matcher = args.delete_at(1) # Extract regexp.
-        if args.first.is_a?(Marvin::IRC::Event)
-          event = args.first
-        else
-          event = Marvin::IRC::Event.new(*args)
-        end
-        self.regexp_matchers << matcher
-        self.events << event
-      end
-    
-    
-      # Initialize a new RegexpParser from the given line.
-      def initialize(line)
-        self.current_line = line
-      end
-    
-      def to_event
-        self.regexp_matchers.each_with_index do |matcher, offset|
-          if (match_data = matcher.match(self.current_line))
-            event = self.events[offset].dup
-            event.raw_arguments = match_data.to_a[1..-1]
-            return event
-          end
-        end
-        # otherwise, return nil
-        return nil
-      end
-    
-      ## The Default IRC Events
-    
-      # Note that some of these Regexp's are from Net::YAIL,
-      # which apparantly sources them itself from the IRCSocket
-      # library.
-    
-      register_event :invite,  /^\:(.+)\!\~?(.+)\@(.+) INVITE (\S+) :?(.+?)$/i,
-                     :nick, :ident, :host, :target, :channel
-                   
-      register_event :action,  /^\:(.+)\!\~?(.+)\@(.+) PRIVMSG (\S+) :?\001ACTION (.+?)\001$/i,
-                     :nick, :ident, :host, :target, :message
-                   
-      register_event :ctcp, /^\:(.+)\!\~?(.+)\@(.+) PRIVMSG (\S+) :?\001(.+?)\001$/i,
-                     :nick, :ident, :host, :target, :message
-    
-      register_event :message, /^\:(.+)\!\~?(.+)\@(.+) PRIVMSG (\S+) :?(.+?)$/i,
-                     :nick, :ident, :host, :target, :message
-                   
-      register_event :join,    /^\:(.+)\!\~?(.+)\@(.+) JOIN (\S+)/i,
-                     :nick, :ident, :host, :target               
-                   
-      register_event :part,    /^\:(.+)\!\~?(.+)\@(.+) PART (\S+)\s?:?(.+?)$/i,
-                     :nick, :ident, :host, :target, :message
-                   
-      register_event :mode,    /^\:(.+)\!\~?(.+)\@(.+) MODE (\S+) :?(.+?)$/i,
-                     :nick, :ident, :host, :target, :mode               
-
-      register_event :kick,    /^\:(.+)\!\~?(.+)\@(.+) KICK (\S+) (\S+)\s?:?(.+?)$/i,
-                     :nick, :ident, :host, :target, :channel, :reason
-                   
-      register_event :topic,  /^\:(.+)\!\~?(.+)\@(.+) TOPIC (\S+) :?(.+?)$/i,
-                     :nick, :ident, :host, :target, :topic
-                   
-      register_event :nick,    /^\:(.+)\!\~?(.+)\@(.+) NICK :?(.+?)$/i,
-                     :nick, :ident, :host, :new_nick
-
-      register_event :quit,    /^\:(.+)\!\~?(.+)\@(.+) QUIT :?(.+?)$/i,
-                     :nick, :ident, :host, :message
-                   
-      register_event :ping,   /^\:(.+)\!\~?(.+)\@(.+) PING (.*)$/,
-                     :nick, :ident, :host, :data
-                     
-      register_event :ping,  /PING (.*)$/, :data
-
-      register_event :numeric, /^\:(\S+) ([0-9]+) (.*)$/,
-                     :server, :code, :data
-    end 
-  end
-end

data/lib/marvin/status.rb

@@ -1,72 +0,0 @@
-module Marvin
-  class Status
-    CONTROLLERS = {
-      :client             => "IRC Client",
-      :server             => "IRC Server",
-      :ring_server        => "Ring Server",
-      :distributed_client => "Distributed Client",
-    }
-    
-    class << self
-      
-      def show!
-        STDOUT.puts ""
-        STDOUT.puts " Marvin Status"
-        STDOUT.puts " ============="
-        STDOUT.puts ""
-        if ARGV.include?("--help") || ARGV.include?("-h")
-          STDOUT.puts " Usage: script/status [options]\n\n"
-          STDOUT.puts " -h, --help    Show this message"
-          STDOUT.puts " -f, --full    Include distributed stats"
-          STDOUT.puts ""
-          exit
-        end
-        pids = {}
-        CONTROLLERS.each_key { |k| pids[k] = Marvin::Daemon.pids_for_type(k) }
-        CONTROLLERS.each do |k, v|
-          count = pids[k].size
-          postfix = count == 1 ? "" : "s"
-          STDOUT.puts " #{count} running instance#{postfix} of the #{CONTROLLERS[k]}"
-          STDOUT.puts " Pid#{postfix}: #{pids[k].join(", ")}" unless count == 0
-          STDOUT.puts ""
-        end
-        
-        if (ARGV.include?("-f") || ARGV.include?("--full")) && !pids[:ring_server].empty?
-          require 'rinda/ring'
-          DRb.start_service
-          STDOUT.puts " Distributed Status"
-          STDOUT.puts " ------------------"
-          begin
-            rs = Rinda::RingFinger.finger.lookup_ring(3)
-            STDOUT.puts " Ring Server:        #{rs.__drburi}"
-            items = rs.read_all([:marvin_event, Marvin::Settings.distributed_namespace, nil, nil, nil])
-            STDOUT.puts " Unprocessed Items:  #{items.size}"
-            STDOUT.puts ""
-            unless items.empty?
-              start_time = items.first[3][:dispatched_at]
-              STDOUT.puts  " Earliest Item:     #{start_time ? start_time.strftime("%I:%M%p %d/%m/%y") : "Never"}"
-              end_time   = items.last[3][:dispatched_at]
-              STDOUT.puts  " Latest Item:       #{end_time ? end_time.strftime("%I:%M%p %d/%m/%y") : "Never"}"
-              mapping = {}
-              items.each do |i|
-                mapping[i[2].inspect] ||= 0
-                mapping[i[2].inspect] += 1
-              end
-              width = mapping.keys.map { |k| k.length }.max
-              STDOUT.puts ""
-              STDOUT.puts " Unprocessed Message Counts:"
-              STDOUT.puts " ---------------------------"
-              mapping.each { |k, v| STDOUT.puts " #{k.ljust width}  => #{v}" }
-              STDOUT.puts ""
-            end
-          rescue
-            STDOUT.puts " Ring server not found."
-            STDOUT.puts ""
-          end
-        end
-        
-      end
-      
-    end
-  end
-end

data/script/client

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-require File.join(File.dirname(__FILE__), "..", "config", "boot")
-Marvin::Loader.run! :client

data/script/console

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-require File.join(File.dirname(__FILE__), "..", "config", "boot")
-Marvin::Loader.run! :console

data/script/distributed_client

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-require File.join(File.dirname(__FILE__), "..", "config", "boot")
-Marvin::Loader.run! :distributed_client

data/script/install

@@ -1 +0,0 @@
-gem uninstall marvin --quiet && rake gemspec  && gem build marvin.gemspec && gem install marvin-*.gem

data/script/ring_server

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-require File.join(File.dirname(__FILE__), "..", "config", "boot")
-Marvin::Loader.run! :ring_server
-

data/script/server

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-require File.join(File.dirname(__FILE__), "..", "config", "boot")
-Marvin::Loader.run! :server
-

data/script/status

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-require File.join(File.dirname(__FILE__), "..", "config", "boot")
-Marvin::Status.show!

data/spec/marvin/abstract_client_test.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-# Tests the behaviour of the AbstractClient functionality
-# via a thin wrapper of the class via Marvin::TestClient.
-
-describe "the base Marvin::TestClient functionality" do
-  
-  it "should dispatch :client_connected as the first event on process_connect" do
-    client(true).dispatched_events.should == []
-    client.process_connect
-    client.dispatched_events.first.should == [:client_connected, {}]
-  end
-  
-  it "should dispatch :client_connected as the first event on process_connect" do
-    client(true).dispatched_events.should == []
-    client.process_connect
-    Marvin::Logger.info client.outgoing_commands.inspect
-    client.dispatched_events[-2].first.should == :outgoing_nick
-    client.dispatched_events[-1].first.should == :outgoing_join
-    client.outgoing_commands.length.should == 3
-    client.outgoing_commands[0].should =~ /^USER \w+ 0 \* :\w+ \r\n$/
-    client.outgoing_commands[1].should =~ /^NICK \w+ \r\n$/
-    client.outgoing_commands[2].should =~ /^JOIN \#[A-Za-z0-9\-\_]+ \r\n$/
-  end
-  
-  it "should dispatch :client_disconnect on process_disconnect" do
-    client(true).dispatched_events.should == []
-    client.process_disconnect
-    client.dispatched_events.last.should == [:client_disconnected, {}]
-  end
-  
-  it "should add an :incoming_line event for each incoming line" do
-    client(true).dispatched_events.should == []
-    client.receive_line "SOME RANDOM LINE THAT HAS ZERO ACTUAL USE"
-    client.dispatched_events.first.should == [:incoming_line, {:line => "SOME RANDOM LINE THAT HAS ZERO ACTUAL USE"}]
-  end
-  
-end

data/spec/spec_helper.rb

@@ -1,14 +0,0 @@
-require "rubygems"
-require "bacon"
-
-require File.dirname(__FILE__) + "/../lib/marvin"
-# Now, Set everything up.
-Marvin::Logger.logger = Logger.new(File.dirname(__FILE__) + "/../log/test.log")
-Marvin::Settings.default_client = Marvin::TestClient
-Marvin::Loader.run!
-
-def client(force_new = false)
-  $test_client = Marvin::TestClient.new if force_new || $test_client.nil?
-  return $test_client
-end
-