crazydoll 0.0.1

data/README.md

@@ -0,0 +1,26 @@
+# CrazyDoll
+
+## Whats?
+  CrazyDoll is a simple IRC bot that aim flexibility.
+  With CrazyDoll you can:
+
+  *   Use a different backend for config like MySQL, PostgreSQL, FireBird
+      or any other ruby supported backend(currently only using YAML)
+  *   Run multiple bots on same ruby process.
+  *   Bots do not share the plugins. You can can have join and nick plugin
+      to Bot A and nick and search plugin to Bot B
+  *   Use a different IRC library
+  *   More coming soon...
+
+
+## How I install?
+  Only run `gem install crazydoll`
+
+## How I use it?
+  Given that the path of bin folder is in your $PATH variable, only run `crazy_doll`
+  In first time it will run a wizard to add basic info
+  If you want to re-run this wizard, only delete `~/.crazy_doll/database.yaml`
+
+## License
+  This project is licensed under MIT license.
+  See MIT-LICENSE file for more details.

data/bin/crazy_doll

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+#encoding: utf8
+
+file = File.join(File.dirname(__FILE__), '..', 'lib', 'crazy_doll.rb')
+if FileTest.file?(file)
+  require file
+else
+  require 'rubygems'
+  require 'crazy_doll'
+end
+
+CrazyDoll.init

data/lib/crazy_doll.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH << File.dirname(File.expand_path(__FILE__))
+
+require 'rubygems'
+require 'net/irc'
+require 'httparty'
+require 'crazy_doll/core'
+require 'crazy_doll/fixes'
+require 'crazy_doll/config'
+require 'crazy_doll/config_backend/yaml'
+require 'crazy_doll/events'
+require 'crazy_doll/irc'
+require 'crazy_doll/plugin_manager'
+require 'crazy_doll/message'
+require 'crazy_doll/bot'
+require 'crazy_doll/wizard'

data/lib/crazy_doll/bot.rb

@@ -0,0 +1,25 @@
+class CrazyDoll::Bot
+
+
+  attr_reader :irc, :event_manager, :plugin_manager, :config
+  def initialize(config=nil)
+    @config         = config || CrazyDoll::Config.new('yaml', File.join(ENV['HOME'], '.crazy_doll','database.yaml'))
+    core_config     = @config.config_of 'Core'
+    @irc            = CrazyDoll::IRC.new(core_config.server, core_config.port)
+    @event_manager  = CrazyDoll::EventManager.new(@irc)
+    @plugin_manager = CrazyDoll::PluginManager
+    @plugin_manager.load_plugins
+    @plugin_manager.find_usable_errors
+    @plugin_manager.register_plugins(@event_manager, @config)
+  end
+
+  def start
+    @config.start_use
+    begin
+      @irc.start
+    ensure
+      @config.end_use
+    end
+  end
+
+end

data/lib/crazy_doll/config.rb

@@ -0,0 +1,131 @@
+require 'yaml'
+
+module CrazyDoll::Config
+
+  def self.new(type, *args)
+    case type
+    when /yaml/i then Backend::YAML.new(*args)
+    else raise ArgumentError, "no config backend #{type.inspect}"
+    end
+  end
+
+  def self.parse(owner, key, description, value)
+    out = setup_class(value.class) unless value.respond_to?(:crazy_doll_setuped?) and value.to_yaml('class_setuped?') == 'YES SIR !'
+    return value if value.crazy_doll_setuped?
+    value.owner       = owner
+    value.key         = key
+    value.description = description
+    value
+  end
+
+  def self.setup_class(klass)
+    klass.class_eval do
+      def crazy_doll_setuped?
+        @owner and @key and @description ? true : false
+      end
+
+      alias :crazy_doll_setuped :crazy_doll_setuped?
+
+      [['owner', 'to_s'], ['key', 'to_sym'], ['description', 'to_s']].each do |name,m|
+        class_eval <<-EVAL
+          def #{name}
+            @#{name} || nil
+          end
+
+          def #{name}=(value)
+            raise ArgumentError, "can't redefine #{name}" if defined?(@#{name})
+            @#{name} = value.#{m}
+          end
+        EVAL
+      end
+
+      alias :__to_yaml :to_yaml
+
+      def _to_yaml(opts = {})
+        return __to_yaml(opts) unless crazy_doll_setuped?
+        a, b, c = @owner, @key, @description
+        ['@owner', '@key', '@description'].each { |x| remove_instance_variable(x) }
+        begin
+          return __to_yaml(opts)
+        ensure
+          @owner, @key, @description = a, b, c
+        end
+      end
+
+      def to_yaml( opts = {} )
+        return 'YES SIR !' if opts == 'class_setuped?'
+        return _to_yaml(opts) unless crazy_doll_setuped?
+        YAML.quick_emit( self.object_id, opts ) do |out|
+          out.map( "tag:crazydoll.org,2010:ConfigVar", "crazydoll.org,2010/ConfigVar" ) do |map|
+            map.add('owner',       self.owner      )
+            map.add('key',         self.key        )
+            map.add('description', self.description)
+            map.add('value',       self._to_yaml   )
+          end
+        end
+      end
+    end
+  end
+
+  class Instance
+
+    attr_reader :config, :owner
+    def initialize(owner, config={})
+      @config = config.empty? ? {} : config
+      @owner  = owner
+      @config.keys.each { |k| create_key(k) }
+    end
+
+    def register(owner, key, description, value)
+      k = key.to_sym
+      return false if @config[k]
+      @config[k] = CrazyDoll::Config.parse(@owner, key, description, value)
+      create_key(k)
+    end
+
+    private
+    def create_key(name)
+      self.instance_eval <<-EVAL
+        def #{name}
+          @config[:#{name}]
+        end
+
+        def #{name}=(val)
+          c = @config[:#{name}]
+          key   = c.key
+          desc  = c.description
+          @config[:#{name}] = CrazyDoll::Config.parse(@owner, key, desc, val)
+        end
+      EVAL
+    end
+
+    def method_missing(name, *args, &block)
+      if name.to_s.match(/=$/) and args.size == 1
+        key = name.to_s.gsub(/=$/,'').to_sym
+        puts "!!! key #{key} missing, but creating !!!"
+        @config[key] = CrazyDoll::Config.parse(@owner, key, 'created by method_missing', args[0])
+        create_key(key)
+        @config[key]
+      elsif name.to_s.match(/\?$/) and self.respond_to?((k=name.to_s.gsub(/\?$/,'')))
+        puts "!!! method #{name} missing, creating it !!!"
+        self.instance_eval <<-EVAL
+          def #{name}
+            @config[:#{k}]
+          end
+        EVAL
+        send(name)
+      else
+        puts "!!! method #{name} missing !!!"
+        nil
+      end
+    end
+
+  end
+
+end
+
+CrazyDoll::Config.setup_class(Object)
+
+YAML.add_domain_type('crazydoll.org,2010', 'ConfigVar') do |type,val|
+  CrazyDoll::Config.parse(val['owner'], val['key'], val['description'], YAML.load(val['value']))
+end

data/lib/crazy_doll/config_backend/yaml.rb

@@ -0,0 +1,69 @@
+require 'thread'
+require 'fileutils'
+
+module CrazyDoll::Config::Backend
+
+  class YAML
+
+    attr_reader :instances
+    def initialize(file)
+      @file = file
+      self.load
+    end
+
+    def start_use
+      @thread = Thread.new(self) do |b|
+        loop do
+          sleep 60
+          b.save
+        end
+      end
+    end
+
+    def end_use
+      @thread.kill if @thread and @thread.alive?
+    end
+
+    def setup_table_if_needed
+      FileUtis.mkdir_p(File.dirname(@file)) unless FileTest.directory?(File.dirname(@file))
+      File.open(@file, "w+") { |f| f.write(::YAML.dump({})) } unless FileTest.file?(@file)
+    end
+
+    def create_instances(data=nil)
+      return false unless data.is_a?(Hash)
+      @instances ||= {}
+      keys = data.keys
+      keys.each do |k|
+        key = real_key(k)
+        @instances[key] = CrazyDoll::Config::Instance.new(key, data[k])
+      end
+    end
+
+    def load
+      setup_table_if_needed
+      create_instances(::YAML.load_file(@file))
+    end
+
+    def save
+      setup_table_if_needed
+      d = {}
+      @instances.each { |k,v| d[k] = v.config }
+      File.open(@file, 'w+') { |f| f.write(::YAML.dump(d)) }
+    end
+
+    def config_of(key)
+      key = real_key(key)
+      @instances[key] ||= CrazyDoll::Config::Instance.new(key, {})
+    end
+
+    def real_key(k)
+      [String, Symbol].include?(k.class) ? k.to_s : k.class.to_s
+    end
+
+    def [](key)
+      @instances[key]
+    end
+
+  end
+
+end

data/lib/crazy_doll/core.rb

@@ -0,0 +1,14 @@
+module CrazyDoll
+
+  VERSION = '0.0.1'.freeze
+
+  def self.init
+    config_file     = File.join(ENV['HOME'], '.crazy_doll', 'database.yaml')
+    config_instance = CrazyDoll::Config.new('yaml', config_file)
+    config          = config_instance.config_of 'Core'
+    CrazyDoll::Wizard.new(config)
+    config_instance.save
+    CrazyDoll::Bot.new(config_instance).start
+  end
+
+end

data/lib/crazy_doll/events.rb

@@ -0,0 +1,49 @@
+class CrazyDoll::Event
+
+  attr_reader :klass, :real_method_name, :method_name
+  def initialize(klass, opts = {})
+    @klass = klass
+    verify(opts)
+    @real_method_name, @method_name = opts[:real_method_name], opts[:method_name]
+  end
+
+  def verify(opts)
+    errors = []
+    errors << 'need a real method name' unless @klass.respond_to?(opts[:real_method_name])
+    errors << 'need a method name' unless opts[:method_name]
+    return true if errors.empty?
+    raise ArgumentError, errors.join(', ')
+  end
+
+  def call(opts, line='')
+    @klass.opts = opts
+    @klass.line = line
+    @klass.send(@real_method_name) rescue nil
+  end
+
+end
+
+class CrazyDoll::EventManager
+
+  attr_reader :irc, :events, :config
+  def initialize(irc)
+    @irc = irc
+    @irc.event_manager = self
+    @events = { :sys => {}, :get => {}, :put => {} }
+  end
+
+  def fire(type, name, opts = {}, line = '')
+    type, name = type.to_sym, name.to_sym
+    return false unless [:sys, :get, :put].include?(type)
+    @events[type][name] ||= []
+    @events[type][name].each { |x| x.call(opts, line) }
+    fire(type, :command_message, opts, line) if opts.is_a?(CrazyDoll::Message) and opts.command == 'PRIVMSG' and name != :command_message
+  end
+
+  def register(type, klass, opts)
+    type, name = type.to_sym, opts[:method_name].to_sym
+    @events[type][name] ||= []
+    @events[type][name] << CrazyDoll::Event.new(klass, opts)
+  end
+
+end

data/lib/crazy_doll/fixes.rb

@@ -0,0 +1,72 @@
+class Hash
+
+  def +(other_hash)
+    raise ArgumentError, 'hash + hash only' unless other_hash.class == Hash
+    new_hash = self.clone
+    for key in other_hash.keys
+      new_hash[key] = other_hash[key]
+    end
+    return new_hash
+  end
+
+end
+
+module YAML
+
+  def load_file(f)
+    return false unless FileTest.file?(f)
+    super
+  end
+
+end
+
+class String
+
+  def to_crazy_doll_regexp
+    x=(' ' << self).gsub(/([^\\])::(\S+)/, '\1(\S+)').gsub(/([^\\])\*\*(\S+)/, '\1(.*)').gsub(/#{0.chr}[^#{1.chr}]+#{1.chr}([^#{2.chr}]+)#{2.chr}/, '\1')
+    x[0] = ''
+    Regexp.new("^#{x}$")
+  end
+
+end
+
+class MatchData
+
+  def to_crazy_doll_params(line)
+    out = {}
+    params = (' ' << line).scan(/[^\\](::|\*\*)(\S+)|#{0.chr}([^#{1.chr}]+)#{1.chr}[^#{2.chr}]+#{2.chr}/).flatten.
+      map { |x| ['::', '**'].include?(x) ? nil : x }.compact
+    params.each_with_index do |key,idx|
+      out[key.to_sym] = self[idx+1]
+    end
+    OpenStruct.new(out)
+  end
+
+end
+
+Numeric.class_eval do
+  HUMAN_SIZES = [
+    [1024.0,          'K'],
+    [1048576.0,       'M'],
+    [1073741824.0,    'G'],
+    [1099511627776.0, 'P']
+  ]
+
+  def to_human_readable_size
+    return self if self < HUMAN_SIZES[0][0]
+    fsize, fletter = nil, nil
+
+    for size, letter in HUMAN_SIZES
+      t = self/size
+      if t <= 1024
+        fsize, fletter = size, letter
+        break
+      end
+    end
+    
+    fsize, fletter = HUMAN_SIZES.last if fsize.nil?
+
+    return "%.03f %s" % [self/fsize, fletter]
+  end
+
+end

data/lib/crazy_doll/irc.rb

@@ -0,0 +1,52 @@
+class CrazyDoll::IRC < Net::IRC::Client
+
+  attr_accessor :event_manager
+
+  def start
+    # reset config
+    @server_config = Message::ServerConfig.new
+    @socket = TCPSocket.open(@host, @port)
+    @event_manager.fire(:sys, :socket_start)
+    while l = @socket.gets
+      begin
+        @log.debug "RECEIVE: #{l.chomp}"
+        m = Message.parse(l)
+        name = real_name((COMMANDS[m.command.upcase] || m.command).downcase, m)
+        @log.debug "TYPE: get_#{name}"
+        @event_manager.fire(:get, name, CrazyDoll::Message.parse(l.chomp), l.chomp)
+        #next if on_message(m) === true
+        #name = "on_#{(COMMANDS[m.command.upcase] || m.command).downcase}"
+        #send(name, m) if respond_to?(name)
+      rescue Exception => e
+        warn e
+        warn e.backtrace.join("\r\t")
+        raise
+      rescue Message::InvalidMessage
+        @log.error "MessageParse: " + l.inspect
+      end
+    end
+    rescue IOError
+    ensure
+      finish
+  end
+
+  public :post
+
+  def finish
+    super
+    @event_manager.fire(:sys, :socket_stop)
+  end
+
+  def real_name(n,m)
+    $msg = [n, m]
+    o = if n == 'privmsg'
+      if m[0][0].chr == '#'
+        'chanmsg'
+      elsif m[1] == "\x01VERSION \x01"
+        'version'
+      end
+    end
+    o.nil? ? n : o
+  end
+
+end

data/lib/crazy_doll/message.rb

@@ -0,0 +1,102 @@
+class CrazyDoll::Message < OpenStruct
+
+  def self.parse_from(args)
+    return '' if args.nil?
+    if args.class == MatchData
+      new({ :nick => args[1], :user => args[2], :host => args[3] })
+    else
+      new({ :nick => args[0], :user => args[1], :host => args[2] })
+    end
+  end
+
+
+  def self.parse(line)
+
+    new case line
+    when /\A:([^!]+)!([^@]+)@(\S+) PRIVMSG (\S+) :(.*)\z/ then
+      {
+        :from    => parse_from($~),
+        :command => "PRIVMSG",
+        :to      => $~[4],
+        :message => $~[5]
+      }
+    when /\APING :(.*)$/                                  then
+      {
+        :from    => $~[1],
+        :to      => $~[1],
+        :command => "PING"
+      }
+    when /\A:([^!]+)!([^@]+)@(\S+) NOTICE (\S+) :(.*)\z/  then
+      {
+        :from    => parse_from($~),
+        :to      => $~[4],
+        :message => $~[5],
+        :command => "NOTICE"
+      }
+    when /\A:([^!]+)!([^@]+)@(\S+) JOIN :(.*)\z/   then
+      {
+        :from    => parse_from($~),
+        :user    => $~[1],
+        :channel => $~[4],
+        :command => "JOIN"
+      }
+    when /\A:(\S+) 353 (\S+) = (\S+) :(.*)\z/             then
+      { 
+        :from    => $~[1],
+        :me      => $~[2],
+        :channel => $~[3],
+        :users   => $~[4].split(" "),
+        :command => 353
+      }
+    when /\A:([^!]+)!([^@]+)@(\S+) NICK :(.*)\z/          then
+      {
+        :from     => parse_from($~),
+        :command  => "NICK",
+        :new_nick => $~[4]
+      }
+    when /\A:([^!]+)!([^@]+)@(\S+) (\S+) (\S+) :(.*)\z/   then
+      {
+        :from    => parse_from($~),
+        :command => $~[4],
+        :to      => $~[5],
+        :message => $~[6]
+      }
+    when /\A:([^!]+)!([^@]+)@(\S+) (\S+) :(.*)\z/         then
+      {
+        :from    => parse_from($~),
+        :command => $~[4],
+        :to      => $~[1],
+        :message => $~[5]
+      }
+    when /\A:(\S+) (\S+) (\S+) (\S+) :(.*)\z/             then
+      {
+        :from    => $~[1],
+        :command => $~[2],
+        :to      => $~[3],
+        :extra   => $~[4],
+        :message => $~[5]
+      }
+    when /\A:(\S+) (\S+) (\S+) :(.*)\z/
+      {
+        :from    => $~[1],
+        :command => $~[2],
+        :to      => $~[3],
+        :message => $~[4]
+    }
+    when /\A:(\S+) (\S+) (\S+) ([^:]+) :(.*)\z/           then
+      {
+        :from    => $~[1],
+        :command => $~[2],
+        :to      => $~[3],
+        :extras  => $~[4].split(' '),
+        :message => $~[5]
+      }
+    else
+      {
+        :extras => line.split(' ')
+      }
+    end.update({ :source => line })
+
+  end
+
+end

data/lib/crazy_doll/plugin_manager.rb

@@ -0,0 +1,286 @@
+module CrazyDoll::PluginManager
+
+  @path = 
+    [
+      File.join(ENV['HOME'], '.crazy_doll', 'plugins'),
+      File.join(File.expand_path(File.dirname(__FILE__)), 'plugins')
+    ]
+  @plugins = { :success => {}, :error => {}, :not_usable => {} }
+
+  class << self
+
+    def path
+      @path
+    end
+
+    def plugins
+      @plugins
+    end
+
+    def register_plugins(event_manager, config, plugins=:all)
+      plugins   = @plugins[:success].map { |k,v| k.to_sym } if plugins == :all
+      registered = []
+      for plugin in plugins
+        if @plugins[:success][plugin]
+          @plugins[:success][plugin][:class].new(event_manager, config)
+          registered << plugin
+        end
+      end
+      registered
+    end
+
+    def load_plugins
+      for path in @path
+        next unless FileTest.directory?(path)
+        for e in Dir.entries(path) - ['.','..']
+          entrie = File.join(path, e)
+          if entrie.match(/_plugin(\.rb)?$/)
+            if FileTest.file?(entrie)
+              load_plugin(entrie)
+            elsif FileTest.directory?(entrie) and FileTest.file?(File.join(entrie, 'plugin.rb'))
+              load_plugin(File.join(entrie, 'plugin.rb'), File.basename(entrie))
+            end
+          end
+        end
+      end
+    end
+
+    def unload_plugins
+      for plugin,info in @plugins[:success]
+        unload_plugin(plugin)
+      end
+      @plugins = { :success => {}, :error => {} }
+      return true
+    end
+
+    def reload_plugins
+      unload_plugins
+      load_plugins
+    end
+
+    def unload_plugin(name)
+      Object.send(:remove_const, name) rescue false
+    end
+
+    def load_plugin(path, file_name=nil)
+      file_name ||= File.basename(path)
+      name = file_name.gsub(/\.rb$/,'').split('_').map { |x| x.capitalize }.join
+      begin
+        load path
+        klass = eval(name)
+        @plugins[:success][name.to_sym] = { :path => path, :class => klass }
+      rescue => e
+        @plugins[:error][name.to_sym] = { :path => path, :error => e }
+      end
+    end
+
+    def find_usable_errors
+      for name, opts in @plugins[:success]
+        config   = opts[:class].config
+        _plugins = config.plugins
+        _gems    = config.gems
+        p = problem_with_plugins?(_plugins)
+        g = problem_with_gems?(_gems)
+        next if p == false and g == false
+        plugin_failed(name, p, g)
+      end
+    end
+
+    def problem_with_plugins?(plugins)
+      return false
+      # errors = []
+      # for plugin in plugins
+      # end
+    end
+
+    def problem_with_gems?(gems)
+      errors = {}
+      for g,opts in gems
+        begin
+          gem g.to_s, opts[:version] || '>= 0'
+          require opts[:lib] || g.to_s
+        rescue Gem::LoadError => e
+          errors[g] = e
+        end
+      end
+      return false if errors.empty?
+      errors
+    end
+
+    def plugin_failed(name, p, g)
+      @plugins[:not_usable][name] = @plugins[:success].delete(name).update({:plugins => p, :gems => g })
+    end
+
+  end
+
+  class Config
+
+    attr_reader :gems, :plugins, :keys, :custom_messages
+    def initialize(klass)
+      @klass = klass
+      @gems, @plugins, @keys, @custom_messages = {}, {}, {}, []
+    end
+
+    def gem(name, opts = {})
+      @gems[name.to_sym] = opts
+    end
+
+    def plugin(name, opts = {})
+      @plugins[name.to_sym] = opts
+    end
+
+    def key(name, value, description='')
+      @keys[name.to_sym] = [description, value]
+    end
+
+    def register(name, line, method, where=[:chan, :priv], regexp=nil)
+      line = '' unless line.is_a?(String)
+      line = "#{name}#{line.empty? ? '' : ' ' + line}"
+      @custom_messages << [regexp || line.to_crazy_doll_regexp, line, method, [where].flatten]
+    end
+
+  end
+
+end
+
+class CrazyDoll::Plugin
+
+  include Net::IRC::Constants
+
+  attr_accessor :opts, :line
+  attr_reader   :params
+  def initialize(manager, config)
+    @manager        = manager
+    @irc            = manager.irc
+    @my_config      = config.config_of self.class.to_s
+    @master_config  = config.config_of 'Core'
+    @config         = config
+    @opts, @line, @params = {}, '', {}
+    register_keys
+    register_events
+    init if respond_to?(:init)
+  end
+
+  def register_events
+    for method in methods.grep(/^(sys|get|put)_/)
+      type, name = method.split('_', 2)
+      @manager.register(type, self, { :method_name => name, :real_method_name => method })
+    end
+    @manager.register(:get, self, { :method_name => :chanmsg, :real_method_name => :custom_messages_chan })
+    @manager.register(:get, self, { :method_name => :privmsg, :real_method_name => :custom_messages_priv })
+  end
+
+  def register_keys
+    for key,opts in self.class.config.keys
+      c.register(self, key, opts[0], opts[1])
+    end
+  end
+
+  def custom_messages(prefix='!', type=:priv)
+    reg = Regexp.new("^#{prefix}")
+    return unless opts.message =~ reg
+    message = opts.message.gsub(reg, '')
+
+    for regexp, original_line, method, where in self.class.config.custom_messages
+      if where.include?(type) and message =~ regexp
+        @params = $~.to_crazy_doll_params(original_line)
+        send(method)
+      end
+    end
+  end
+
+  def custom_messages_chan
+    custom_messages('!', :chan)
+  end
+
+  def custom_messages_priv
+    custom_messages('', :priv)
+  end
+
+  def post(*args)
+    @irc.post(*args)
+  end
+
+  def config
+    @master_config
+  end
+
+  def c
+    @my_config
+  end
+
+  def current_nick
+    config.nick.name
+  end
+
+  def reply_to
+    case opts.command
+    when 'PRIVMSG' then opts.to.match(/^#/) ? opts.to : opts.from.nick
+    when 'JOIN'    then opts.from.nick
+    end
+  end
+
+  def current_channel
+    if opts.respond_to?(:channel)
+      opts.channel
+    elsif opts.respond_to?(:to) and opts.to =~ /^#/
+      opts.to
+    else
+      raise ArgumentError, "opts don't respond to :channel and :to isn't a channel"
+    end
+  end
+
+  def join(chan, pass=nil)
+    post JOIN, chan, pass
+  end
+
+  def say(to, message)
+    post PRIVMSG, to, message
+  end
+
+  def reply(message, with_nick=true)
+    message = parse_message(message)
+    case opts.command
+    when 'PRIVMSG' then say reply_to, message
+    when 'JOIN'    then say current_channel, message
+    else
+      p opts
+      raise ArgumentError, "can't reply"
+    end
+  end
+
+  def get(url)
+    HTTParty.get(url)
+  end
+
+  def parse_message(message)
+    message.
+      gsub('{{me}}',      current_nick).
+      gsub('{{to}}',      reply_to).
+      gsub('{{channel}}', reply_to_a_channel? ? current_channel : '')
+  end
+
+  def reply_to_a_channel?
+    (reply_to || '') =~ /^#/
+  end
+
+  alias :reply_to_a_channel :reply_to_a_channel?
+
+  def talked_with_me?
+    return false unless opts.message
+    opts.message.downcase.include?(current_nick.downcase)
+  end
+
+  alias :talked_with_me :talked_with_me?
+
+  class << self
+
+    def config(&block)
+      @config ||= CrazyDoll::PluginManager::Config.new(self)
+      return @config unless block_given?
+      block.call(@config)
+    end
+
+  end
+
+end

data/lib/crazy_doll/plugins/join_plugin.rb

@@ -0,0 +1,30 @@
+class JoinPlugin < CrazyDoll::Plugin
+
+  config do |c|
+    c.key :channels, [], 'Channels'
+    c.register 'join', '::channel', :join_channel
+  end
+
+  def init
+    c.channels = []
+  end
+
+  def join_all
+    for channel,password in config.channels - c.channels
+      join(channel, password)
+    end
+  end
+
+  def get_rpl_welcome
+    join_all
+  end
+
+  def get_join
+    (c.channels << opts.channel).uniq!
+  end
+
+  def join_channel
+    join(@params.channel)
+  end
+
+end

data/lib/crazy_doll/plugins/nick_plugin.rb

@@ -0,0 +1,77 @@
+class NickPlugin < CrazyDoll::Plugin
+
+  config do |c|
+    c.key :nick,         {},    'Current Bot Nick'
+    c.key :random_nick,  true,  'Using a Random Nick?'
+    c.key :identified,   false, 'Nick are identified?'
+    c.register 'nick', '', :change_nick
+  end
+
+  def init
+    c.identified  = false
+    c.random_nick = true
+  end
+
+  def set_current_nick
+    if c.random_nick?
+      c.nick        = config.nick
+      c.random_nick = false
+    else
+      c.nick        = gen_random_nick
+      c.random_nick = true
+    end
+    send_nick
+    send_user
+  end
+
+  def send_nick(nick=nil)
+    post NICK, nick || c.nick.name
+  end
+
+  def send_user(user=nil, real_name=nil)
+    post USER, user||c.nick.user, "0", "*", real_name||c.nick.real_name
+  end
+
+  def gen_random_nick
+    letters = [*97..122].map { |x| x.chr }
+    OpenStruct.new({ :name => 8.times.map { letters.shuffle[0] }.join, :user => 'CrazyDoll', :real_name => 'CrazyDoll Bot' })
+  end
+
+  def identify(pass=nil)
+    say 'NickServ', "IDENTIFY #{pass||c.nick.password}" if pass or (not c.random_nick and c.nick.password)
+  end
+
+  def sys_socket_start
+    set_current_nick
+  end
+
+  def get_err_unavailresource
+    if opts.extra == c.nick.name
+      set_current_nick
+      identify
+    end
+  end
+
+  def get_rpl_welcome
+    identify
+  end
+
+  def get_ping
+    post PONG, opts.from
+  end
+
+  def get_nick
+    c.nick.name = opts.new_nick
+  end
+
+  def get_version
+    post NOTICE, opts.from.nick, "\x01VERSION CrazyDoll IRC Bot v.#{CrazyDoll::VERSION}\x01"
+  end
+
+  def change_nick
+    return reply "I'm already using my correct nick." if current_nick == config.nick.name
+    set_current_nick
+    identify
+  end
+
+end

data/lib/crazy_doll/plugins/search_plugin.rb

@@ -0,0 +1,15 @@
+class SearchPlugin < CrazyDoll::Plugin
+
+  config do |c|
+    c.gem 'ruby-web-search'
+    c.key :number_of_results, 3, 'Number of results to be displayed'
+    c.register 'g', '**query', :google, [:chan, :priv]
+  end
+
+  def google
+    return if c.number_of_results <= 0
+    reply RubyWebSearch::Google.search(:query => @params.query).results[0..(c.number_of_results-1)].map { |x|
+      "#{CGI.unescapeHTML(x[:title])} - #{x[:url]}" }.join(" | ")
+  end
+
+end

data/lib/crazy_doll/plugins/show_url_info_plugin.rb

@@ -0,0 +1,34 @@
+class ShowUrlInfoPlugin < CrazyDoll::Plugin
+
+  config do |c|
+    c.gem 'nokogiri'
+    c.gem 'httparty'
+    c.key :show_info, true, 'Should show info of urls?'
+  end
+
+  def get_privmsg
+    return unless c.show_info
+    for url in URI::extract(opts.message, ['http','https'])
+      reply url_info(url), false
+    end
+  end
+
+  alias :get_chanmsg :get_privmsg
+
+  def url_info(url)
+    resp = HTTParty::Request.new(Net::HTTP::Head, url)
+    resp.perform
+    lr = resp.last_response
+    if lr['content-type'].include?('text/html')
+      title = (Nokogiri::HTML(get(url))/'title').text
+      title = 'No title' if title.empty?
+      "[Site] #{title}"
+    else
+      file = File.basename(resp.uri.path).gsub(/\?.*/,'')
+      file = 'unknown' if file.empty?
+      "[file] #{file.inspect}, content-type: #{lr['content-type'].inspect}, content-length: #{lr['content-length'].to_i.to_human_readable_size}, " +
+      "last-modified: #{lr['last-modified'].inspect}"
+    end
+  end
+
+end

data/lib/crazy_doll/plugins/welcome_plugin.rb

@@ -0,0 +1,33 @@
+class WelcomePlugin < CrazyDoll::Plugin
+
+  config do |c|
+    c.key :messages, {}, 'Channels and messages'
+    c.register 'welcome', 'ignore ::user',     :add_ignore,     :chan
+    c.register 'welcome', 'message **message', :change_message, :chan
+  end
+
+  def get_join
+    chan = opts.channel
+    setup_chan(chan)
+    reply c.messages[chan][:message] if opts.user != current_nick and not c.messages[chan][:ignore].include?(opts.user) and c.messages[chan][:message]
+  end
+
+  def add_ignore
+    setup_chan(opts.to)
+    return reply "I'm already ignoring #{@params.user}." if c.messages[opts.to][:ignore].include?(@params.user)
+    c.messages[opts.to][:ignore] << @params.user
+    reply "I've started to ignore #{@params.user}"
+  end
+
+  def setup_chan(chan)
+    c.messages[chan] ||= {}
+    c.messages[chan][:ignore] ||= []
+  end
+
+  def change_message
+    setup_chan(opts.to)
+    c.messages[opts.to][:message] = @params.message
+    reply 'Message updated!'
+  end
+
+end

data/lib/crazy_doll/welcome_plugin.rb

@@ -0,0 +1,15 @@
+class WellcomePlugin < CrazyDoll::Plugin
+
+  config do |c|
+    c.key :messages,
+      { '#funrer' => 'Seja bem vindo ao #funrer', '#ubuntugames' => 'Seja bem vindo ao UbuntuGames, o seu canal de jogos :)' },
+      'Canais e mensagens a serem mostradas aos visitantes'
+  end
+
+  def get_join
+    channel = opts.message
+    post PRIVMSG, channel, "#{opts.from.nick}, #{config[:messages][channel]}" if
+        config[:messages][channel] and opts.from.nick != @config[:nick][:current_nick][0]
+  end
+
+end

data/lib/crazy_doll/wizard.rb

@@ -0,0 +1,45 @@
+class CrazyDoll::Wizard
+
+  def initialize(config)
+    @config = config
+    run
+  end
+
+  def run
+    @config.register(self,
+                     :server,
+                     'Address of IRC server',
+                     get("Type the address of server(i.e. irc.freenode.net):", 'irc.freenode.net')) unless @config.respond_to?(:server) and @config.server.is_a?(String)
+    @config.register(self,
+                     :port,
+                     'The port of IRC server',
+                     get("Type the port of server(default 6667):", 6667){|x| Integer(x) rescue 6667 }) unless @config.respond_to?(:port) and @config.port.is_a?(Integer)
+
+    unless @config.respond_to?(:nick) and @config.nick.is_a?(OpenStruct) and @config.nick.name and not @config.nick.name.empty?
+      @config.register(self, :nick, 'Info(nick, user, name, password) of bot', OpenStruct.new({
+        :name => get("Type the nick of bot(default CrazyDoll):", 'CrazyDoll') { |x| x.empty? ? 'CrazyDoll' : x },
+        :user => get("Type the user of bot(default CrazyBot):", 'CrazyBot') { |x| x.empty? ? 'CrazyBot' : x },
+        :real_name => get("Type the 'real name' of bot(default CrazyDoll #{CrazyDoll::VERSION}):",
+                          "CrazyDoll #{CrazyDoll::VERSION}") { |x| x.empty? ? "CrazyDoll #{CrazyDoll::VERSION}" : x },
+        :password  => get("Type the password of bot(default not use):", nil) { |x| x.empty? ? nil : x }
+      }))
+    end
+
+    @config.register(self,
+                     :channels,
+                     'Channels to join',
+                     get("Type the channels to enter separed by comma(i.e. #crazydoll,#ubuntugames):", "#crazydoll") { |chans|
+      chans.gsub(' ','').split(',') }) unless @config.respond_to?(:channels) and @config.channels.is_a?(Array) and not @config.channels.empty?
+  end
+
+  def get(string, default=nil, &block)
+    print string << " "
+    g = gets.chomp
+    g = default if g.empty?
+    if g and block_given?
+      return yield g      
+    end
+    g
+  end
+
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: crazydoll
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Renan Fernandes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-27 00:00:00 -04:00
+default_executable: crazy_doll
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-irc
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 9
+        version: 0.0.9
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 2
+        version: 0.5.2
+  type: :runtime
+  version_requirements: *id002
+description: A plugin oriented IRC bot
+email: renan@kauamanga.com.br
+executables: 
+- crazy_doll
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/crazy_doll.rb
+- lib/crazy_doll/bot.rb
+- lib/crazy_doll/config.rb
+- lib/crazy_doll/config_backend/yaml.rb
+- lib/crazy_doll/core.rb
+- lib/crazy_doll/events.rb
+- lib/crazy_doll/fixes.rb
+- lib/crazy_doll/irc.rb
+- lib/crazy_doll/message.rb
+- lib/crazy_doll/plugin_manager.rb
+- lib/crazy_doll/plugins/join_plugin.rb
+- lib/crazy_doll/plugins/nick_plugin.rb
+- lib/crazy_doll/plugins/search_plugin.rb
+- lib/crazy_doll/plugins/show_url_info_plugin.rb
+- lib/crazy_doll/plugins/welcome_plugin.rb
+- lib/crazy_doll/welcome_plugin.rb
+- lib/crazy_doll/wizard.rb
+- README.md
+has_rdoc: true
+homepage: http://github.com/ShadowBelmolve/crazydoll
+licenses: []
+
+post_install_message: "\n  =================================================================\n    Thanks for installing CrazyDoll\n    If you want to use the 'show_url_info' plugin you'll need to\n    install nokogiri gem\n\n      gem install nokogiri      \n\n  =================================================================\n    "
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A IRC bot
+test_files: []
+