hipbot 1.0.0.rc2 → 1.0.0

data/lib/hipbot/cache.rb

@@ -0,0 +1,23 @@
+module Hipbot
+  module Cache
+    extend ActiveSupport::Concern
+
+    included do
+      extend ClassMethods
+    end
+
+    def _cache
+      @_cache ||= {}
+    end
+
+    module ClassMethods
+      def attr_cache *attributes, &block
+        attributes.each do |attr_name|
+          define_method(attr_name) do
+            _cache[attr_name] ||= block_given? ? instance_eval(&block) : []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/base.rb

@@ -0,0 +1,15 @@
+module Hipbot
+  module Callbacks
+    class Base
+      protected
+
+      def with_room params
+        yield Room.find_or_create_by(params)
+      end
+
+      def with_user params
+        yield User.find_or_create_by(params)
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/invite.rb

@@ -0,0 +1,11 @@
+module Hipbot
+  module Callbacks
+    class Invite < Base
+      def initialize room_id, user_name, room_name, topic
+        with_room(id: room_id, name: room_name, topic: topic) do |room|
+          Hipbot.join_room(room)
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/lobby_presence.rb

@@ -0,0 +1,13 @@
+module Hipbot
+  module Callbacks
+    class LobbyPresence < Presence
+      def initialize user_id, presence
+        self.presence = presence
+
+        with_user(id: user_id) do |user|
+          user.update_attribute(:is_online, online_presence?)
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/message.rb

@@ -0,0 +1,11 @@
+module Hipbot
+  module Callbacks
+    class Message < Base
+      protected
+
+      def ignore_message? sender, message_body
+        message_body.empty? || sender.myself?
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/presence.rb

@@ -0,0 +1,17 @@
+module Hipbot
+  module Callbacks
+    class Presence < Base
+      attr_accessor :presence
+
+      protected
+
+      def online_presence?
+        presence.empty?
+      end
+
+      def offline_presence?
+        presence == 'unavailable'
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/private_message.rb

@@ -0,0 +1,12 @@
+module Hipbot
+  module Callbacks
+    class PrivateMessage < Message
+      def initialize user_id, message_body
+        with_user(id: user_id) do |user|
+          return if ignore_message?(user, message_body)
+          Hipbot.react(user, nil, message_body)
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/room_message.rb

@@ -0,0 +1,21 @@
+module Hipbot
+  module Callbacks
+    class RoomMessage < Message
+      def initialize room_id, user_name, message_body, topic
+        with_room(id: room_id) do |room|
+          update_topic(room, topic)
+          with_user(name: user_name) do |user|
+            return if ignore_message?(user, message_body)
+            Hipbot.react(user, room, message_body)
+          end
+        end
+      end
+
+      protected
+
+      def update_topic room, topic
+        room.update_attribute(:topic, topic) unless topic.empty?
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/room_presence.rb

@@ -0,0 +1,28 @@
+module Hipbot
+  module Callbacks
+    class RoomPresence < Presence
+      attr_accessor :room_id, :user_name
+
+      def initialize room_id, user_name, presence
+        self.presence  = presence
+        self.user_name = user_name
+        self.room_id   = room_id
+        handle_room_presence
+      end
+
+      protected
+
+      def handle_room_presence
+        with_room(id: room_id) do |room|
+          with_user(name: user_name) do |user|
+            if offline_presence?
+              room.on_leave(user)
+            elsif online_presence? && !room.users.include?(user)
+              room.on_join(user)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/configurable.rb

@@ -0,0 +1,22 @@
+module Hipbot
+  module Configurable
+    extend ActiveSupport::Concern
+    attr_accessor :configuration
+
+    delegate *Configuration::OPTIONS, to: :configuration
+
+    included do
+      extend ClassMethods
+    end
+
+    def initialize
+      self.configuration ||= Configuration.new
+    end
+
+    module ClassMethods
+      def configure &block
+        instance.configuration = Configuration.new.tap(&block)
+      end
+    end
+  end
+end

data/lib/hipbot/configuration.rb

@@ -1,18 +1,24 @@
 module Hipbot
   class Configuration
-    attr_accessor *Bot::CONFIGURABLE_OPTIONS
+    OPTIONS = [
+      :adapter, :exception_handler, :helpers, :jid, :join, :logger, :password,
+      :plugins, :preloader, :rooms, :status, :storage, :teams, :user
+    ]
+    attr_accessor *OPTIONS
 
     def initialize
       self.adapter       = Adapters::Hipchat
-      self.error_handler = Proc.new{}
+      self.exception_handler = Proc.new{ |e| Hipbot.logger.error(e) }
       self.helpers       = Module.new
       self.jid           = ''
+      self.join          = :all
       self.logger        = Logger.new($stdout)
       self.password      = ''
       self.plugins       = Hipbot.plugins
       self.preloader     = Proc.new{}
       self.rooms         = {}
-      self.storage       = Collection
+      self.status        = ''
+      self.storage       = Storages::Hash
       self.teams         = {}
     end
 

data/lib/hipbot/helpers.rb

@@ -1,46 +1,10 @@
 module Hipbot
   module Helpers
-    [:get, :post, :put, :delete].each do |http_verb|
-      define_method http_verb do |url, query = {}, &block|
-        Hipbot.logger.info("HTTP-REQUEST: #{url} #{query}")
-        query.merge!({ :head => {'accept-encoding' => 'gzip, compressed'} })
-        conn = ::EM::HttpRequest.new(url, :connect_timeout => 5, :inactivity_timeout => 10)
-        http = conn.send(http_verb, :query => query)
-        http.callback do
-          begin
-            response = HttpResponse.new(http)
-            Hipbot.logger.info("HTTP-RESPONSE: #{response}")
-            block.call(response)
-          rescue => e
-            Hipbot.logger.error(e)
-            instance_exec(e, &Hipbot.error_handler)
-          end
-        end if block.present?
-
-        http.errback do
-          Hipbot.logger.error("HTTP-RESPONSE-ERROR: #{url}")
-        end
-      end
-
-      module_function http_verb
-    end
-
-    class HttpResponse < Struct.new(:raw_response)
-      def body
-        raw_response.response
-      end
-
-      def code
-        raw_response.response_header.status
-      end
-
-      def headers
-        raw_response.response_header
-      end
-
-      def json
-        @json ||= JSON.parse(body)
+    [:get, :post, :put, :delete].each do |method|
+      define_method method do |url, query = {}, &block|
+        Http::Request.new(url, query, method).(&block)
       end
+      module_function method
     end
   end
 end

data/lib/hipbot/http.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Hipbot
+  module Http
+    class Request < Struct.new(:url, :params, :method)
+      DEFAULT_HEADERS     = { 'accept-encoding' => 'gzip, compressed' }.freeze
+      CONNECTION_SETTINGS = { connect_timeout: 5, inactivity_timeout: 10 }.freeze
+      ERROR_CALLBACK      = ->(error){ Hipbot.logger.error(error) }
+
+      def initialize *args
+        super
+        self.params ||= {}
+        self.params = params.has_key?(:query) ? params : { query: params }
+        self.params = { head: DEFAULT_HEADERS }.merge(params)
+        Hipbot.logger.info("HTTP-REQUEST: #{url} #{params}")
+      end
+
+      def call &success_block
+        http.errback(&ERROR_CALLBACK)
+        http.callback do
+          success(&success_block)
+        end unless success_block.nil?
+      end
+
+      protected
+
+      def success
+        yield Http::Response.new(http)
+      rescue => e
+        instance_exec(e, &Hipbot.exception_handler)
+      end
+
+      def http options = {}
+        @http ||= connection.send(method, params.merge(options))
+      end
+
+      def connection
+        @connection ||= EM::HttpRequest.new(url, CONNECTION_SETTINGS)
+      end
+    end
+
+    class Response < Struct.new(:raw_response)
+      def initialize *args
+        super
+        Hipbot.logger.debug("HTTP-RESPONSE: #{body}")
+      end
+
+      def body
+        raw_response.response
+      end
+
+      def code
+        raw_response.response_header.status
+      end
+
+      def headers
+        raw_response.response_header
+      end
+
+      def json
+        binding.pry
+        @json ||= JSON.parse(body) || {}
+      end
+    end
+  end
+end

data/lib/hipbot/match.rb

@@ -1,25 +1,27 @@
 module Hipbot
   class Match < Struct.new(:reaction, :message)
+    include Cache
+
     def matches?
-      matches_regexp? && matches_scope? && matches_sender? && matches_place?
+      matches_scope? && matches_place? && matches_regexp? && matches_sender? && matches_condition?
     end
 
     def invoke
-      Response.new(reaction, message).invoke(params)
+      Response.new(reaction, message).invoke(reaction_parameters)
     end
 
     protected
 
-    def params
-      reaction.anything? ? [message.body] : regexp_match[1..-1]
+    def reaction_parameters
+      reaction.to_anything? ? [message.body] : match_data[1..-1]
     end
 
     def matches_regexp?
-      reaction.anything? || regexp_match.present?
+      reaction.to_anything? || !match_data.nil? || reaction.regexps.empty?
     end
 
-    def regexp_match
-      @regexp_match ||= reaction.regexps.inject(nil) do |result, regexp|
+    attr_cache :match_data do
+      reaction.regexps.inject(nil) do |result, regexp|
         break result if result
         message_text.match(regexp)
       end
@@ -30,19 +32,29 @@ module Hipbot
     end
 
     def matches_place?
-      reaction.anywhere? || (message.room.present? ? matches_room? : reaction.private_message_only?)
+      reaction.from_anywhere? || (message.room.nil? ? reaction.to_private_message? : matches_room?)
     end
 
     def matches_room?
-      reaction.any_room? || reaction.rooms.include?(message.room.name)
+      reaction.in_any_room? || reaction.rooms.include?(message.room.name)
     end
 
     def matches_sender?
       reaction.from_all? || reaction.users.include?(message.sender.name)
     end
 
+    def matches_condition?
+      reaction.condition.(*reaction.condition.parameters.map{ |parameter| message.send(parameter.last) })
+    end
+
     def message_text
       reaction.global? ? message.raw_body : message.body
     end
+
+    class << self
+      def invoke_all matches
+        matches.each(&:invoke)
+      end
+    end
   end
 end

data/lib/hipbot/matchable.rb

@@ -0,0 +1,38 @@
+module Hipbot
+  module Matchable
+    def react sender, room, body
+      message = Message.new(body, room, sender)
+      matches = message_matches(message)
+      Match.invoke_all(matches)
+    end
+
+    def reactions
+      reaction_sets.flatten
+    end
+
+    protected
+
+    def reactables
+      plugins.map(&:class)
+    end
+
+    def reaction_sets
+      reactables.each_with_object([]) do |reactable, array|
+        array.unshift(reactable.reactions)
+        array.push(reactable.default_reactions)
+      end
+    end
+
+    def message_matches message
+      reaction_sets.each do |reactions|
+        matches = reactions_matches(message, reactions)
+        return matches if matches.any?
+      end
+      []
+    end
+
+    def reactions_matches message, reactions
+      reactions.map{ |reaction| reaction.match_with(message) }.select(&:matches?)
+    end
+  end
+end

data/lib/hipbot/message.rb

@@ -1,28 +1,43 @@
+# encoding: utf-8
 module Hipbot
   class Message < Struct.new(:raw_body, :room, :sender)
-    attr_accessor :body, :recipients
+    include Cache
+
+    attr_accessor :body
+
+    MENTION_REGEXP = /@(\p{Word}++)/.freeze
 
     def initialize *args
       super
       Hipbot.logger.info("MESSAGE from #{sender} in #{room}")
-      self.body       = strip_recipient(raw_body)
-      self.recipients = raw_body.scan(/@(\p{Word}++)/).flatten.compact.uniq
+      self.raw_body = raw_body.force_encoding('UTF-8')
+      self.body     = strip_bot_mention
     end
 
-    def for? recipient
-      recipients.include? recipient.mention
+    def for? user
+      recipients.include? user.mention
     end
 
-    def strip_recipient body
-      body.gsub(/^@\p{Word}++[^\p{Word}]*/, '').strip
+    attr_cache :recipients do
+      raw_body.scan(MENTION_REGEXP).flatten.compact.uniq
     end
 
-    def mentions
-      recipients[1..-1] || [] # TODO: Fix global message case
+    attr_cache :mentions do
+      recipients.tap{ |r| r.delete(bot_mention) }
     end
 
     def private?
       room.nil?
     end
+
+    protected
+
+    def bot_mention
+      Hipbot.user.mention
+    end
+
+    def strip_bot_mention
+      raw_body.gsub(/^@#{bot_mention}[^\p{Word}]*/, '')
+    end
   end
 end