hipbot 1.0.0.rc2 → 1.0.0

data/Gemfile.lock

@@ -1,90 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (3.2.12)
-      i18n (~> 0.6)
-      multi_json (~> 1.0)
-    addressable (2.3.3)
-    coderay (1.0.9)
-    colorize (0.5.8)
-    cookiejar (0.3.0)
-    coveralls (0.6.7)
-      colorize
-      multi_json (~> 1.3)
-      rest-client
-      simplecov (>= 0.7)
-      thor
-    daemons (1.1.9)
-    diff-lcs (1.2.2)
-    em-http-request (1.0.3)
-      addressable (>= 2.2.3)
-      cookiejar
-      em-socksify
-      eventmachine (>= 1.0.0.beta.4)
-      http_parser.rb (>= 0.5.3)
-    em-socksify (0.2.1)
-      eventmachine (>= 1.0.0.beta.4)
-    eventmachine (1.0.3)
-    formatador (0.2.4)
-    guard (1.7.0)
-      formatador (>= 0.2.4)
-      listen (>= 0.6.0)
-      lumberjack (>= 1.0.2)
-      pry (>= 0.9.10)
-      thor (>= 0.14.6)
-    guard-rspec (2.5.2)
-      guard (>= 1.1)
-      rspec (~> 2.11)
-    http_parser.rb (0.5.3)
-    httparty (0.10.2)
-      multi_json (~> 1.0)
-      multi_xml (>= 0.5.2)
-    i18n (0.6.4)
-    listen (0.7.3)
-    lumberjack (1.0.3)
-    metaclass (0.0.1)
-    method_source (0.8.1)
-    mime-types (1.23)
-    mocha (0.13.3)
-      metaclass (~> 0.0.1)
-    multi_json (1.7.2)
-    multi_xml (0.5.3)
-    pry (0.9.12)
-      coderay (~> 1.0.5)
-      method_source (~> 0.8)
-      slop (~> 3.4)
-    rake (10.0.4)
-    rest-client (1.6.7)
-      mime-types (>= 1.16)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.0)
-    simplecov (0.7.1)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.7.1)
-    simplecov-html (0.7.1)
-    slop (3.4.4)
-    thor (0.18.1)
-    xmpp4r (0.5)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport
-  coveralls
-  daemons
-  em-http-request
-  eventmachine
-  guard-rspec
-  httparty
-  i18n
-  mocha
-  rake
-  rspec
-  xmpp4r

data/examples/cleverbot.rb

@@ -1,23 +0,0 @@
-# example bot that simulates intelligence
-# using http://cleverbot.com/ api
-
-require 'hipbot'
-require 'cleverbot'
-require 'htmlentities'
-
-class CleverHipbot < Hipbot::Bot
-  configure do |c|
-    c.jid = ENV['HIPBOT_JID']
-    c.password = ENV['HIPBOT_PASSWORD']
-    c.name = ENV['HIPBOT_NAME']
-  end
-
-  cleverbot = ::Cleverbot::Client.new
-
-  on /(.+)/ do |message|
-    coder = HTMLEntities.new
-    reply(coder.decode(cleverbot.write(message)))
-  end
-end
-
-CleverHipbot.start!

data/examples/google_images.rb

@@ -1,35 +0,0 @@
-# Pull out a random image from the Google Images API and display it
-# Uses: google_image_api http://rubygems.org/gems/google_image_api
-# Author Rushi Vishavadia <rushi.v@gmail.com>
-
-require 'hipbot'
-require 'google_image_api'
-
-class SampleBot < Hipbot::Bot
-  configure do |c|
-    c.jid = ENV['HIPBOT_JID']
-    c.password = ENV['HIPBOT_PASSWORD']
-    c.name = ENV['HIPBOT_NAME']
-  end
-
-  on /\Aimage (.+)/i do |img_str|
-    max = 8 # max number of results you want to pull a random
-    puts img_str
-    begin
-      results = GoogleImageApi.find(img_str, :rsz => max)
-      if results.raw_data["responseStatus"] == 200 and results.images.size > 0
-        reply(results.images.take(max).sample['unescapedUrl'])
-      elsif results.raw_data["responseStatus"] == 200 and results.images.size == 0
-        reply("I'm sorry I couldn't find an image for #{img_str}")
-      else
-        reply("I'm sorry, an error occurred. Try again please") # Most likely a 403
-      end
-    rescue => e
-      reply("I'm sorry, an error occurred trying to find that image")
-      p e.message
-      p e.backtrace
-    end
-  end
-end
-
-SampleBot.start!

data/lib/hipbot/adapters/hipchat/connection.rb

@@ -1,166 +0,0 @@
-module Hipbot
-  module Adapters
-    module Hipchat
-      class Connection
-        def initialize
-          Hipbot.connection = self
-          setup_error_handler && setup_bot && setup_timers
-        end
-
-        def restart!
-          exit_all_rooms # TODO: Nice quit
-          setup_bot
-        end
-
-        def send_to_room(room, message)
-          Hipbot.logger.info("REPLY in #{room}: #{message}")
-          @client.send_message(:groupchat, room.id, message)
-        end
-
-        def send_to_user(user, message)
-          Hipbot.logger.info("REPLY to #{user}: #{message}")
-          @client.send_message(:chat, user.id, message)
-        end
-
-        def set_topic(room, topic)
-          Hipbot.logger.info("TOPIC set in #{room} to '#{topic}'")
-          @client.send_message(:groupchat, room.id, nil, topic)
-        end
-
-        def set_presence(status = nil, type = :available)
-          Hipbot.logger.info("PRESENCE set to #{type} with '#{status}'")
-          @client.set_presence(type, nil, status)
-        end
-
-        protected
-
-        def setup_bot
-          initialize_client do
-            initialize_rooms
-            initialize_users
-            initialize_callbacks
-            set_bot_user
-            join_rooms
-            set_presence('Hello humans!')
-          end
-        end
-
-        def initialize_client
-          @client = ::Jabber::MUC::HipchatClient.new(Hipbot.jid)
-          yield if @client.connect(Hipbot.password)
-        end
-
-        def initialize_rooms
-          @client.get_rooms.each do |room_data|
-            room = Room.find_or_create_by(id: room_data[:item].jid.to_s)
-            room.update_attributes({
-                 name: room_data[:item].iname,
-                topic: room_data[:details]['topic'],
-            })
-          end
-        end
-
-        def initialize_users
-          @client.get_users.each do |user_data|
-            user = User.find_or_create_by(id: user_data.delete(:jid))
-            user.update_attributes(user_data)
-
-            if user.attributes['email'].nil?
-              user.update_attributes(@client.get_user_details(user.id))
-            end
-          end
-        end
-
-        def set_bot_user
-          Hipbot.configuration.user = User[Hipbot.jid]
-          @client.name = Hipbot.user
-        end
-
-        def join_rooms
-          with_rooms do |room|
-            @client.join(room.id)
-          end
-        end
-
-        def exit_all_rooms
-          with_rooms do |room|
-            @client.exit(room.id, 'bye bye!')
-          end
-        end
-
-        def initialize_callbacks
-          @client.on_message{ |*args| message_callback *args }
-          @client.on_private_message{ |*args| private_message_callback *args }
-          @client.on_invite{ |*args| invite_callback *args }
-          @client.on_presence{ |*args| presence_callback *args }
-          @client.activate_callbacks
-        end
-
-        def message_callback room_jid, user_name, message
-          with_sender(room_jid, user_name) do |room, user|
-            room.update_attribute(:topic, message.subject) if message.subject.present?
-            return if user_name == Hipbot.name || message.body.blank?
-            Hipbot.react(user, room, message.body)
-          end
-        end
-
-        def invite_callback room_jid, user_name, room_name, topic
-          Room.create(id: room_jid, name: room_name, topic: topic)
-          @client.join(room_jid)
-        end
-
-        def presence_callback room_jid, user_name, pres
-          with_sender(room_jid, user_name) do |room, user|
-            if pres == 'unavailable'
-              if user_name == Hipbot.name
-                room.delete
-              elsif user.present?
-                room.users.delete(user)
-              end
-            elsif pres.blank? && room.users.exclude?(user)
-              room.users << user
-            end
-          end
-        end
-
-        def private_message_callback user_jid, message
-          with_user(user_jid) do |user|
-            Hipbot.react(user, nil, message.body) if user.name != Hipbot.name
-          end if message.body.present?
-        end
-
-        def with_rooms
-          return Hipbot.logger.error 'No rooms found' if Room.empty?
-          Room.each{ |room| yield room }
-        end
-
-        def with_sender room_id, user_id
-          room = Room[room_id]
-          with_user(user_id) do |user|
-            yield room, user
-          end if room.present?
-        end
-
-        def with_user user_id
-          user = User[user_id]
-          yield user if user
-        end
-
-        def setup_timers
-          ::EM::add_periodic_timer(60) do
-            @client.keep_alive(Hipbot.password) if @client.present?
-          end
-        end
-
-        def setup_error_handler
-          ::EM.error_handler do |e|
-            Hipbot.logger.error e.inspect
-            e.backtrace.each do |line|
-              Hipbot.logger.error line
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hipbot/adapters/hipchat/hipchat.rb

@@ -1,13 +0,0 @@
-module Hipbot
-  module Adapters
-    module Hipchat
-      def start!
-        connection = Connection.new
-      end
-
-      def method_missing(sym, *args, &block)
-        connection.send sym, *args, &block
-      end
-    end
-  end
-end

data/lib/hipbot/adapters/telnet/connection.rb

@@ -1,17 +0,0 @@
-module Hipbot
-  module Adapters
-    module Telnet
-      class Connection < EM::Connection
-        def initialize
-          Hipbot.connection = self
-        end
-
-        def receive_data(data)
-          sender, room, message = data.strip.split(':')
-          Hipbot.react(sender, room, message)
-        end
-      end
-    end
-  end
-end
-

data/lib/hipbot/adapters/telnet/telnet.rb

@@ -1,14 +0,0 @@
-module Hipbot
-  module Adapters
-    module Telnet
-      def send_to_room room, message
-        connection.send_data("#{self}:#{room}:#{message}\n")
-      end
-
-      def start!
-        ::EM::connect('0.0.0.0', 3001, Connection, self)
-      end
-    end
-  end
-end
-

data/lib/hipbot/collection.rb

@@ -1,72 +0,0 @@
-module Hipbot
-  module Collection
-    extend ActiveSupport::Concern
-
-    included do
-      extend ClassMethods
-
-      attr_accessor :id, :name, :attributes
-      alias_method :to_s, :name
-    end
-
-    def initialize params
-      params = params.with_indifferent_access
-      self.id         = params.delete(:id)
-      self.name       = params.delete(:name)
-      self.attributes = params
-    end
-
-    def update_attribute key, value
-      if key == :name
-        self.name = value
-      else
-        self.attributes[key] = value
-      end
-    end
-
-    def update_attributes hash
-      hash.each do |k, v|
-        update_attribute k, v
-      end
-    end
-
-    def delete
-      self.class.collection.delete(self.id)
-    end
-
-    module ClassMethods
-      def create params, &block
-        collection[params[:id]] = new(params, &block)
-      end
-
-      def collection
-        @collection ||= {}
-      end
-
-      def [] *items
-        items.first.is_a?(Array) ? find_many(*items) : find_one(items.first)
-      end
-
-      def find_one item
-        collection[item] || find{ |i| i.name == item }
-      end
-
-      def find_many *items
-        items.flatten!
-        items.map{ |i| find_one(i) }.compact.uniq
-      end
-
-      def find_or_create_by params
-        find_one(params[:id] || params[:name]) || create(params)
-      end
-
-      protected
-
-      def method_missing name, *args, &block
-        return collection.values.public_send(name, *args, &block) if Array.instance_methods.include?(name)
-        super
-      end
-    end
-  end
-end
-

data/lib/hipbot/patches/hipchat_client.rb

@@ -1,230 +0,0 @@
-require 'xmpp4r/muc/x/muc'
-require 'xmpp4r/muc/iq/mucowner'
-require 'xmpp4r/muc/iq/mucadmin'
-require 'xmpp4r/dataforms'
-require 'xmpp4r/roster'
-require 'xmpp4r/vcard'
-
-module Jabber
-  module MUC
-    class HipchatClient
-
-      def initialize(jid)
-        @my_jid  = JID.new(jid)
-
-        @stream = Client.new(@my_jid.strip) # TODO: Error Handling
-        Jabber::debuglog "Stream initialized"
-        @chat_domain = @my_jid.domain
-
-        @presence_cbs = CallbackList.new
-        @message_cbs = CallbackList.new
-        @private_message_cbs = CallbackList.new
-        @invite_cbs = CallbackList.new
-      end
-
-      def join(jid, password = nil, opts = { :history => false })
-        room_jid = JID.new(jid)
-        xmuc = XMUC.new
-        xmuc.password = password
-
-        if !opts[:history]
-          history = REXML::Element.new('history').tap{ |h| h.add_attribute('maxstanzas','0') }
-          xmuc.add_element history
-        end
-
-        room_jid.resource = name
-        set_presence(:available, room_jid, nil, xmuc) # TODO: Handle all join responses
-      end
-
-      def exit(jid, reason = nil)
-        room_jid = JID.new(jid)
-        Jabber::debuglog "Exiting #{jid}"
-        set_presence(:unavailable, room_jid, reason)
-      end
-
-      def keep_alive password
-        if @stream.is_disconnected?
-          connect(password)
-        end
-      end
-
-      def name
-        @my_jid.resource
-      end
-
-      def name= resource
-        @my_jid.resource = resource
-      end
-
-      def on_presence(prio = 0, ref = nil, &block)
-        @presence_cbs.add(prio, ref) do |room_jid, user_name, pres_type|
-          block.call(room_jid, user_name, pres_type)
-          false
-        end
-      end
-
-      def on_message(prio = 0, ref = nil, &block)
-        @message_cbs.add(prio, ref) do |room_jid, user_name, message|
-          block.call(room_jid, user_name, message)
-          false
-        end
-      end
-
-      def on_private_message(prio = 0, ref = nil, &block)
-        @private_message_cbs.add(prio, ref) do |user_jid, message|
-          block.call(user_jid, message)
-          false
-        end
-      end
-
-      def on_invite(prio = 0, ref = nil, &block)
-        @invite_cbs.add(prio, ref) do |room_jid, user_name, room_name, topic|
-          block.call(room_jid, user_name, room_name, topic)
-          false
-        end
-      end
-
-      def set_presence(type, to = nil, reason = nil, xmuc = nil, &block)
-        pres = Presence.new(:chat, reason)
-        pres.type = type
-        pres.to = to if to
-        pres.from = @my_jid
-        pres.add(xmuc) if xmuc
-        @stream.send(pres) { |r| block.call(r) }
-      end
-
-      def kick(recipients, room_jid)
-        iq = Iq.new(:set, room_jid)
-        iq.from = @my_jid
-        iq.add(IqQueryMUCAdmin.new)
-        recipients.each do |recipient|
-          item = IqQueryMUCAdminItem.new
-          item.nick = recipient
-          item.role = :none
-          iq.query.add(item)
-        end
-        @stream.send_with_id(iq)
-      end
-
-      def invite(recipients, room_jid)
-        msg = Message.new
-        msg.from = @my_jid
-        msg.to   = room_jid
-        x = msg.add(XMUCUser.new)
-        recipients.each do |jid|
-          x.add(XMUCUserInvite.new(jid))
-        end
-        @stream.send(msg)
-      end
-
-      def send_message(type, jid, text, subject = nil)
-        message = Message.new(JID.new(jid), text.to_s)
-        message.type = type
-        message.from = @my_jid
-        message.subject = subject
-
-        @send_thread.join if @send_thread.present? && @send_thread.alive?
-        @send_thread = Thread.new {
-          @stream.send(message)
-          sleep(0.2)
-        }
-      end
-
-      def connect password
-        begin
-          @stream.connect
-          Jabber::debuglog "Connected to stream"
-          @stream.auth(password)
-          Jabber::debuglog "Authenticated"
-          @muc_browser = MUCBrowser.new(@stream)
-          Jabber::debuglog "MUCBrowser initialized"
-          @conference_domain = @muc_browser.muc_rooms(@chat_domain).keys.first
-          Jabber::debuglog "No conference domain found" if !@conference_domain.present?
-          @roster = Roster::Helper.new(@stream) # TODO: Error handling
-          @vcard = Vcard::Helper.new(@stream) # TODO: Error handling
-          true
-        rescue => e
-          Jabber::debuglog "Connection failed"
-          false
-        end
-      end
-
-      def activate_callbacks
-        @stream.add_presence_callback(150, self) { |presence|
-          @presence_cbs.process(presence.from.strip.to_s, presence.from.resource, presence.type.to_s)
-        }
-
-        @stream.add_message_callback(150, self) { |message|
-          handle_message(message)
-        }
-        Jabber::debuglog "Callbacks activated"
-      end
-
-      def get_rooms
-        iq = Iq.new(:get, @conference_domain)
-        iq.from = @stream.jid
-        iq.add(Discovery::IqQueryDiscoItems.new)
-
-        rooms = []
-        @stream.send_with_id(iq) do |answer|
-          answer.query.each_element('item') do |item|
-            details = {}
-            item.first.children.each{ |c| details[c.name] = c.text }
-            rooms << {
-              :item    => item,
-              :details => details
-            }
-          end
-        end
-        rooms
-      end
-
-      def get_users
-        @roster.wait_for_roster
-        @roster.items.map do |jid, item|
-          {
-                jid: item.jid.to_s,
-               name: item.iname,
-            mention: item.attributes['mention_name'],
-          }
-        end
-      end
-
-      def get_user_details user_jid
-        vcard = @vcard.get(user_jid)
-        {
-          email: vcard['EMAIL/USERID'],
-          title: vcard['TITLE'],
-          photo: vcard['PHOTO'],
-        }
-      end
-
-      def deactivate_callbacks
-        @stream.delete_presence_callback(self)
-        @stream.delete_message_callback(self)
-        Jabber::debuglog "Callbacks deactivated"
-      end
-
-      private
-
-      def handle_message(message)
-        if is_invite?(message)
-          room_name = message.children.last.first_element_text('name')
-          topic = message.children.last.first_element_text('topic')
-          @invite_cbs.process(message.from.strip.to_s, message.from.resource, room_name, topic)
-        elsif message.type == :chat
-          @private_message_cbs.process(message.from.strip.to_s, message)
-        elsif message.type == :groupchat
-          @message_cbs.process(message.from.strip.to_s, message.from.resource, message)
-        elsif message.type == :error
-          false
-        end
-      end
-
-      def is_invite?(message)
-        !message.x.nil? && message.x.kind_of?(XMUCUser) && message.x.first.kind_of?(XMUCUserInvite)
-      end
-
-    end
-  end
-end