can_has_bots 0.1.0

data/HISTORY

@@ -0,0 +1,4 @@
+can_has_fixtures Release History
+
+Version 0.1.0 (22 March 2008)
+  * Initial release.

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2008 Ben Burkert <ben@benburkert.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of this project nor the names of its contributors may be
+      used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,44 @@
+= can_has_bots
+
+"The box is locked, the lights are on, it's robot fightin' time!"
+
+Author::      Ben Burkert (mailto:ben@benburkert.com)
+Version::     0.1.0
+Copyright::   Copyright (c) 2008 Ben Burkert. All rights reserved.
+License::     New BSD License (http://opensource.org/licenses/bsd-license.php)
+Website::     http://canhasgems.rubyforge.org/can_has_bots
+Repository::  git://github.com/benburkert/can_has_bots.git
+
+== Dependencies
+
+== Basic Usage
+
+can_has_bots started off as helpers for writing long running processes, and quickly turned into a DSL
+for creating said bots.  The author never got around to finishing the Erlang book, so the design is
+based on what little he understood of the Actor pattern.  Here is an example bot:
+
+  class TweetReceiverBot < CanHasBots::Base
+    acts_as_bot
+
+    input_type  Jabber
+    output_type Starling
+
+    register_input_message
+    register_output_queue(:tweets)
+
+    worker do |message|
+      info "Message received: #{message.from}: #{message.body}"
+      output(message.body) if message.from == "twitter@twitter.com"
+    end
+  end
+
+This bot, like all others, is comprised of three parts: inputs, outputs, and the worker.  Input's are
+the interface into the bot; message arrives in an input, and is sent to the worker for processing.  In
+this example, the input listens for xmpp messages.  Naturally, the output receivers are the interfaces
+out of the bot.  A Starling queue, in this case
+
+The worker is a method that takes all input, does something, then sends it to the output.  All inputs
+send their packages to the worker, and all outputs receive the same package from the worker.  There can
+be only one input type, but many output types (for now, at least).
+
+Browse the examples folder for more examples of bots.

data/Rakefile

@@ -0,0 +1,75 @@
+# -*- ruby -*-
+
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require 'rake/rdoctask'
+require "spec"
+require "spec/rake/spectask"
+
+DIR = File.dirname(__FILE__)
+NAME = 'can_has_bots'
+SUMMARY =<<-EOS
+DSL for creating bots.
+EOS
+
+require "lib/#{NAME}/version"
+
+spec = Gem::Specification.new do |s|
+  s.name         = NAME
+  s.summary      = SUMMARY
+
+  s.version      = CanHasBots::VERSION
+  s.platform     = Gem::Platform::RUBY
+
+  s.require_path = "lib"
+  s.files        = %w(Rakefile LICENSE HISTORY README TODO) + Dir["{lib,adapters,examples}/**/*"]
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+  package.need_zip = true
+  package.need_tar = true
+end
+
+##############################################################################
+# Documentation
+##############################################################################
+task :doc => "doc:rerdoc"
+namespace :doc do
+
+  Rake::RDocTask.new do |rdoc|
+    files = %w(Rakefile README) + Dir["{lib,adapters,examples}/**/*"]
+    rdoc.rdoc_files.add(files)
+    rdoc.main = 'README'
+    rdoc.title = 'I CAN HAS BOTS?  HUZZAH!'
+    rdoc.template = 'tools/allison-2.0.3/lib/allison'
+    rdoc.rdoc_dir = "doc/#{NAME}/rdoc"
+    rdoc.options << '--line-numbers' << '--inline-source'
+  end
+
+  desc "rdoc to rubyforge"
+  task :rubyforge => :doc do
+    sh %{chmod -R 755 doc}
+    sh %{/usr/bin/scp -r -p doc/#{NAME}/rdoc/* benburkert@rubyforge.org:/var/www/gforge-projects/canhasgems/#{NAME}}
+  end
+end
+
+##############################################################################
+# rSpec & rcov
+##############################################################################
+desc "Run all specs"
+Spec::Rake::SpecTask.new("specs") do |t|
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = Dir["spec/**/*_spec.rb"].sort
+end
+
+##############################################################################
+# release
+##############################################################################
+task :release => [:specs, :package] do
+  sh %{rubyforge add_release canhasgems #{NAME} "#{CanHasBots::VERSION}" pkg/#{NAME}-#{CanHasBots::VERSION}.gem}
+  %w[zip tgz].each do |ext|
+    sh %{rubyforge add_file canhasgems #{NAME} #{CanHasBots::VERSION} pkg/#{NAME}-#{CanHasBots::VERSION}.#{ext}}
+  end
+end

data/adapters/data_mapper/bot.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'data_mapper'
+
+module DataMapper::Bot
+  module Common
+    include CanHasBots::Adapter
+    attr_accessor :config_file, :db_config, :environment, :models
+    
+    def connect_database
+      info "Attempting to connect to #{@db_config[:adapter]}://#{@db_config[:host] || :localhost}/#{@db_config[:database]}"
+      DataMapper::Database.setup(@db_config)
+      info "Connection to #{@db_config[:adapter]}://#{@db_config[:host] || :localhost}/#{@db_config[:database]} established successfully"
+    end
+    
+    mixins do
+      initializer do |config|
+        @adapter ||= @config.delete(:adapter)
+        @database ||= @config.delete(:database)
+        @username ||= @config.delete(:username)
+        
+        raise "You must supply an adapter" unless @adapter
+        raise "You must supply a database name" unless @database
+        raise "You must supply a username" unless @username
+        
+        @db_config = {
+          :adapter  => @adapter,
+          :database => @database,
+          :username => @username
+        }
+
+        connect_database
+      end
+    end
+  end
+  
+  module Output
+    include Common
+
+    macros do
+      def register_output_query(&block)
+        raise "register_output_query expects a block" if block.nil?
+        register_output_receiver do |*args|
+          block.call(*args)
+        end
+      end
+    end
+  end
+end

data/adapters/jabber/bot.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'xmpp4r'
+
+module Jabber::Bot
+  module Input
+    include Jabber
+    include CanHasBots::Adapter
+    
+    attr_accessor :node, :domain, :resource, :passwd, :presence
+        
+    initializer do
+      @@resource_count ||= 0
+      @node ||= @config.delete(:node)
+      @domain ||= @config.delete(:domain)
+      @resource ||= @config.delete(:resource) || generate_resource
+      @passwd ||= @config.delete(:passwd)
+      @presence ||= @config.delete(:presence) || :available
+      
+      raise "You must supply a node" unless @node
+      raise "You must supply a domain" unless @domain
+      raise "You must supply a passwd" unless @passwd
+      
+      info "Attempting to connect Jabber ID: #{@node}@#{@domain}/#{resource}"
+      @jid = JID::new(@node, @domain, @resource)
+      @client = Client.new(@jid)
+      @client.connect
+      
+      info "Jabber connection made, authenticating"
+      @client.auth(@passwd)
+      @client.send(Presence.new.set_type(@presence))
+      
+      info "#{@node}@#{@domain}/#{resource} is now #{@presence}"
+    end
+    
+    def generate_resource
+      "#{`hostname`.chomp}-#{Process.pid}-#{@@resource_count += 1}"
+    end
+    
+    mixins do
+      runner do
+        Thread.new(self) do |instance|
+          instance.input_receivers.each do |proc|
+            instance.instance_eval(&proc)
+          end
+        end
+      end
+    end
+    
+    macros do
+      def register_input_message(&block)
+        register_input_receiver do
+          @client.add_message_callback do |message|
+            input(message)
+          end
+        end
+      end
+    end
+  end
+end

data/adapters/starling/bot.rb

@@ -0,0 +1,96 @@
+require 'rubygems'
+require 'starling'
+
+module Starling::Bot
+  module Common
+    include CanHasBots::Adapter
+    
+    attr_accessor :starling_host, :starling_port, :starling
+    
+    mixins do
+      initializer do
+        @starling_host ||= @config.delete(:starling_host) || 'localhost'
+        @starling_port ||= @config.delete(:starling_port) || 22122
+
+        unless @starling
+          info("Connecting to Starling server at '#{starling_server}'")
+          @starling = Starling.new(starling_server)
+          test_starling_connection
+        end
+      end
+
+      def starling_server
+        "#{@starling_host}:#{@starling_port}"
+      end
+
+      def test_starling_connection
+        info("Testing connection to Starling server")
+        begin
+          @starling.set("test_queue", :connection_test)
+          @starling.get("test_queue")
+        rescue Exception => e
+          raise "Error connecting to the Starling server at '#{starling_server}': #{e}"
+        end
+      end
+    end
+  end
+  
+  module Input
+    include Common
+    
+    mixins do
+      runner do
+        threads = []
+        input_receivers.each do |proc|
+          threads << Thread.new(self, proc) do |instance, proc|
+            instance.instance_eval(&proc)
+          end
+        end
+
+        threads
+      end
+    end
+    
+    macros do
+      def register_input_queue(name, &block)
+        register_input_receiver do
+          loop do
+            begin
+              if block.nil?
+                input(@starling.get(name.to_s))
+              else
+                input(block.call(@starling.get(name.to_s)))
+              end
+            rescue Exception => e
+              error "Error while reading from Starling #{e}: \"#{e.message}\""
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  module Output
+    include Common
+    
+    def send_to_queue(name, *args)
+      begin
+        @starling.set(name.to_s, *args)
+      rescue Exception => e
+        error "Error while writing to Starling #{e}: \"#{e.message}\""
+      end
+    end
+    
+    macros do
+      def register_output_queue(name, &block)
+        register_output_receiver do |*args|
+          if block.nil?
+            send_to_queue(name, *args)
+          else
+            send_to_queue(name, block.call(*args))
+          end
+        end
+      end
+    end
+  end
+end

data/examples/tweecrets/init.rb

@@ -0,0 +1,10 @@
+require "#{File.dirname(__FILE__)}/../../lib/can_has_bots"
+
+require 'data_mapper'
+
+DataMapper::Database.setup(:adapter => :sqlite3, :database => "tweecrets.db")
+
+require "models/user"
+require "models/tweecret"
+
+DataMapper::Base.auto_migrate!

data/examples/tweecrets/message_parser_bot.rb

@@ -0,0 +1,14 @@
+class MessageParserBot < CanHasBots::Base
+  acts_as_bot
+  
+  input_type  Starling
+  output_type Starling
+  
+  register_input_queue(:tweets)
+  register_output_queue(:tweecrets)
+  
+  worker do |message|
+    info "Message received: #{message}"
+    output(:username => $1, :message => $2) if message =~ /^Direct from (\w+):\n(.*)\n\nReply\swith\s'd\s(\w+)\shi\.'$/m
+  end
+end

data/examples/tweecrets/models/tweecret.rb

@@ -0,0 +1,4 @@
+class Tweecret < DataMapper::Base
+  property :message, :string
+  belongs_to :user
+end

data/examples/tweecrets/models/user.rb

@@ -0,0 +1,4 @@
+class User < DataMapper::Base
+  property :username, :string
+  has_many :tweecrets
+end

data/examples/tweecrets/run.rb

@@ -0,0 +1,30 @@
+require "#{File.dirname(__FILE__)}/../../lib/can_has_bots"
+
+require 'data_mapper/bot'
+require 'jabber/bot'
+require 'starling/bot'
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require "message_parser_bot"
+require "store_tweecret_bot"
+require "tweet_receiver_bot"
+
+autoload :User, "models/user"
+autoload :Tweecret, "models/tweecret"
+
+MessageParserBot.new.run
+
+StoreTweecretBot.new do
+  @adapter = :sqlite3
+  @database = "tweecrets.db"
+  @username = "ben"
+end.run
+
+TweetReceiverBot.new do
+  @node = "tweecrets"
+  @domain = "gmail.com"
+  @passwd = "matsumoto"
+end.run
+
+Thread.stop

data/examples/tweecrets/store_tweecret_bot.rb

@@ -0,0 +1,15 @@
+class StoreTweecretBot < CanHasBots::Base
+  acts_as_bot
+  
+  input_type  Starling
+  output_type DataMapper
+  
+  register_input_queue(:tweecrets)
+  
+  worker do |username_and_message|
+    info "Finding or creating #{username_and_message[:username]}"
+    user = User.find_or_create(:username => username_and_message[:username])
+    info "Creating #{username_and_message[:message]}"
+    Tweecret.create(:user => user, :message => username_and_message[:message])
+  end
+end

data/examples/tweecrets/tweet_receiver_bot.rb

@@ -0,0 +1,14 @@
+class TweetReceiverBot < CanHasBots::Base
+  acts_as_bot
+  
+  input_type  Jabber
+  output_type Starling
+  
+  register_input_message
+  register_output_queue(:tweets)
+  
+  worker do |message|
+    info "Message received: #{message.from}: #{message.body}"
+    output(message.body) if message.from == "twitter@twitter.com"
+  end
+end

data/lib/can_has_bots.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'logger'
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../adapters"
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require "can_has_bots/core_ext/class"
+require "can_has_bots/core_ext/module"
+require "can_has_bots/core_ext/object"
+require "can_has_bots/core_ext/thread_group"
+
+module CanHasBots; end
+
+require "can_has_bots/adapter"
+require "can_has_bots/base"

data/lib/can_has_bots/adapter.rb

@@ -0,0 +1,13 @@
+module CanHasBots::Adapter
+  macros do
+    def initializer(&block)
+      included_callback do |base|
+        base.register_initializer(&block)
+      end
+    end
+    
+    def runner(&block)
+      self.register_runner(&block)
+    end
+  end
+end

data/lib/can_has_bots/base.rb

@@ -0,0 +1,133 @@
+module CanHasBots
+  class Base
+    
+    klass.class_eval do
+      def acts_as_bot
+        self.class_eval do
+          cattr_accessor :initializers, :runners, :input_receivers, :output_receivers, :worker_proc
+          self.initializers = []
+          self.runners = []
+          self.input_receivers = []
+          self.output_receivers = []
+        end
+      end
+    end
+    
+    def self.register_initializer(&block)
+      initializers << block
+    end
+    
+    def self.register_runner(&block)
+      runners << block
+    end
+    
+    def self.input_type(mod)
+      include mod.const_get(:Bot).const_get(:Input)
+    end
+    
+    def self.output_type(*mods)
+      mods.each {|mod| include mod.const_get(:Bot).const_get(:Output)}
+    end
+    
+    class << self
+      alias_method :output_types, :output_type
+    end
+    
+    def self.register_input_receiver(&block)
+      input_receivers << block
+    end
+    
+    def self.register_output_receiver(&block)
+      output_receivers << block
+    end
+    
+    def self.worker(&block)
+      self.worker_proc = block
+    end
+    
+    attr_accessor :input_procs, :output_procs
+    attr_accessor :log_file, :log_level
+    attr_accessor :logger
+    
+    def initialize(config = {}, &block)
+      @input_procs, @output_procs = [], []
+      
+      @log_file ||= config[:log_file] || $stdout
+      @environment ||= config[:environment] || :development
+      @log_level ||= config[:log_level] || @environment
+      
+      instance_eval(&block) unless block.nil?
+      
+      @logger = Logger.new(@log_file)
+      @logger.level = case @log_level
+      when :development then Logger::DEBUG
+      when :test        then Logger::WARN
+      when :production  then Logger::ERROR
+      end
+      
+      @config = config
+      initializers.each {|initializer| instance_eval(config, &initializer) }
+    end
+    
+    def unknown(*args)
+      args.each {|m| @logger.unknown(klass.name) {m} }
+    end
+    
+    def fatal(*args)
+      args.each {|m| @logger.fatal(klass.name) {m} }
+    end
+    
+    def error(*args)
+      args.each {|m| @logger.error(klass.name) {m} }
+    end
+    
+    def warn(*args)
+      args.each {|m| @logger.warn(klass.name) {m} }
+    end
+    
+    def info(*args)
+      args.each {|m| @logger.info(klass.name) {m} }
+    end
+    
+    def debug(*args)
+      args.each {|m| @logger.debug(klass.name) {m} }
+    end
+    
+    def run
+      threads = ThreadGroup.new
+      klass.runners.each do |proc|
+        [instance_eval(&proc)].flatten.each do |thread|
+          threads.add thread
+        end
+      end
+      
+      threads
+    end
+    
+    def input(*args)
+      begin
+        instance_eval(*args, &worker_proc)
+      rescue Exception => e
+        fatal "exception #{e.class} #{e}, #{e.message}: #{e.backtrace}"
+      end
+    end
+    
+    def output(*args)
+      begin
+        klass.output_receivers.each do |output_receiver|
+          instance_eval(*args, &output_receiver)
+        end
+      rescue Exception => e
+        fatal "exception #{e.class} #{e}, #{e.message}: #{e.backtrace}"
+      end
+    end
+    
+    def raise_with_logging(*args)
+      fatal(*args)
+      raise_without_logging(*args)
+    end
+    
+    alias_method :raise_without_logging, :raise
+    alias_method :raise, :raise_with_logging
+  end
+end

data/lib/can_has_bots/core_ext/class.rb

@@ -0,0 +1,192 @@
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+  
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+      
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => (value.dup rescue value))
+        end
+      end
+      
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/can_has_bots/core_ext/module.rb

@@ -0,0 +1,35 @@
+class Module
+  attr_accessor :macro_blocks, :mixin_blocks, :included_callbacks
+  
+  def macros(&block)
+    @macro_blocks ||= [] << block
+  end
+  
+  def mixins(&block)
+    @mixin_blocks ||= [] << block
+  end
+  
+  def included_with_meta(base, &block)
+    (@macro_blocks ||= []).each do |block|
+      base.class.class_eval(&block)
+    end
+    
+    (@mixin_blocks ||= []).each do |block|
+      base.class_eval(&block)
+    end
+    
+    case base.class
+    when Class then (@included_callbacks ||= []).each {|ic| base.instance_eval(&ic)}
+    when Module then (@included_callbacks ||= []).each {|ic| base.included_callbacks << ic}
+    end
+    
+    included_without_meta(base, &block)
+  end
+  
+  alias_method :included_without_meta, :included
+  alias_method :included, :included_with_meta
+  
+  def included_callback(&block)
+    @included_callbacks ||= [] << block
+  end
+end

data/lib/can_has_bots/core_ext/object.rb

@@ -0,0 +1,28 @@
+class Object
+  def klass
+    self.class
+  end
+  
+  def instance_eval_with_args_check(*args, &block)
+    unless args.empty? || block.nil?
+      instance_eval_with_args(*args, &block)
+    else
+      instance_eval_without_args_check(*args, &block)
+    end
+  end
+  
+  alias_method :instance_eval_without_args_check, :instance_eval
+  alias_method :instance_eval, :instance_eval_with_args_check
+  
+  def instance_eval_with_args(*args, &block)
+    while respond_to?(random_name = "temp_method#{rand(10)}"); end
+    
+    klass.class_eval do
+      define_method(random_name, &block)
+    end
+    
+    self.send(random_name, *args)
+    
+    klass.class_eval("undef #{random_name}")
+  end
+end

data/lib/can_has_bots/core_ext/thread_group.rb

@@ -0,0 +1,5 @@
+class ThreadGroup
+  def join
+    list.each {|t| t.join if t != Thread.current}
+  end
+end

data/lib/can_has_bots/version.rb

@@ -0,0 +1,3 @@
+module CanHasBots
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: can_has_bots
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-03-22 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- LICENSE
+- HISTORY
+- README
+- TODO
+- lib/can_has_bots
+- lib/can_has_bots/adapter.rb
+- lib/can_has_bots/base.rb
+- lib/can_has_bots/core_ext
+- lib/can_has_bots/core_ext/class.rb
+- lib/can_has_bots/core_ext/module.rb
+- lib/can_has_bots/core_ext/object.rb
+- lib/can_has_bots/core_ext/thread_group.rb
+- lib/can_has_bots/version.rb
+- lib/can_has_bots.rb
+- adapters/data_mapper
+- adapters/data_mapper/bot.rb
+- adapters/jabber
+- adapters/jabber/bot.rb
+- adapters/starling
+- adapters/starling/bot.rb
+- examples/tweecrets
+- examples/tweecrets/init.rb
+- examples/tweecrets/message_parser_bot.rb
+- examples/tweecrets/models
+- examples/tweecrets/models/tweecret.rb
+- examples/tweecrets/models/user.rb
+- examples/tweecrets/run.rb
+- examples/tweecrets/store_tweecret_bot.rb
+- examples/tweecrets/tweecrets.db
+- examples/tweecrets/tweet_receiver_bot.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: DSL for creating bots.
+test_files: []
+