ircbot 0.0.2 → 0.1.0

data/lib/ircbot/core_ext/delegation.rb

@@ -0,0 +1,135 @@
+class Module
+  # Provides a delegate class method to easily expose contained objects' methods
+  # as your own. Pass one or more methods (specified as symbols or strings)
+  # and the name of the target object as the final <tt>:to</tt> option (also a symbol
+  # or string).  At least one method and the <tt>:to</tt> option are required.
+  #
+  # Delegation is particularly useful with Active Record associations:
+  #
+  #   class Greeter < ActiveRecord::Base
+  #     def hello()   "hello"   end
+  #     def goodbye() "goodbye" end
+  #   end
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :to => :greeter
+  #   end
+  #
+  #   Foo.new.hello   # => "hello"
+  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+  #
+  # Multiple delegates to the same target are allowed:
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :goodbye, :to => :greeter
+  #   end
+  #
+  #   Foo.new.goodbye # => "goodbye"
+  #
+  # Methods can be delegated to instance variables, class variables, or constants
+  # by providing them as a symbols:
+  #
+  #   class Foo
+  #     CONSTANT_ARRAY = [0,1,2,3]
+  #     @@class_array  = [4,5,6,7]
+  #     
+  #     def initialize
+  #       @instance_array = [8,9,10,11]
+  #     end
+  #     delegate :sum, :to => :CONSTANT_ARRAY
+  #     delegate :min, :to => :@@class_array
+  #     delegate :max, :to => :@instance_array
+  #   end
+  #
+  #   Foo.new.sum # => 6
+  #   Foo.new.min # => 4
+  #   Foo.new.max # => 11
+  #
+  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+  # delegated to.
+  #
+  #   Person = Struct.new(:name, :address)
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => true
+  #   end
+  #
+  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.client_name    # => "John Doe"
+  #   invoice.client_address # => "Vimmersvej 13"
+  #
+  # It is also possible to supply a custom prefix.
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => :customer
+  #   end
+  #
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.customer_name    # => "John Doe"
+  #   invoice.customer_address # => "Vimmersvej 13"
+  #
+  # If the object to which you delegate can be nil, you may want to use the
+  # :allow_nil option. In that case, it returns nil instead of raising a
+  # NoMethodError exception:
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar
+  #  end
+  #
+  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar, :allow_nil => true
+  #  end
+  #
+  #  Foo.new.zoo   # returns nil
+  #
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    end
+
+    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
+
+    methods.each do |method|
+      on_nil =
+        if options[:allow_nil]
+          'return'
+        else
+          %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        end
+
+      module_eval(<<-EOS, file, line)
+        def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
+        rescue NoMethodError                                # rescue NoMethodError
+          if #{to}.nil?                                     #   if client.nil?
+            #{on_nil}
+          else                                              #   else
+            raise                                           #     raise
+          end                                               #   end
+        end                                                 # end
+      EOS
+    end
+  end
+end

data/lib/ircbot/core_ext/extending.rb

@@ -0,0 +1,80 @@
+class Object
+  def remove_subclasses_of(*superclasses) #:nodoc:
+    Class.remove_class(*subclasses_of(*superclasses))
+  end
+
+  begin
+    ObjectSpace.each_object(Class.new) {}
+
+    # Exclude this class unless it's a subclass of our supers and is defined.
+    # We check defined? in case we find a removed class that has yet to be
+    # garbage collected. This also fails for anonymous classes -- please
+    # submit a patch if you have a workaround.
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(class << sup; self; end) do |k|
+          if k != sup && (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+      end
+
+      subclasses
+    end
+  rescue RuntimeError
+    # JRuby and any implementations which cannot handle the objectspace traversal
+    # above fall back to this implementation
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(Class) do |k|
+          if superclasses.any? { |superclass| k < superclass } &&
+            (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+        subclasses.uniq!
+      end
+      subclasses
+    end
+  end
+
+  def extended_by #:nodoc:
+    ancestors = class << self; ancestors end
+    ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
+  end
+
+  def extend_with_included_modules_from(object) #:nodoc:
+    object.extended_by.each { |mod| extend mod }
+  end
+
+  unless defined? instance_exec # 1.9
+    module InstanceExecMethods #:nodoc:
+    end
+    include InstanceExecMethods
+
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
+    end
+  end
+end

data/lib/ircbot/core_ext/message.rb

@@ -0,0 +1,18 @@
+######################################################################
+### core_ext 
+
+class Net::IRC::Message
+  def channel
+    params[0]
+  end
+
+  def message
+    params[1]
+  end
+
+  def reply(client, text)
+    to = (client.config.nick == params[0]) ? prefix.nick : params[0]
+    client.privmsg to, text.to_s unless text.to_s.empty?
+  end
+end
+

data/lib/ircbot/framework.rb

@@ -1,50 +1,32 @@
 module Ircbot
-  mattr_accessor :load_paths
-  self.load_paths = {}
-
-  class InvalidFilename < SecurityError; end
-  class FileNotFound < SecurityError; end
-
-  class Recover < RuntimeError
-    attr_reader :wait
-
-    def initialize(wait = 300)
-      @wait = wait
-    end
+  def paths
+    @paths ||= Mash.new
   end
 
-  class << self
-    def root
-      @root || File.expand_path(Dir.pwd)
-    end
-
-    def root=(value)
-      @root = value
-    end
+  def root
+    @root || Pathname(Dir.pwd).expand_path
+  end
 
-    def push_path(type, path, file_glob = "**/*.rb")
-      load_paths[type] = [Pathname(path), file_glob]
-    end
+  def system_root
+    (Pathname(File.dirname(__FILE__)) + ".." + "..").expand_path
+  end
 
-    def dir_for(type)
-      load_paths[type][0] or
-        raise RuntimeError, "directory not found: #{type}"
-    end
+  def root=(value)
+    @root = Pathname(value)
+  end
 
-    def glob_for(type)
-      load_paths[type][1]
-    end
+  def push_path(type, path)
+    paths[type] ||= []
+    paths[type] << Pathname(path)
+  end
 
-    def path_for(type, name)
-      name = name.to_s
-      raise InvalidFilename, name if name =~ %r{\.\.|~|/}
+  def glob_for(type, name)
+    Array(paths[type]).reverse.select{|p| p.directory?}.map{|d|
+      Dir.glob(d + "**/#{name}.*")
+    }.flatten.compact.map{|i| Pathname(i)}
+  end
 
-      path = dir_for(type) + name
-      path.readable_real? or
-        raise FileNotFound, name
+  attr_accessor :toplevel_binding
 
-      return path
-    end
-  end
+  extend self
 end
-

data/lib/ircbot/plugin.rb

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+module Ircbot
+  class Plugin
+    class Null
+      def method_missing(*)
+        self
+      end
+    end
+
+    class InitialMessage < Net::IRC::Message
+      def initialize(nick = nil)
+        super nick, "PRIVMSG", ["#channel", "(initialize)"]
+      end
+    end
+
+    attr_accessor :message
+    attr_accessor :plugins
+    attr_accessor :running
+    attr_accessor :plugin_name
+
+    def initialize(plugins = nil)
+      @plugins = plugins || Plugins.new
+      @message = InitialMessage.new(self.class.name)
+      @running = false
+    end
+
+    ######################################################################
+    ### Accessors
+
+    delegate :plugin!, :client, :bot, :config, :to=>"@plugins"
+
+    def plugin_name
+      @plugin_name ||= Extlib::Inflection.foreign_key(self.class.name).sub(/(_plugin)?_id$/,'')
+    end
+
+    def inspect
+      "<%sPlugin: %s>" % [running ? '*' : '', plugin_name]
+    end
+
+    def to_s
+      "%s%s" % [running ? '*' : '', plugin_name]
+    end
+
+    ######################################################################
+    ### Operations
+
+    def help
+      raise "no helps for #{plugin_name}"
+    end
+
+    private
+      def plugin(name)
+        plugin!(name)
+      rescue
+        Null.new
+      end
+
+      def direct?
+        message.channel == config.nick
+      end
+  end
+end

data/lib/ircbot/plugins.rb

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+
+module Ircbot
+  class PluginNotFound < RuntimeError; end
+
+  class Plugins
+    attr_reader :plugins
+    attr_reader :client
+    delegate :config, :to=>"client"
+
+    def initialize(client = nil, plugins = nil)
+      @client  = client  || Client::Standalone.new
+      @plugins = Dictionary.new
+
+      load_plugins Array(plugins)
+    end
+
+    ######################################################################
+    ### Enumerable
+
+    include Enumerable
+
+    def each(&block)
+      plugins.values.__send__(:each, &block)
+    end
+
+    ######################################################################
+    ### Accessors
+
+    def plugin!(name)
+      find_plugin!(name)
+    end
+
+    def plugin(name)
+      plugin!(name) rescue nil
+    end
+    alias :[] :plugin!
+
+    def bot
+      client
+    end
+
+    ######################################################################
+    ### Operations
+
+    def start(plugin)
+      find_plugin(plugin).running = true
+    end
+
+    def stop(plugin)
+      find_plugin(plugin).running = false
+    end
+
+    def load(plugin)
+      load_plugins(plugin)
+    end
+
+    def delete(plugin)
+      name = plugin.is_a?(Plugin) ? plugin.name : plugin.to_s
+      plugin!(name)
+      @plugins.delete(name)
+    end
+
+    ######################################################################
+    ### IO
+
+    def load_plugins(plugin)
+      case plugin
+      when Array
+        plugin.each do |name|
+          self << name
+        end
+      when Plugin
+        plugin.plugins = self
+        plugins[plugin.plugin_name] = plugin
+        plugin.running = true
+      when Class
+        if plugin.ancestors.include?(Ircbot::Plugin)
+          self << plugin.new(self)
+        else
+          raise ArgumentError, "#{plugin} is not Ircbot::Plugin"
+        end
+      when String, Symbol
+        begin
+          name = plugin.to_s
+          unless @plugins[name]
+            self << load_plugin(name)
+          end
+        rescue Exception => e
+          broadcast "Plugin error(#{name}): #{e}[#{e.class}]"
+        end
+      else
+        raise NotImplementedError, "#<< for #{plugin.class}"
+      end
+      return self
+    end
+    alias :<< :load_plugins
+
+    def load_plugin(name)
+      path = Ircbot.glob_for(:plugin, name).first or
+        raise PluginNotFound, name.to_s
+
+      script = path.read{}
+      eval(script, Ircbot.toplevel_binding)
+
+      class_name = Extlib::Inflection.camelize(name) + "Plugin"
+      return Object.const_get(class_name).new
+
+#       Object.subclasses_of(Plugin).each do |k|
+#         return k.new if Extlib::Inflection.demodulize(k.name) =~ /^#{class_name}(Plugin)?$/
+#       end
+
+    rescue NameError => e
+      raise LoadError, "Expected #{path} to define #{class_name} (#{e})"
+    end
+
+    def active
+      select(&:running)
+    end
+
+    def inspect
+      plugins.values.inspect
+    end
+
+    private
+      def find_plugin!(plugin)
+        case plugin
+        when String, Symbol
+          @plugins[plugin.to_s] or raise PluginNotFound, plugin.to_s
+        when Plugin
+          plugin
+        else
+          raise PluginNotFound, "#{plugin.class}(#{plugin})"
+        end
+      end
+
+      def broadcast(text)
+        p text
+      end
+  end
+end